diff options
Diffstat (limited to 'pyuno')
68 files changed, 11728 insertions, 0 deletions
diff --git a/pyuno/CustomTarget_python_shell.mk b/pyuno/CustomTarget_python_shell.mk new file mode 100644 index 000000000..541620304 --- /dev/null +++ b/pyuno/CustomTarget_python_shell.mk @@ -0,0 +1,40 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_CustomTarget_CustomTarget,pyuno/python_shell)) + +$(eval $(call gb_CustomTarget_register_targets,pyuno/python_shell,\ + os.sh \ + python.sh \ +)) + +ifeq ($(OS),MACOSX) +pyuno_PYTHON_SHELL_VERSION:=$(PYTHON_VERSION_MAJOR).$(PYTHON_VERSION_MINOR) +else +pyuno_PYTHON_SHELL_VERSION:=$(PYTHON_VERSION) +endif + +$(call gb_CustomTarget_get_workdir,pyuno/python_shell)/python.sh : \ + $(SRCDIR)/pyuno/zipcore/python.sh \ + $(call gb_CustomTarget_get_workdir,pyuno/python_shell)/os.sh + $(call gb_Output_announce,$(subst $(WORKDIR)/,,$@),$(true),CAT,1) + $(call gb_Trace_StartRange,$(subst $(WORKDIR)/,,$@),CAT) + cat $^ > $@ && chmod +x $@ + $(call gb_Trace_EndRange,$(subst $(WORKDIR)/,,$@),CAT) + +$(call gb_CustomTarget_get_workdir,pyuno/python_shell)/os.sh : \ + $(SRCDIR)/pyuno/zipcore/$(if $(filter MACOSX,$(OS)),mac,nonmac).sh \ + $(BUILDDIR)/config_$(gb_Side)/config_python.h + $(call gb_Output_announce,$(subst $(WORKDIR)/,,$@),$(true),SED,1) + $(call gb_Trace_StartRange,$(subst $(WORKDIR)/,,$@),SED) + sed -e "s/%%PYVERSION%%/$(pyuno_PYTHON_SHELL_VERSION)/g" \ + $< > $@ + $(call gb_Trace_EndRange,$(subst $(WORKDIR)/,,$@),SED) + +# vim: set noet sw=4 ts=4: diff --git a/pyuno/CustomTarget_pyuno_pythonloader_ini.mk b/pyuno/CustomTarget_pyuno_pythonloader_ini.mk new file mode 100644 index 000000000..cc5a67f3c --- /dev/null +++ b/pyuno/CustomTarget_pyuno_pythonloader_ini.mk @@ -0,0 +1,38 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_CustomTarget_CustomTarget,pyuno/pythonloader_ini)) + +$(eval $(call gb_CustomTarget_register_targets,pyuno/pythonloader_ini, \ + $(call gb_Helper_get_rcfile,pythonloader.uno) \ +)) + +$(call gb_CustomTarget_get_workdir,pyuno/pythonloader_ini)/$(call gb_Helper_get_rcfile,pythonloader.uno): \ + $(BUILDDIR)/config_$(gb_Side)/config_python.h \ + $(SRCDIR)/pyuno/CustomTarget_pyuno_pythonloader_ini.mk + $(call gb_Output_announce,$(subst $(WORKDIR)/,,$@),$(true),ECH,1) + $(call gb_Trace_StartRange,$(subst $(WORKDIR)/,,$@),ECH) + ( printf '[Bootstrap]\n' && \ + $(if $(SYSTEM_PYTHON),, \ + printf 'PYUNO_LOADER_PYTHONHOME=%s\n' \ + $(if $(filter MACOSX,$(OS)), \ + '$$ORIGIN/../Frameworks/LibreOfficePython.framework', \ + '$$ORIGIN/python-core-$(PYTHON_VERSION)') &&) \ + printf 'PYUNO_LOADER_PYTHONPATH=%s$$ORIGIN\n' \ + $(if $(SYSTEM_PYTHON), \ + '', \ + $(if $(filter MACOSX,$(OS)), \ + '$(foreach dir,/ /lib-dynload /lib-tk /site-packages,$(patsubst %/,%,$$ORIGIN/../Frameworks/LibreOfficePython.framework/Versions/Current/lib/python$(PYTHON_VERSION_MAJOR).$(PYTHON_VERSION_MINOR)$(dir))) ', \ + $(if $(filter WNT,$(OS)), \ + '$(foreach dir,/ /site-packages,$(patsubst %/,%,$$ORIGIN/python-core-$(PYTHON_VERSION)/lib$(dir))) ', \ + '$(foreach dir,/ /lib-dynload /lib-tk /site-packages,$(patsubst %/,%,$$ORIGIN/python-core-$(PYTHON_VERSION)/lib$(dir))) '))) \ + ) > $@ + $(call gb_Trace_EndRange,$(subst $(WORKDIR)/,,$@),ECH) + +# vim: set noet sw=4 ts=4: diff --git a/pyuno/Executable_python.mk b/pyuno/Executable_python.mk new file mode 100644 index 000000000..192d54cf9 --- /dev/null +++ b/pyuno/Executable_python.mk @@ -0,0 +1,22 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_Executable_Executable,python)) + +$(eval $(call gb_Executable_use_static_libraries,python,\ + ooopathutils \ +)) + +$(eval $(call gb_Executable_add_exception_objects,python,\ + pyuno/zipcore/python \ +)) + +$(eval $(call gb_Executable_add_default_nativeres,python)) + +# vim:set noet sw=4 ts=4: diff --git a/pyuno/IwyuFilter_pyuno.yaml b/pyuno/IwyuFilter_pyuno.yaml new file mode 100644 index 000000000..427d6319d --- /dev/null +++ b/pyuno/IwyuFilter_pyuno.yaml @@ -0,0 +1,33 @@ +--- +assumeFilename: pyuno/source/module/pyuno.cxx +blacklist: + pyuno/inc/pyuno.hxx: + # Used in #ifdef + - Python.h + pyuno/source/module/pyuno_impl.hxx: + # Used in #ifdef + - Python.h + # Base class needs complete type + - com/sun/star/lang/XUnoTunnel.hpp + - com/sun/star/script/XInvocation.hpp + # Needed for typedef + - com/sun/star/container/XIndexAccess.hpp + - cppuhelper/weakref.hxx + pyuno/source/loader/pyuno_loader.cxx: + # Don't replace with URE impl. detail + - osl/file.hxx + # Needed for direct memmber access + - com/sun/star/uno/XComponentContext.hpp + pyuno/source/module/pyuno_module.cxx: + # Needed on MACOSX + - config_folders.h + # Don't replace with URE impl. detail + - rtl/bootstrap.hxx + pyuno/source/module/pyuno_runtime.cxx: + # Needed on MACOSX + - config_folders.h + # Needed for direct member access + - com/sun/star/container/XHierarchicalNameAccess.hpp + pyuno/zipcore/python.cxx: + # Needed on WIN32 + - tools/pathutils.hxx diff --git a/pyuno/Library_pythonloader.mk b/pyuno/Library_pythonloader.mk new file mode 100644 index 000000000..adc622ee5 --- /dev/null +++ b/pyuno/Library_pythonloader.mk @@ -0,0 +1,40 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_Library_Library,pythonloader)) + +$(eval $(call gb_Library_set_componentfile,pythonloader,pyuno/source/loader/pythonloader)) + +$(eval $(call gb_Library_set_include,pythonloader,\ + -I$(SRCDIR)/pyuno/source/loader \ + -I$(SRCDIR)/pyuno/inc \ + $$(INCLUDE) \ +)) + +$(eval $(call gb_Library_use_api,pythonloader,\ + udkapi \ +)) + +$(eval $(call gb_Library_use_libraries,pythonloader,\ + cppu \ + cppuhelper \ + pyuno \ + sal \ +)) + +$(eval $(call gb_Library_use_externals,pythonloader,\ + boost_headers \ + python \ +)) + +$(eval $(call gb_Library_add_exception_objects,pythonloader,\ + pyuno/source/loader/pyuno_loader \ +)) + +# vim:set noet sw=4 ts=4: diff --git a/pyuno/Library_pyuno.mk b/pyuno/Library_pyuno.mk new file mode 100644 index 000000000..49c5b9104 --- /dev/null +++ b/pyuno/Library_pyuno.mk @@ -0,0 +1,52 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_Library_Library,pyuno)) + +$(eval $(call gb_Library_set_include,pyuno,\ + -I$(SRCDIR)/pyuno/source/loader \ + -I$(SRCDIR)/pyuno/inc \ + $$(INCLUDE) \ +)) + +$(eval $(call gb_Library_add_defs,pyuno,\ + -DLO_DLLIMPLEMENTATION_PYUNO \ +)) + +$(eval $(call gb_Library_use_api,pyuno,\ + udkapi \ +)) + +$(eval $(call gb_Library_use_libraries,pyuno,\ + cppu \ + cppuhelper \ + sal \ + salhelper \ +)) + +$(eval $(call gb_Library_use_externals,pyuno,\ + boost_headers \ + python \ +)) + +$(eval $(call gb_Library_add_exception_objects,pyuno,\ + pyuno/source/module/pyuno_runtime \ + pyuno/source/module/pyuno \ + pyuno/source/module/pyuno_struct \ + pyuno/source/module/pyuno_callable \ + pyuno/source/module/pyuno_module \ + pyuno/source/module/pyuno_type \ + pyuno/source/module/pyuno_util \ + pyuno/source/module/pyuno_except \ + pyuno/source/module/pyuno_adapter \ + pyuno/source/module/pyuno_gc \ + pyuno/source/module/pyuno_iterator \ +)) + +# vim:set noet sw=4 ts=4: diff --git a/pyuno/Library_pyuno_wrapper.mk b/pyuno/Library_pyuno_wrapper.mk new file mode 100644 index 000000000..4bce8fc00 --- /dev/null +++ b/pyuno/Library_pyuno_wrapper.mk @@ -0,0 +1,48 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_Library_Library,pyuno_wrapper)) + +$(eval $(call gb_Library_set_include,pyuno_wrapper,\ + -I$(SRCDIR)/pyuno/source/module \ + -I$(SRCDIR)/pyuno/inc \ + $$(INCLUDE) \ +)) + +# not using external "python" because we do not want to link against python +$(eval $(call gb_Library_use_externals,pyuno_wrapper,\ + python_headers \ +)) + +# python "import pyuno" dlopens pyuno.so as RTLD_LOCAL, so g++ exception +# handling used to not work, so pyuno.so (pyuno_wrapper) is just a thin wrapper +# that dlopens libpyuno.so as RTLD_GLOBAL; but when pyuno.so wrapper links +# against libstdc++ (which has not previously been loaded into python process), +# that resolves its _ZNSs4_Rep20_S_empty_rep_storageE to itself, but later LO +# libs (loaded though RTLD_GLOBAL libpyuno.so) may resolve that symbol to e.g. +# cppu, because they happen to see that before libstdc++; so the requirement has +# always been that RTLD_LOCAL-loaded pyuno.so wrapper implicitly load into the +# process as little as possible. +# To ensure that pyuno.so does not link against libstdc++ the dynamic link +# command invokes gcc and not g++ if there are only C objects, so +# don't add any C++ objects here! + +ifeq ($(filter DRAGONFLY FREEBSD NETBSD OPENBSD MACOSX,$(OS)),) + +$(eval $(call gb_Library_add_libs,pyuno_wrapper,\ + -ldl \ +)) + +endif + +$(eval $(call gb_Library_add_cobjects,pyuno_wrapper,\ + pyuno/source/module/pyuno_dlopenwrapper \ +)) + +# vim:set noet sw=4 ts=4: diff --git a/pyuno/Makefile b/pyuno/Makefile new file mode 100644 index 000000000..0997e6284 --- /dev/null +++ b/pyuno/Makefile @@ -0,0 +1,14 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +module_directory:=$(dir $(realpath $(firstword $(MAKEFILE_LIST)))) + +include $(module_directory)/../solenv/gbuild/partial_build.mk + +# vim: set noet sw=4 ts=4: diff --git a/pyuno/Module_pyuno.mk b/pyuno/Module_pyuno.mk new file mode 100644 index 000000000..71d7b48e8 --- /dev/null +++ b/pyuno/Module_pyuno.mk @@ -0,0 +1,62 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_Module_Module,pyuno)) + +ifneq ($(DISABLE_PYTHON),TRUE) + +$(eval $(call gb_Module_add_targets,pyuno,\ + CustomTarget_pyuno_pythonloader_ini \ + Library_pyuno \ + Library_pythonloader \ + Package_python_scripts \ + Package_pyuno_pythonloader_ini \ + Rdb_pyuno \ +)) + +ifneq ($(OS),WNT) +$(eval $(call gb_Module_add_targets,pyuno,\ + Library_pyuno_wrapper \ +)) +endif + +# Windows: only --enable-python=internal possible +# python-core: pyuno/python.exe on Windows +ifeq ($(OS),WNT) +$(eval $(call gb_Module_add_targets,pyuno,\ + Executable_python \ +)) +endif + +ifeq ($(SYSTEM_PYTHON),) + +# python-core: python.sh on Unix +ifneq ($(OS),WNT) +$(eval $(call gb_Module_add_targets,pyuno,\ + CustomTarget_python_shell \ + Package_python_shell \ +)) +endif + +endif # SYSTEM_PYTHON + +ifneq ($(OS),MACOSX) +$(eval $(call gb_Module_add_check_targets,pyuno, \ + PythonTest_pyuno_pytests_testssl \ +)) +endif + +$(eval $(call gb_Module_add_subsequentcheck_targets,pyuno, \ + PythonTest_pyuno_pytests_testcollections \ + PythonTest_pyuno_pytests_insertremovecells \ +)) + +endif # DISABLE_PYTHON + +# vim:set noet sw=4 ts=4: diff --git a/pyuno/Package_python_scripts.mk b/pyuno/Package_python_scripts.mk new file mode 100644 index 000000000..0588af370 --- /dev/null +++ b/pyuno/Package_python_scripts.mk @@ -0,0 +1,19 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_Package_Package,pyuno_python_scripts,$(SRCDIR)/pyuno/source)) + +$(eval $(call gb_Package_add_files,pyuno_python_scripts,$(LIBO_LIB_PYUNO_FOLDER),\ + loader/pythonloader.py \ + module/uno.py \ + module/unohelper.py \ + officehelper.py \ +)) + +# vim: set noet sw=4 ts=4: diff --git a/pyuno/Package_python_shell.mk b/pyuno/Package_python_shell.mk new file mode 100644 index 000000000..f75cda39a --- /dev/null +++ b/pyuno/Package_python_shell.mk @@ -0,0 +1,18 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_Package_Package,python_shell,$(call gb_CustomTarget_get_workdir,pyuno/python_shell))) + +ifeq ($(OS),MACOSX) +$(eval $(call gb_Package_add_file,python_shell,$(LIBO_ETC_FOLDER)/python,python.sh)) +else +$(eval $(call gb_Package_add_file,python_shell,$(LIBO_BIN_FOLDER)/python,python.sh)) +endif + +# vim: set noet sw=4 ts=4: diff --git a/pyuno/Package_pyuno_pythonloader_ini.mk b/pyuno/Package_pyuno_pythonloader_ini.mk new file mode 100644 index 000000000..0fae14618 --- /dev/null +++ b/pyuno/Package_pyuno_pythonloader_ini.mk @@ -0,0 +1,16 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_Package_Package,pyuno_pythonloader_ini,$(call gb_CustomTarget_get_workdir,pyuno/pythonloader_ini))) + +$(eval $(call gb_Package_add_files,pyuno_pythonloader_ini,$(LIBO_ETC_FOLDER), \ + $(call gb_Helper_get_rcfile,pythonloader.uno) \ +)) + +# vim: set noet sw=4 ts=4: diff --git a/pyuno/PythonTest_pyuno_pytests_insertremovecells.mk b/pyuno/PythonTest_pyuno_pytests_insertremovecells.mk new file mode 100644 index 000000000..3b3e3c098 --- /dev/null +++ b/pyuno/PythonTest_pyuno_pytests_insertremovecells.mk @@ -0,0 +1,20 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_PythonTest_PythonTest,pyuno_pytests_insertremovecells)) + +$(eval $(call gb_PythonTest_set_defs,pyuno_pytests_insertremovecells,\ + TDOC="$(SRCDIR)/pyuno/qa/pytests/testdocuments" \ +)) + +$(eval $(call gb_PythonTest_add_modules,pyuno_pytests_insertremovecells,$(SRCDIR)/pyuno/qa/pytests,\ + insertremovecells \ +)) + +# vim: set noet sw=4 ts=4: diff --git a/pyuno/PythonTest_pyuno_pytests_testcollections.mk b/pyuno/PythonTest_pyuno_pytests_testcollections.mk new file mode 100644 index 000000000..abd26699c --- /dev/null +++ b/pyuno/PythonTest_pyuno_pytests_testcollections.mk @@ -0,0 +1,27 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_PythonTest_PythonTest,pyuno_pytests_testcollections)) + +$(eval $(call gb_PythonTest_add_modules,pyuno_pytests_testcollections,$(SRCDIR)/pyuno/qa/pytests,\ + testcollections_XIndexAccess \ + testcollections_XIndexReplace \ + testcollections_XIndexContainer \ + testcollections_XNameAccess \ + testcollections_XNameReplace \ + testcollections_XNameContainer \ + testcollections_XEnumerationAccess \ + testcollections_XEnumeration \ + testcollections_XCellRange \ + testcollections_mixednameindex \ + testcollections_misc \ + testcollections_misc2 \ +)) + +# vim: set noet sw=4 ts=4: diff --git a/pyuno/PythonTest_pyuno_pytests_testssl.mk b/pyuno/PythonTest_pyuno_pytests_testssl.mk new file mode 100644 index 000000000..e431af31a --- /dev/null +++ b/pyuno/PythonTest_pyuno_pytests_testssl.mk @@ -0,0 +1,16 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_PythonTest_PythonTest,pyuno_pytests_testssl)) + +$(eval $(call gb_PythonTest_add_modules,pyuno_pytests_testssl,$(SRCDIR)/pyuno/qa/pytests,\ + testssl \ +)) + +# vim: set noet sw=4 ts=4: diff --git a/pyuno/README b/pyuno/README new file mode 100644 index 000000000..4d8839122 --- /dev/null +++ b/pyuno/README @@ -0,0 +1,19 @@ +UNO bindings for the Python programming language. + +To have much joy debugging python extensions you need to: + a) edit pythonloader.py in your install setting DEBUG=1 at the top + b) touch pyuno/source/module/pyuno_runtime.cxx and 'make debug=true' in pyuno + +Then you'll start to see your exceptions on the console instead of them getting +lost at the UNO interface. + +Python also comes with a gdb script +libpython$(PYTHON_VERSION_MAJOR).$(PYTHON_VERSION_MINOR)m.so.1.0-gdb.py +that is copied to instdir and will be auto-loaded by gdb; +it provides commands like "py-bt" to get a python-level backtrace, +and "py-print" to print python variables. + +Another way to debug Python code is to use pdb: edit some initialization +function to insert "import pdb; pdb.set_trace()" (somewhere so that it is +executed early), then run soffice from a terminal and a command-line python +debugger will appear where you can set python-level breakpoints. diff --git a/pyuno/Rdb_pyuno.mk b/pyuno/Rdb_pyuno.mk new file mode 100644 index 000000000..c14185742 --- /dev/null +++ b/pyuno/Rdb_pyuno.mk @@ -0,0 +1,16 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# 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/. +# + +$(eval $(call gb_Rdb_Rdb_install,pyuno)) + +$(eval $(call gb_Rdb_add_components,pyuno, \ + pyuno/source/loader/pythonloader \ +)) + +# vim: set noet sw=4 ts=4: diff --git a/pyuno/demo/Addons.xcu b/pyuno/demo/Addons.xcu new file mode 100644 index 000000000..b3e62f302 --- /dev/null +++ b/pyuno/demo/Addons.xcu @@ -0,0 +1,39 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + * 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 . + --> + +<oor:node xmlns:oor="http://openoffice.org/2001/registry" + xmlns:xs="http://www.w3.org/2001/XMLSchema" + oor:name="Addons" oor:package="org.openoffice.Office"> +<node oor:name="AddonUI"> + <node oor:name="AddonMenu"> + <node oor:name="org.openoffice.comp.pyuno.demo.HelloWorld" oor:op="replace"> + <prop oor:name="URL" oor:type="xs:string"> + <value>service:org.openoffice.comp.pyuno.demo.HelloWorld?insert</value> + </prop> + <prop oor:name="ImageIdentifier" oor:type="xs:string"> + <value>private:image/3216</value> + </prop> + <prop oor:name="Title" oor:type="xs:string"> + <value xml:lang="x-no-translate">Insert Hello World</value> + <value xml:lang="en-US">Insert Hello World</value> + </prop> + </node> + </node> +</node> +</oor:node> diff --git a/pyuno/demo/biblioaccess.py b/pyuno/demo/biblioaccess.py new file mode 100644 index 000000000..0e5d0b4c8 --- /dev/null +++ b/pyuno/demo/biblioaccess.py @@ -0,0 +1,53 @@ +# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-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 . +# + +import uno +from com.sun.star.sdb.CommandType import COMMAND + +def main(): + connectionString = "socket,host=localhost,port=2002" + + url = "uno:" + connectionString + ";urp;StarOffice.ComponentContext" + + localCtx = uno.getComponentContext() + localSmgr = localCtx.ServiceManager + resolver = localSmgr.createInstanceWithContext( + "com.sun.star.bridge.UnoUrlResolver", localCtx) + ctx = resolver.resolve(url) + smgr = ctx.ServiceManager + + rowset =smgr.createInstanceWithContext("com.sun.star.sdb.RowSet", ctx) + rowset.DataSourceName = "Bibliography" + rowset.CommandType = COMMAND + rowset.Command = "SELECT IDENTIFIER, AUTHOR FROM biblio" + + rowset.execute(); + + print("Identifier\tAuthor") + + id = rowset.findColumn("IDENTIFIER") + author = rowset.findColumn("AUTHOR") + while rowset.next(): + print(rowset.getString(id) + "\t" + repr(rowset.getString(author))) + + rowset.dispose(); + +main() + +# vim: set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/demo/hello_world_comp.py b/pyuno/demo/hello_world_comp.py new file mode 100644 index 000000000..646a124a4 --- /dev/null +++ b/pyuno/demo/hello_world_comp.py @@ -0,0 +1,60 @@ +# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-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 . +# + +import uno +import unohelper + +from com.sun.star.task import XJobExecutor + +# implement a UNO component by deriving from the standard unohelper.Base class +# and from the interface(s) you want to implement. +class HelloWorldJob(unohelper.Base, XJobExecutor): + def __init__(self, ctx): + # store the component context for later use + self.ctx = ctx + + def trigger(self, args): + # note: args[0] == "HelloWorld", see below config settings + + # retrieve the desktop object + desktop = self.ctx.ServiceManager.createInstanceWithContext( + "com.sun.star.frame.Desktop", self.ctx) + + # get current document model + model = desktop.getCurrentComponent() + + # access the document's text property + text = model.Text + + # create a cursor + cursor = text.createTextCursor() + + # insert the text into the document + text.insertString(cursor, "Hello World", 0) + +# pythonloader looks for a static g_ImplementationHelper variable +g_ImplementationHelper = unohelper.ImplementationHelper() + +g_ImplementationHelper.addImplementation( \ + HelloWorldJob, # UNO object class + "org.openoffice.comp.pyuno.demo.HelloWorld", # implementation name + ("com.sun.star.task.Job",),) # list of implemented services + # (the only service) + +# vim: set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/demo/makefile.mk b/pyuno/demo/makefile.mk new file mode 100644 index 000000000..11fe66f31 --- /dev/null +++ b/pyuno/demo/makefile.mk @@ -0,0 +1,60 @@ +# +# 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 . +# + +PRJNAME=pyuno +PRJ=.. + +.INCLUDE : settings.mk +.INCLUDE : pyversion.mk + +ROOT=$(MISC)/pyuno-doc + +FILES=\ + $(ROOT)/python-bridge.html \ + $(ROOT)/customized_setup.png \ + $(ROOT)/mode_component.png \ + $(ROOT)/mode_ipc.png \ + $(ROOT)/modes.sxd \ + $(ROOT)/optional_components.png \ + $(ROOT)/samples/swriter.py \ + $(ROOT)/samples/swritercomp.py \ + $(ROOT)/samples/ooextract.py \ + $(ROOT)/samples/biblioaccess.py \ + $(ROOT)/samples/swritercompclient.py \ + $(ROOT)/samples/hello_world_pyuno.zip + + +$(MISC)/pyuno-doc.zip : dirs $(FILES) + -rm -f $@ + cd $(MISC) && zip -r pyuno-doc.zip pyuno-doc + +dirs .PHONY : + -mkdir $(ROOT) + -mkdir $(ROOT)/samples + +$(ROOT)/samples/hello_world_pyuno.zip : hello_world_comp.py Addons.xcu + -rm -f $@ + zip $@ hello_world_comp.py Addons.xcu + +$(ROOT)/samples/% : % + -rm -f $@ + $(COPY) $? $@ + +$(ROOT)/% : ../doc/% + -rm -f $@ + $(COPY) $? $@ diff --git a/pyuno/demo/ooextract.py b/pyuno/demo/ooextract.py new file mode 100644 index 000000000..d6cce94e8 --- /dev/null +++ b/pyuno/demo/ooextract.py @@ -0,0 +1,129 @@ +# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-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 . +# + +import getopt,sys +import uno +from unohelper import Base,systemPathToFileUrl, absolutize +from os import getcwd + +from com.sun.star.beans import PropertyValue +from com.sun.star.beans.PropertyState import DIRECT_VALUE +from com.sun.star.uno import Exception as UnoException +from com.sun.star.io import IOException,XInputStream, XOutputStream + +class OutputStream(Base, XOutputStream): + def __init__(self): + self.closed = 0 + + def closeOutput(self): + self.closed = 1 + + def writeBytes(self, seq): + sys.stdout.write(seq.value) + + def flush(self): + pass + +def main(): + retVal = 0 + doc = None + + try: + opts, args = getopt.getopt(sys.argv[1:], "hc:", ["help", "connection-string=", "html"]) + format = None + url = "uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext" + filterName = "Text (Encoded)" + for o, a in opts: + if o in ("-h", "--help"): + usage() + sys.exit() + if o in ("-c", "--connection-string"): + url = "uno:" + a + ";urp;StarOffice.ComponentContext" + if o == "--html": + filterName = "HTML (StarWriter)" + + print(filterName) + if not len(args): + usage() + sys.exit() + + ctxLocal = uno.getComponentContext() + smgrLocal = ctxLocal.ServiceManager + + resolver = smgrLocal.createInstanceWithContext( + "com.sun.star.bridge.UnoUrlResolver", ctxLocal) + ctx = resolver.resolve(url) + smgr = ctx.ServiceManager + + desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop", ctx) + + cwd = systemPathToFileUrl(getcwd()) + outProps = ( + PropertyValue("FilterName" , 0, filterName, 0), + PropertyValue("OutputStream", 0, OutputStream(), 0)) + inProps = PropertyValue("Hidden", 0 , True, 0), + for path in args: + try: + fileUrl = uno.absolutize(cwd, systemPathToFileUrl(path)) + doc = desktop.loadComponentFromURL(fileUrl , "_blank", 0, inProps) + + if not doc: + raise UnoException("Could not open stream for unknown reason", None) + + doc.storeToURL("private:stream", outProps) + except IOException as e: + sys.stderr.write("Error during conversion: " + e.Message + "\n") + retVal = 1 + except UnoException as e: + sys.stderr.write("Error (" + repr(e.__class__) + ") during conversion: " + e.Message + "\n") + retVal = 1 + if doc: + doc.dispose() + + except UnoException as e: + sys.stderr.write("Error (" + repr(e.__class__) + "): " + e.Message + "\n") + retVal = 1 + except getopt.GetoptError as e: + sys.stderr.write(str(e) + "\n") + usage() + retVal = 1 + + sys.exit(retVal) + +def usage(): + sys.stderr.write("usage: ooextract.py --help |\n"+ + " [-c <connection-string> | --connection-string=<connection-string>\n"+ + " file1 file2 ...\n"+ + "\n" + + "Extracts plain text from documents and prints it to stdout.\n" + + "Requires an OpenOffice.org instance to be running. The script and the\n"+ + "running OpenOffice.org instance must be able to access the file with\n"+ + "by the same system path.\n" + "\n"+ + "-c <connection-string> | --connection-string=<connection-string>\n" + + " The connection-string part of a UNO URL to where the\n" + + " the script should connect to in order to do the conversion.\n" + + " The strings defaults to socket,host=localhost,port=2002\n" + "--html \n" + " Instead of the text filter, the writer html filter is used\n" + ) + +main() + +# vim: set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/demo/pyunoenv.bat b/pyuno/demo/pyunoenv.bat new file mode 100644 index 000000000..b38c61e73 --- /dev/null +++ b/pyuno/demo/pyunoenv.bat @@ -0,0 +1,23 @@ +rem +rem This file is part of the LibreOffice project. +rem +rem This Source Code Form is subject to the terms of the Mozilla Public +rem License, v. 2.0. If a copy of the MPL was not distributed with this +rem file, You can obtain one at http://mozilla.org/MPL/2.0/. +rem +rem This file incorporates work covered by the following license notice: +rem +rem Licensed to the Apache Software Foundation (ASF) under one or more +rem contributor license agreements. See the NOTICE file distributed +rem with this work for additional information regarding copyright +rem ownership. The ASF licenses this file to you under the Apache +rem License, Version 2.0 (the "License"); you may not use this file +rem except in compliance with the License. You may obtain a copy of +rem the License at http://www.apache.org/licenses/LICENSE-2.0 . +rem + +set OOOHOME= + +set PYTHONPATH=.;%OOOHOME%\program;%OOOHOME%\program\pydemo;%OOOHOME%\program\python-2.2.2;%PYTHONPATH% +set PATH=%OOOHOME%\program;%PYTHONHOME%;%OOOHOME%\program\python-2.2.2\bin;%PATH% + diff --git a/pyuno/demo/pyunoenv.tcsh b/pyuno/demo/pyunoenv.tcsh new file mode 100644 index 000000000..653d72a38 --- /dev/null +++ b/pyuno/demo/pyunoenv.tcsh @@ -0,0 +1,49 @@ +# +# 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 . +# +# the path to the office installation (e.g. /home/joe/OpenOffice.org1.1Beta) +setenv OOOHOME /src4/OpenOffice.org1.1Beta2 + +# don't modify anything beyond these lines +#--------------------------------------------- +setenv PYTHONHOME $OOOHOME/program/python + +if( ! $?LD_LIBRARY_PATH ) then + setenv LD_LIBRARY_PATH +endif + +if(! $?PYTHONPATH ) then + setenv PYTHONPATH +endif + +if( ! $?LD_LIBRARY_PATH ) then +setenv LD_LIBRARY_PATH +endif + +if( "$PYTHONPATH" != "" ) then + setenv PYTHONPATH $OOOHOME/program:$OOOHOME/program/pydemo:$OOOHOME/program/python/lib:$PYTHONPATH +else + setenv PYTHONPATH $OOOHOME/program:$OOOHOME/program/pydemo:$OOOHOME/program/python/lib +endif + +setenv LD_LIBRARY_PATH $OOOHOME/program:$LD_LIBRARY_PATH + +if( $?PYTHONHOME ) then +setenv PATH $PYTHONHOME/bin:$PATH +endif + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/demo/swriter.py b/pyuno/demo/swriter.py new file mode 100644 index 000000000..90a53e826 --- /dev/null +++ b/pyuno/demo/swriter.py @@ -0,0 +1,122 @@ +# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-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 . +# + +# bootstrap uno component context +import uno +import unohelper + +from com.sun.star.lang import IllegalArgumentException + +# a UNO struct later needed to create a document +from com.sun.star.text.ControlCharacter import PARAGRAPH_BREAK +from com.sun.star.text.TextContentAnchorType import AS_CHARACTER +from com.sun.star.awt import Size + + +def insertTextIntoCell( table, cellName, text, color ): + tableText = table.getCellByName( cellName ) + cursor = tableText.createTextCursor() + cursor.setPropertyValue( "CharColor", color ) + tableText.setString( text ) + +localContext = uno.getComponentContext() + +resolver = localContext.ServiceManager.createInstanceWithContext( + "com.sun.star.bridge.UnoUrlResolver", localContext ) + +smgr = resolver.resolve( "uno:socket,host=localhost,port=2002;urp;StarOffice.ServiceManager" ) +remoteContext = smgr.getPropertyValue( "DefaultContext" ) + +#remoteContext = resolver.resolve( "uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext" ) +#smgr = remoteContext.ServiceManager + +desktop = smgr.createInstanceWithContext( "com.sun.star.frame.Desktop",remoteContext) + +# open a writer document +doc = desktop.loadComponentFromURL( "private:factory/swriter","_blank", 0, () ) + +text = doc.Text +cursor = text.createTextCursor() +text.insertString( cursor, "The first line in the newly created text document.\n", 0 ) +text.insertString( cursor, "Now we are in the second line\n" , 0 ) + +# create a text table +table = doc.createInstance( "com.sun.star.text.TextTable" ) + +# with 4 rows and 4 columns +table.initialize(4, 4) + +text.insertTextContent( cursor, table, 0 ) +rows = table.Rows + +table.setPropertyValue( "BackTransparent", False ) +table.setPropertyValue( "BackColor", 13421823 ) +row = rows[0] +row.setPropertyValue( "BackTransparent", False ) +row.setPropertyValue( "BackColor", 6710932 ) + +textColor = 16777215 + +insertTextIntoCell( table, "A1", "FirstColumn", textColor ) +insertTextIntoCell( table, "B1", "SecondColumn", textColor ) +insertTextIntoCell( table, "C1", "ThirdColumn", textColor ) +insertTextIntoCell( table, "D1", "SUM", textColor ) + +table.getCellByName("A2").setValue(22.5) +table.getCellByName("B2").setValue(5615.3) +table.getCellByName("C2").setValue(-2315.7) +table.getCellByName("D2").setFormula("sum <A2:C2>") + +table.getCellByName("A3").setValue(21.5) +table.getCellByName("B3").setValue(615.3) +table.getCellByName("C3").setValue(-315.7) +table.getCellByName("D3").setFormula("sum <A3:C3>") + +table.getCellByName("A4").setValue(121.5) +table.getCellByName("B4").setValue(-615.3) +table.getCellByName("C4").setValue(415.7) +table.getCellByName("D4").setFormula("sum <A4:C4>") + + +cursor.setPropertyValue( "CharColor", 255 ) +cursor.setPropertyValue( "CharShadowed", True ) + +text.insertControlCharacter( cursor, PARAGRAPH_BREAK, 0 ) +text.insertString( cursor, " This is a colored Text - blue with shadow\n" , 0 ) +text.insertControlCharacter( cursor, PARAGRAPH_BREAK, 0 ) + +textFrame = doc.createInstance( "com.sun.star.text.TextFrame" ) +textFrame.setSize( Size(15000,400)) +textFrame.setPropertyValue( "AnchorType" , AS_CHARACTER ) + + +text.insertTextContent( cursor, textFrame, 0 ) + +textInTextFrame = textFrame.getText() +cursorInTextFrame = textInTextFrame.createTextCursor() +textInTextFrame.insertString( cursorInTextFrame, "The first line in the newly created text frame.", 0 ) +textInTextFrame.insertString( cursorInTextFrame, "\nWith this second line the height of the rame raises.",0) +text.insertControlCharacter( cursor, PARAGRAPH_BREAK, 0 ) + +cursor.setPropertyValue( "CharColor", 65536 ) +cursor.setPropertyValue( "CharShadowed", False ) + +text.insertString( cursor, " That's all for now!" , 0 ) + +# vim: set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/demo/swritercomp.py b/pyuno/demo/swritercomp.py new file mode 100644 index 000000000..7c200cc7b --- /dev/null +++ b/pyuno/demo/swritercomp.py @@ -0,0 +1,128 @@ +# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-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 . +# + +# just a simple copy of the swriter.py demo, but implemented as a component. The advantage is, +# that the component may run within the office process which may give a performance improvement. + +import unohelper +import uno + +# a UNO struct later needed to create a document +from com.sun.star.text.ControlCharacter import PARAGRAPH_BREAK +from com.sun.star.text.TextContentAnchorType import AS_CHARACTER +from com.sun.star.awt import Size + +from com.sun.star.lang import XMain + +def insertTextIntoCell( table, cellName, text, color ): + tableText = table.getCellByName( cellName ) + cursor = tableText.createTextCursor() + cursor.setPropertyValue( "CharColor", color ) + tableText.setString( text ) + +# the UNO component +# implementing the interface com.sun.star.lang.XMain +# unohelper.Base implements the XTypeProvider interface +class SWriterComp(XMain,unohelper.Base): + def __init__( self, ctx ): + self.ctx = ctx + + # implementation for XMain.run( [in] sequence< any > ) + def run( self,args ): + ctx = self.ctx + smgr = ctx.ServiceManager + desktop = smgr.createInstanceWithContext( "com.sun.star.frame.Desktop",ctx) + + # open a writer document + doc = desktop.loadComponentFromURL( "private:factory/swriter","_blank", 0, () ) + + text = doc.Text + cursor = text.createTextCursor() + text.insertString( cursor, "The first line in the newly created text document.\n", 0 ) + text.insertString( cursor, "Now we are in the second line\n" , 0 ) + + # create a text table + table = doc.createInstance( "com.sun.star.text.TextTable" ) + + # with 4 rows and 4 columns + table.initialize( 4,4) + + text.insertTextContent( cursor, table, 0 ) + rows = table.Rows + + table.setPropertyValue( "BackTransparent", uno.Bool(0) ) + table.setPropertyValue( "BackColor", 13421823 ) + row = rows[0] + row.setPropertyValue( "BackTransparent", uno.Bool(0) ) + row.setPropertyValue( "BackColor", 6710932 ) + + textColor = 16777215 + + insertTextIntoCell( table, "A1", "FirstColumn", textColor ) + insertTextIntoCell( table, "B1", "SecondColumn", textColor ) + insertTextIntoCell( table, "C1", "ThirdColumn", textColor ) + insertTextIntoCell( table, "D1", "SUM", textColor ) + + table.getCellByName("A2").setValue(22.5) + table.getCellByName("B2").setValue(5615.3) + table.getCellByName("C2").setValue(-2315.7) + table.getCellByName("D2").setFormula("sum <A2:C2>") + + table.getCellByName("A3").setValue(21.5) + table.getCellByName("B3").setValue(615.3) + table.getCellByName("C3").setValue(-315.7) + table.getCellByName("D3").setFormula("sum <A3:C3>") + + table.getCellByName("A4").setValue(121.5) + table.getCellByName("B4").setValue(-615.3) + table.getCellByName("C4").setValue(415.7) + table.getCellByName("D4").setFormula("sum <A4:C4>") + + + cursor.setPropertyValue( "CharColor", 255 ) + cursor.setPropertyValue( "CharShadowed", uno.Bool(1) ) + + text.insertControlCharacter( cursor, PARAGRAPH_BREAK, 0 ) + text.insertString( cursor, " This is a colored Text - blue with shadow\n" , 0 ) + text.insertControlCharacter( cursor, PARAGRAPH_BREAK, 0 ) + + textFrame = doc.createInstance( "com.sun.star.text.TextFrame" ) + textFrame.setSize( Size(15000,400)) + textFrame.setPropertyValue( "AnchorType" , AS_CHARACTER ) + + text.insertTextContent( cursor, textFrame, 0 ) + + textInTextFrame = textFrame.getText() + cursorInTextFrame = textInTextFrame.createTextCursor() + textInTextFrame.insertString( cursorInTextFrame, "The first line in the newly created text frame.", 0 ) + textInTextFrame.insertString( cursorInTextFrame, "\nWith this second line the height of the rame raises.",0) + text.insertControlCharacter( cursor, PARAGRAPH_BREAK, 0 ) + + cursor.setPropertyValue( "CharColor", 65536 ) + cursor.setPropertyValue( "CharShadowed", uno.Bool(0) ) + + text.insertString( cursor, " That's all for now!" , 0 ) + return 0 + +# pythonloader looks for a static g_ImplementationHelper variable +g_ImplementationHelper = unohelper.ImplementationHelper() +g_ImplementationHelper.addImplementation( \ + SWriterComp,"org.openoffice.comp.pyuno.swriter",("org.openoffice.demo.SWriter",),) + +# vim: set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/demo/swritercompclient.py b/pyuno/demo/swritercompclient.py new file mode 100644 index 000000000..c4d6cdbf6 --- /dev/null +++ b/pyuno/demo/swritercompclient.py @@ -0,0 +1,32 @@ +# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-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 . +# + +import uno + +localContext = uno.getComponentContext() +resolver = localContext.ServiceManager.createInstanceWithContext( + "com.sun.star.bridge.UnoUrlResolver", localContext ) +remoteContext = resolver.resolve( "uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext" ) +remoteSmgr = remoteContext.ServiceManager + +pyComp = remoteSmgr.createInstanceWithContext( "org.openoffice.demo.SWriter" , remoteContext ) + +pyComp.run( (), ) + +# vim: set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/doc/modes.sxd b/pyuno/doc/modes.sxd Binary files differnew file mode 100644 index 000000000..848912b92 --- /dev/null +++ b/pyuno/doc/modes.sxd diff --git a/pyuno/inc/pyuno.hxx b/pyuno/inc/pyuno.hxx new file mode 100644 index 000000000..f7cab36c7 --- /dev/null +++ b/pyuno/inc/pyuno.hxx @@ -0,0 +1,321 @@ +/* -*- 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 . + */ + +#pragma once + +#ifndef Py_PYTHON_H +#include <Python.h> +#endif // #ifdef Py_PYTHON_H + +#include <com/sun/star/uno/Any.hxx> + +namespace com::sun::star::uno { class XComponentContext; } +namespace com::sun::star::uno { template <typename > class Reference; } + +/** + External interface of the Python UNO bridge. + + This is a C++ interface, because the core UNO components + invocation and proxyfactory are used to implement the bridge. + + This interface is somewhat private and my change in future. + + A scripting framework implementation may use this interface + to do the necessary conversions. +*/ + +#if defined LO_DLLIMPLEMENTATION_PYUNO +#define LO_DLLPUBLIC_PYUNO SAL_DLLPUBLIC_EXPORT +#else +#define LO_DLLPUBLIC_PYUNO SAL_DLLPUBLIC_IMPORT +#endif + +/** function called by the python runtime to initialize the + pyuno module. + + preconditions: python has been initialized before and + the global interpreter lock is held +*/ + +extern "C" LO_DLLPUBLIC_PYUNO PyObject* PyInit_pyuno(); + +namespace pyuno +{ + +enum NotNull +{ + /** definition of a no acquire enum for ctors + */ + NOT_NULL +}; + +/** Helper class for keeping references to python objects. + BEWARE: Look up every python function you use to check + whether you get an acquired or not acquired object pointer + (python terminus for a not acquired object pointer + is 'borrowed reference'). Use in the acquired pointer cases the + PyRef( pointer, SAL_NO_ACQUIRE) ctor. + + precondition: python has been initialized before and + the global interpreter lock is held + +*/ +class PyRef +{ + PyObject *m; +public: + PyRef () : m(nullptr) {} + PyRef( PyObject * p ) : m( p ) { Py_XINCREF( m ); } + + PyRef( PyObject * p, __sal_NoAcquire ) : m( p ) {} + + PyRef( PyObject * p, __sal_NoAcquire, NotNull ) : m( p ) + { + if (!m) + throw std::bad_alloc(); + } + + PyRef(const PyRef &r) : m(r.get()) { Py_XINCREF(m); } + PyRef(PyRef &&r) noexcept : m(r.get()) { r.scratch(); } + + ~PyRef() { Py_XDECREF( m ); } + + PyObject *get() const noexcept { return m; } + + PyObject * getAcquired() const + { + Py_XINCREF( m ); + return m; + } + + PyRef& operator=(const PyRef& r) + { + PyObject *tmp = m; + m = r.getAcquired(); + Py_XDECREF(tmp); + return *this; + } + + PyRef& operator=(PyRef&& r) + { + PyObject *tmp = m; + m = r.get(); + r.scratch(); + Py_XDECREF(tmp); + return *this; + } + + bool operator == ( const PyRef & r ) const + { + return r.get() == m; + } + + /** clears the reference without decreasing the reference count + only seldom needed ! */ + void scratch() noexcept + { + m = nullptr; + } + + /** returns 1 when the reference points to a python object python object, + otherwise 0. + */ + bool is() const + { + return m != nullptr; + } + + struct Hash + { + sal_IntPtr operator () ( const PyRef &r) const { return reinterpret_cast<sal_IntPtr>( r.get() ); } + }; +}; + +//struct stRuntimeImpl; +typedef struct stRuntimeImpl RuntimeImpl; + +enum ConversionMode { ACCEPT_UNO_ANY, REJECT_UNO_ANY }; + + +/** The pyuno::Runtime class keeps the internal state of the python UNO bridge + for the currently in use python interpreter. + + You may keep a Runtime instance, use it from a different thread, etc. But you must + make sure to fulfill all preconditions mentioned for the specific methods. +*/ + +class LO_DLLPUBLIC_PYUNO Runtime +{ + RuntimeImpl *impl; + + /** + Safely unpacks a Python iterator into a sequence, then + stores it in an Any. Used internally by pyObject2Any + */ + bool pyIterUnpack( PyObject *const, css::uno::Any & ) const; +public: + ~Runtime( ); + + /** + preconditions: python has been initialized before, + the global interpreter lock is held and pyuno + has been initialized for the currently used interpreter. + + Note: This method exists for efficiency reasons to save + lookup costs for any2PyObject and pyObject2Any + + @throw RuntimeException in case the runtime has not been + initialized before + */ + Runtime(); + + Runtime( const Runtime & ); + Runtime & operator = ( const Runtime & ); + + /** Initializes the python-UNO bridge. May be called only once per python interpreter. + + @param ctx the component context is used to instantiate bridge services needed + for bridging such as invocation, typeconverter, invocationadapterfactory, etc. + + preconditions: python has been initialized before and + the global interpreter lock is held and pyuno is not + initialized (see isInitialized() ). + + @throw RuntimeException in case the thread is not attached or the runtime + has not been initialized. + */ + static void initialize( + const css::uno::Reference< css::uno::XComponentContext > & ctx ); + + /** Checks, whether the uno runtime is already initialized in the current python interpreter. + + @throws css::uno::RuntimeException + */ + static bool isInitialized(); + + /** converts something contained in a UNO Any to a Python object + + preconditions: python has been initialized before, + the global interpreter lock is held and pyuno::Runtime + has been initialized. + + @throws css::script::CannotConvertException + @throws css::lang::IllegalArgumentException + @throws css::uno::RuntimeException + */ + PyRef any2PyObject (const css::uno::Any &source ) const; + + /** converts a Python object to a UNO any + + preconditions: python has been initialized before, + the global interpreter lock is held and pyuno + has been initialized + + @throws css::uno::RuntimeException + */ + css::uno::Any pyObject2Any ( + const PyRef & source , enum ConversionMode mode = REJECT_UNO_ANY ) const; + + /** extracts a proper uno exception from a given python exception + */ + css::uno::Any extractUnoException( + const PyRef & excType, const PyRef & excValue, const PyRef & excTraceback) const; + + /** Returns the internal handle. Should only be used by the module implementation + */ + RuntimeImpl *getImpl() const { return impl; } +}; + + +/** helper class for attaching the current thread to the python runtime. + + Attaching is done creating a new threadstate for the given interpreter + and acquiring the global interpreter lock. + + Usage: + + ... don't use python here + { + PyThreadAttach guard( PyInterpreterState_Head() ); + { + ... do whatever python code you want + { + PyThreadDetach antiguard; + ... don't use python here + } + ... do whatever python code you want + } + } + ... don't use python here + + Note: The additional scope brackets after the PyThreadAttach are needed, + e.g. when you would leave them away, dtors of potential pyrefs + may be called after the thread has detached again. + */ +class LO_DLLPUBLIC_PYUNO PyThreadAttach +{ + PyThreadState *tstate; + bool m_isNewState; + PyThreadAttach ( const PyThreadAttach & ) = delete; + PyThreadAttach & operator = ( const PyThreadAttach & ) = delete; +public: + + /** Creates a new python threadstate and acquires the global interpreter lock. + precondition: The current thread MUST NOT hold the global interpreter lock. + postcondition: The global interpreter lock is acquired + + @throws css::uno::RuntimeException + in case no pythread state could be created + */ + PyThreadAttach( PyInterpreterState *interp); + + + /** Releases the global interpreter lock and destroys the thread state. + */ + ~PyThreadAttach(); +}; + +/** helper class for detaching the current thread from the python runtime + to do some blocking, non-python related operation. + + @see PyThreadAttach +*/ +class PyThreadDetach +{ + PyThreadState *tstate; + PyThreadDetach ( const PyThreadDetach & ) = delete; + PyThreadDetach & operator = ( const PyThreadDetach & ) = delete; + +public: + /** Releases the global interpreter lock. + + precondition: The current thread MUST hold the global interpreter lock. + postcondition: The current thread does not hold the global interpreter lock anymore. + + @throws css::uno::RuntimeException + */ + PyThreadDetach(); + /** Acquires the global interpreter lock again + */ + ~PyThreadDetach(); +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/qa/pytests/insertremovecells.py b/pyuno/qa/pytests/insertremovecells.py new file mode 100644 index 000000000..f1c0fa176 --- /dev/null +++ b/pyuno/qa/pytests/insertremovecells.py @@ -0,0 +1,80 @@ +import pathlib +import re +import unittest + +from os import getenv, path + +from org.libreoffice.unotest import pyuno, mkPropertyValue, makeCopyFromTDOC + + +class InsertRemoveCells(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.xContext = pyuno.getComponentContext() + pyuno.private_initTestEnvironment() + + def test_fdo74824_load(self): + ctxt = self.xContext + assert(ctxt) + + smgr = ctxt.ServiceManager + desktop = smgr.createInstanceWithContext('com.sun.star.frame.Desktop', ctxt) + load_props = tuple(mkPropertyValue(k, v) for (k, v) in ( + ('Hidden', True), + ('ReadOnly', False) + )) + tdoc_path = makeCopyFromTDOC('fdo74824.ods') + url = pathlib.Path(tdoc_path).as_uri() + doc = desktop.loadComponentFromURL(url, "_blank", 0, load_props) + + sheet = doc.Sheets.Sheet1 + area = sheet.getCellRangeByName('A2:B4') + addr = area.getRangeAddress() + + # 2 = intended to shift cells right, but I don't know where to find + # the ENUM to put in its place. Corrections welcome. + sheet.insertCells(addr, 2) + + # basically, the insertCells call is the test: it should not crash + # LibreOffice. However, for completeness, we should test the cell + # contents as well. + + empty_cells = ( + (0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), + (3, 1), (4, 0), (4, 2), (5, 0), (5, 2), (5, 3), + ) + formula_cells = ( + (2, 0, '=(1+GDR)^-D1', '1.000', 1.0), + (4, 1, '=(1+GDR)^-F2', '0.125', 0.125), + (4, 3, '=SUM(C1:C2)', '1.000', 1.0), + ) + value_cells = ( + (2, 2, '2010', 2010.0), + (2, 3, '7', 7.0), + (3, 0, '0', 0), + (3, 2, '2012', 2012.0), + (3, 3, '6', 6.0), + (5, 1, '1', 1.0), + ) + for pos in empty_cells: + cell = sheet.getCellByPosition(*pos) + self.assertEqual('EMPTY', cell.Type.value) + + for x, y, f, s, val in formula_cells: + cell = sheet.getCellByPosition(x, y) + self.assertEqual('FORMULA', cell.Type.value) + self.assertEqual(f, cell.getFormula()) + self.assertEqual(s, cell.String) + self.assertEqual(val, cell.Value) + + for x, y, s, val in value_cells: + cell = sheet.getCellByPosition(x, y) + self.assertEqual(s, cell.String) + self.assertEqual(val, cell.Value) + + doc.close(True) + + +if __name__ == '__main__': + unittest.main() diff --git a/pyuno/qa/pytests/testcollections_XCellRange.py b/pyuno/qa/pytests/testcollections_XCellRange.py new file mode 100644 index 000000000..3f610ca34 --- /dev/null +++ b/pyuno/qa/pytests/testcollections_XCellRange.py @@ -0,0 +1,401 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from testcollections_base import CollectionsTestBase +from com.sun.star.beans import PropertyValue +from com.sun.star.table import CellAddress + +# TextTable instance factory +def getTextTableInstance(doc): + return doc.createInstance('com.sun.star.text.TextTable') + +# Tests behaviour of objects implementing XCellRange using the new-style +# collection accessors + +class TestXCellRange(CollectionsTestBase): + + # TODO negative indices + + # Tests syntax: + # cell = cellrange[0,0] # Access cell by indices + # For: + # Spreadsheet + # Cell at Row 0, Col 0 + def test_XCellRange_Spreadsheet_Cell_00(self): + # Given + spr = self.createBlankSpreadsheet() + sht = spr.Sheets[0] + + # When + cell = sht[0, 0] + + # Then + self.assertEqual(0, cell.CellAddress.Sheet) + self.assertEqual(0, cell.CellAddress.Row) + self.assertEqual(0, cell.CellAddress.Column) + + spr.close(True) + + # Tests syntax: + # cell = cellrange[0,0] # Access cell by indices + # For: + # Text table + # Cell at Row 0, Col 0 + def test_XCellRange_Table_Cell_00(self): + # Given + doc = self.createBlankTextDocument() + text_table = getTextTableInstance(doc) + text_table.initialize(10, 10) + cursor = doc.Text.createTextCursor() + doc.Text.insertTextContent(cursor, text_table, False) + tbl = doc.TextTables[0] + + # When + cell = tbl[0, 0] + + # Then + self.assertEqual('A1', cell.CellName) + + doc.close(True) + + # Tests syntax: + # cell = cellrange[0,0] # Access cell by indices + # For: + # Spreadsheet + # Cell at Row 3, Col 7 + def test_XCellRange_Spreadsheet_Cell_37(self): + # Given + spr = self.createBlankSpreadsheet() + sht = spr.Sheets[0] + + # When + rng = sht[3, 7] + + # Then + self.assertEqual(0, rng.CellAddress.Sheet) + self.assertEqual(3, rng.CellAddress.Row) + self.assertEqual(7, rng.CellAddress.Column) + + spr.close(True) + + # Tests syntax: + # cell = cellrange[0,0] # Access cell by indices + # For: + # Text table + # Cell at Row 3, Col 7 + def test_XCellRange_Table_Cell_37(self): + # Given + doc = self.createBlankTextDocument() + text_table = getTextTableInstance(doc) + text_table.initialize(10, 10) + cursor = doc.Text.createTextCursor() + doc.Text.insertTextContent(cursor, text_table, False) + tbl = doc.TextTables[0] + + # When + cell = tbl[3, 7] + + # Then + self.assertEqual('H4', cell.CellName) + + doc.close(True) + + # Tests syntax: + # rng = cellrange[0,1:2] # Access cell range by index,slice + # For: + # Spreadsheet + def test_XCellRange_Spreadsheet_Range_Index_Slice(self): + # Given + spr = self.createBlankSpreadsheet() + sht = spr.Sheets[0] + + # When + rng = sht[0, 1:3] + + # Then + self.assertEqual(0, rng.RangeAddress.Sheet) + self.assertEqual(0, rng.RangeAddress.StartRow) + self.assertEqual(1, rng.RangeAddress.StartColumn) + self.assertEqual(0, rng.RangeAddress.EndRow) + self.assertEqual(2, rng.RangeAddress.EndColumn) + + spr.close(True) + + # Tests syntax: + # rng = cellrange[0,1:2] # Access cell range by index,slice + # For: + # Text table + def test_XCellRange_Table_Range_Index_Slice(self): + # Given + doc = self.createBlankTextDocument() + text_table = getTextTableInstance(doc) + text_table.initialize(10, 10) + cursor = doc.Text.createTextCursor() + doc.Text.insertTextContent(cursor, text_table, False) + tbl = doc.TextTables[0] + doc.lockControllers() + tbl.DataArray = tuple(tuple(str(100 + y) for y in range(10*x, 10*x + 10)) for x in range(10)) + doc.unlockControllers() + + # When + rng = tbl[0, 1:3] + + # Then + self.assertEqual((('101', '102'),), rng.DataArray) + + doc.close(True) + + # Tests syntax: + # rng = cellrange[1:2,0] # Access cell range by slice,index + # For: + # Spreadsheet + def test_XCellRange_Spreadsheet_Range_Slice_Index(self): + # Given + spr = self.createBlankSpreadsheet() + sht = spr.Sheets[0] + + # When + rng = sht[1:3, 0] + + # Then + self.assertEqual(0, rng.RangeAddress.Sheet) + self.assertEqual(1, rng.RangeAddress.StartRow) + self.assertEqual(0, rng.RangeAddress.StartColumn) + self.assertEqual(2, rng.RangeAddress.EndRow) + self.assertEqual(0, rng.RangeAddress.EndColumn) + + spr.close(True) + + # Tests syntax: + # rng = cellrange[1:2,0] # Access cell range by index,slice + # For: + # Text table + def test_XCellRange_Table_Range_Slice_Index(self): + # Given + doc = self.createBlankTextDocument() + text_table = getTextTableInstance(doc) + text_table.initialize(10, 10) + cursor = doc.Text.createTextCursor() + doc.Text.insertTextContent(cursor, text_table, False) + tbl = doc.TextTables[0] + doc.lockControllers() + tbl.DataArray = tuple(tuple(str(100 + y) for y in range(10*x, 10*x + 10)) for x in range(10)) + doc.unlockControllers() + + # When + rng = tbl[1:3, 0] + + # Then + self.assertEqual((('110',), ('120',)), rng.DataArray) + + doc.close(True) + + # Tests syntax: + # rng = cellrange[0:1,2:3] # Access cell range by slices + # For: + # Spreadsheet + def test_XCellRange_Spreadsheet_Range_Slices(self): + # Given + spr = self.createBlankSpreadsheet() + sht = spr.Sheets[0] + + # When + rng = sht[1:3, 3:5] + + # Then + self.assertEqual(0, rng.RangeAddress.Sheet) + self.assertEqual(1, rng.RangeAddress.StartRow) + self.assertEqual(3, rng.RangeAddress.StartColumn) + self.assertEqual(2, rng.RangeAddress.EndRow) + self.assertEqual(4, rng.RangeAddress.EndColumn) + + spr.close(True) + + # Tests syntax: + # rng = cellrange[0:1,2:3] # Access cell range by slices + # For: + # Spreadsheet + # Zero rows/columns + def test_XCellRange_Spreadsheet_Range_Slices_Invalid(self): + # Given + spr = self.createBlankSpreadsheet() + sht = spr.Sheets[0] + + # When / Then + with self.assertRaises(KeyError): + rng = sht[1:1, 3:5] + with self.assertRaises(KeyError): + rng = sht[1:3, 3:3] + + spr.close(True) + + # Tests syntax: + # rng = cellrange[0:1,2:3] # Access cell range by slices + # For: + # Text table + def test_XCellRange_Table_Range_Slices(self): + # Given + doc = self.createBlankTextDocument() + text_table = getTextTableInstance(doc) + text_table.initialize(10, 10) + cursor = doc.Text.createTextCursor() + doc.Text.insertTextContent(cursor, text_table, False) + tbl = doc.TextTables[0] + doc.lockControllers() + tbl.DataArray = tuple(tuple(str(100 + y) for y in range(10*x, 10*x + 10)) for x in range(10)) + doc.unlockControllers() + + # When + rng = tbl[1:3, 3:5] + + # Then + self.assertEqual((('113', '114'), ('123', '124')), rng.DataArray) + + doc.close(True) + + # Tests syntax: + # rng = cellrange['A1:B2'] # Access cell range by descriptor + # For: + # Spreadsheet + def test_XCellRange_Spreadsheet_Range_Descriptor(self): + # Given + spr = self.createBlankSpreadsheet() + sht = spr.Sheets[0] + + # When + rng = sht['A3:B4'] + + # Then + self.assertEqual(0, rng.RangeAddress.Sheet) + self.assertEqual(2, rng.RangeAddress.StartRow) + self.assertEqual(0, rng.RangeAddress.StartColumn) + self.assertEqual(3, rng.RangeAddress.EndRow) + self.assertEqual(1, rng.RangeAddress.EndColumn) + + spr.close(True) + + # Tests syntax: + # rng = cellrange['A1:B2'] # Access cell range by descriptor + # For: + # Table + def test_XCellRange_Table_Range_Descriptor(self): + # Given + doc = self.createBlankTextDocument() + text_table = getTextTableInstance(doc) + text_table.initialize(10, 10) + cursor = doc.Text.createTextCursor() + doc.Text.insertTextContent(cursor, text_table, False) + tbl = doc.TextTables[0] + doc.lockControllers() + tbl.DataArray = tuple(tuple(str(100 + y) for y in range(10*x, 10*x + 10)) for x in range(10)) + doc.unlockControllers() + + # When + rng = tbl['A3:B4'] + + # Then + self.assertEqual((('120', '121'), ('130', '131')), rng.DataArray) + + doc.close(True) + + # Tests syntax: + # rng = cellrange['Name'] # Access cell range by name + # For: + # Spreadsheet + def test_XCellRange_Spreadsheet_Range_Name(self): + # Given + spr = self.createBlankSpreadsheet() + sht = spr.Sheets[0] + expr = '$' + sht.Name + '.$C2:F10' + addr = CellAddress(Sheet=0, Row=1, Column=2) + sht.NamedRanges.addNewByName('foo', expr, addr, 0) + + # When + rng = sht['foo'] + + # Then + self.assertEqual(0, rng.RangeAddress.Sheet) + self.assertEqual(1, rng.RangeAddress.StartRow) + self.assertEqual(2, rng.RangeAddress.StartColumn) + self.assertEqual(9, rng.RangeAddress.EndRow) + self.assertEqual(5, rng.RangeAddress.EndColumn) + + spr.close(True) + + # Tests syntax: + # rng = cellrange[0] # Access cell range by row index + # For: + # Spreadsheet + def test_XCellRange_Spreadsheet_Range_RowIndex(self): + # Given + spr = self.createBlankSpreadsheet() + sht = spr.Sheets[0] + + # When + rng = sht[0] + + # Then + self.assertEqual(0, rng.RangeAddress.Sheet) + self.assertEqual(0, rng.RangeAddress.StartRow) + self.assertEqual(0, rng.RangeAddress.StartColumn) + self.assertEqual(0, rng.RangeAddress.EndRow) + self.assertEqual(1023, rng.RangeAddress.EndColumn) + + spr.close(True) + + # Tests syntax: + # rng = cellrange[0,:] # Access cell range by row index + # For: + # Spreadsheet + def test_XCellRange_Spreadsheet_Range_RowIndex_FullSlice(self): + # Given + spr = self.createBlankSpreadsheet() + sht = spr.Sheets[0] + + # When + rng = sht[0, :] + + # Then + self.assertEqual(0, rng.RangeAddress.Sheet) + self.assertEqual(0, rng.RangeAddress.StartRow) + self.assertEqual(0, rng.RangeAddress.StartColumn) + self.assertEqual(0, rng.RangeAddress.EndRow) + self.assertEqual(1023, rng.RangeAddress.EndColumn) + + spr.close(True) + + # Tests syntax: + # rng = cellrange[:,0] # Access cell range by column index + # For: + # Spreadsheet + def test_XCellRange_Spreadsheet_Range_FullSlice_ColumnIndex(self): + # Given + spr = self.createBlankSpreadsheet() + sht = spr.Sheets[0] + + # When + rng = sht[:, 0] + + # Then + self.assertEqual(0, rng.RangeAddress.Sheet) + self.assertEqual(0, rng.RangeAddress.StartRow) + self.assertEqual(0, rng.RangeAddress.StartColumn) + self.assertEqual(1048575, rng.RangeAddress.EndRow) + self.assertEqual(0, rng.RangeAddress.EndColumn) + + spr.close(True) + + +if __name__ == '__main__': + unittest.main() + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testcollections_XEnumeration.py b/pyuno/qa/pytests/testcollections_XEnumeration.py new file mode 100644 index 000000000..8d1f8eece --- /dev/null +++ b/pyuno/qa/pytests/testcollections_XEnumeration.py @@ -0,0 +1,122 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from testcollections_base import CollectionsTestBase +from com.sun.star.beans import PropertyValue + + +# Tests behaviour of objects implementing XEnumeration using the new-style +# collection accessors +# The objects chosen have no special meaning, they just happen to implement the +# tested interfaces + +class TestXEnumeration(CollectionsTestBase): + + # Tests syntax: + # for val in itr: ... # Iteration of named iterator + # For: + # 1 element + def test_XEnumeration_ForIn(self): + # Given + doc = self.createBlankTextDocument() + + # When + paragraphs = [] + itr = iter(doc.Text.createEnumeration()) + for para in itr: + paragraphs.append(para) + + # Then + self.assertEqual(1, len(paragraphs)) + + doc.close(True) + + # Tests syntax: + # if val in itr: ... # Test value presence + # For: + # Present value + def test_XEnumeration_IfIn_Present(self): + # Given + doc = self.createBlankTextDocument() + + # When + paragraph = doc.Text.createEnumeration().nextElement() + itr = iter(doc.Text.createEnumeration()) + result = paragraph in itr + + # Then + self.assertTrue(result) + + doc.close(True) + + # Tests syntax: + # if val in itr: ... # Test value presence + # For: + # Absent value + def test_XEnumeration_IfIn_Absent(self): + # Given + doc1 = self.createBlankTextDocument() + doc2 = self.createBlankTextDocument() + + # When + paragraph = doc2.Text.createEnumeration().nextElement() + itr = iter(doc1.Text.createEnumeration()) + result = paragraph in itr + + # Then + self.assertFalse(result) + + doc1.close(True) + doc2.close(True) + + # Tests syntax: + # if val in itr: ... # Test value presence + # For: + # None + def test_XEnumeration_IfIn_None(self): + # Given + doc = self.createBlankTextDocument() + + # When + itr = iter(doc.Text.createEnumeration()) + result = None in itr + + # Then + self.assertFalse(result) + + doc.close(True) + + # Tests syntax: + # if val in itr: ... # Test value presence + # For: + # Invalid value (string) + # Note: Ideally this would raise TypeError in the same manner as for + # XEnumerationAccess, but an XEnumeration doesn't know the type of its + # values + def test_XEnumeration_IfIn_String(self): + # Given + doc = self.createBlankTextDocument() + + # When + itr = iter(doc.Text.createEnumeration()) + result = 'foo' in itr + + # Then + self.assertFalse(result) + + doc.close(True) + + +if __name__ == '__main__': + unittest.main() + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testcollections_XEnumerationAccess.py b/pyuno/qa/pytests/testcollections_XEnumerationAccess.py new file mode 100644 index 000000000..a62b05ce9 --- /dev/null +++ b/pyuno/qa/pytests/testcollections_XEnumerationAccess.py @@ -0,0 +1,146 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from testcollections_base import CollectionsTestBase +from com.sun.star.beans import PropertyValue + + +# Tests behaviour of objects implementing XEnumerationAccess using the new-style +# collection accessors +# The objects chosen have no special meaning, they just happen to implement the +# tested interfaces + +class TestXEnumerationAccess(CollectionsTestBase): + + # Tests syntax: + # for val in obj: ... # Implicit iterator + # For: + # 1 element + def test_XEnumerationAccess_ForIn(self): + # Given + doc = self.createBlankTextDocument() + + # When + paragraphs = [] + for para in doc.Text: + paragraphs.append(para) + + # Then + self.assertEqual(1, len(paragraphs)) + + doc.close(True) + + # Tests syntax: + # itr = iter(obj) # Named iterator + # For: + # 1 element + def test_XEnumerationAccess_Iter(self): + # Given + doc = self.createBlankTextDocument() + + # When + itr = iter(doc.Text) + + # Then + self.assertIsNotNone(next(itr)) + with self.assertRaises(StopIteration): + next(itr) + + doc.close(True) + + # Tests syntax: + # if val in obj: ... # Test value presence + # For: + # Present value + def test_XEnumerationAccess_IfIn_Present(self): + # Given + doc = self.createBlankTextDocument() + + # When + paragraph = doc.Text.createEnumeration().nextElement() + result = paragraph in doc.Text + + # Then + self.assertTrue(result) + + doc.close(True) + + # Tests syntax: + # if val in obj: ... # Test value presence + # For: + # Absent value + def test_XEnumerationAccess_IfIn_Absent(self): + # Given + doc1 = self.createBlankTextDocument() + doc2 = self.createBlankTextDocument() + + # When + paragraph = doc2.Text.createEnumeration().nextElement() + result = paragraph in doc1.Text + + # Then + self.assertFalse(result) + + doc1.close(True) + doc2.close(True) + + # Tests syntax: + # if val in obj: ... # Test value presence + # For: + # None + def test_XEnumerationAccess_IfIn_None(self): + # Given + doc = self.createBlankTextDocument() + + # When + result = None in doc.Text + + # Then + self.assertFalse(result) + + doc.close(True) + + # Tests syntax: + # if val in obj: ... # Test value presence + # For: + # Invalid value (string) + def test_XEnumerationAccess_IfIn_String(self): + # Given + doc = self.createBlankTextDocument() + + # When + result = 'foo' in doc.Text + + # Then + self.assertFalse(result) + + doc.close(True) + + # Tests syntax: + # if val in obj: ... # Test value presence + # For: + # Invalid value (dict) + def test_XEnumerationAccess_IfIn_String(self): + # Given + doc = self.createBlankTextDocument() + + # When / Then + with self.assertRaises(TypeError): + result = {} in doc.Text + + doc.close(True) + + +if __name__ == '__main__': + unittest.main() + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testcollections_XIndexAccess.py b/pyuno/qa/pytests/testcollections_XIndexAccess.py new file mode 100644 index 000000000..e3eeb45ce --- /dev/null +++ b/pyuno/qa/pytests/testcollections_XIndexAccess.py @@ -0,0 +1,326 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from inspect import isclass + +from testcollections_base import CollectionsTestBase +from com.sun.star.beans import PropertyValue + +# Footnote instance factory +def getFootnoteInstance(doc): + return doc.createInstance("com.sun.star.text.Footnote") + +# Tests behaviour of objects implementing XIndexAccess using the new-style +# collection accessors +# The objects chosen have no special meaning, they just happen to implement the +# tested interfaces + +class TestXIndexAccess(CollectionsTestBase): + + def insertTestFootnotes(self, doc, count): + cursor = doc.Text.createTextCursor() + for i in range(count): + footnote = getFootnoteInstance(doc) + footnote.Label = 'n'+str(i) + doc.Text.insertTextContent(cursor, footnote, 0) + + def readValuesTestFixture(self, doc, count, key, expected): + # Given + doc.Text.setString('') + self.insertTestFootnotes(doc, count) + + # When + captured = None + try: + actual = doc.Footnotes[key] + except Exception as e: + captured = e + + # Then + if isclass(expected) and issubclass(expected, Exception): + # expected is exception + self.assertNotEqual(None, captured) + self.assertEqual(expected.__name__, type(captured).__name__) + elif type(expected) is tuple: + # expected is tuple + self.assertEqual(None, captured) + self.assertTrue(type(actual) is tuple) + self.assertEqual(len(expected), len(actual)) + for i in range(len(expected)): + self.assertEqual('n'+str(expected[i]), actual[i].Label) + else: + # expected is value + self.assertEqual(None, captured) + self.assertTrue(type(actual) is not tuple) + self.assertEqual('n'+str(expected), actual.Label) + + # Tests syntax: + # num = len(obj) # Number of elements + # For: + # length = 0 + def test_XIndexAccess_Len_0(self): + # Given + doc = self.createBlankTextDocument() + + # When + count = len(doc.Footnotes) + + # Then + self.assertEqual(0, count) + + doc.close(True); + + # Tests syntax: + # num = len(obj) # Number of elements + # For: + # length = 1 + def test_XIndexAccess_Len_1(self): + # Given + doc = self.createBlankTextDocument() + cursor = doc.Text.createTextCursor() + footnote = getFootnoteInstance(doc) + doc.Text.insertTextContent(cursor, footnote, 0) + + # When + count = len(doc.Footnotes) + + # Then + self.assertEqual(1, count) + + doc.close(True); + + # Tests syntax: + # val = obj[0] # Access by index + # For: + # Single indices + def test_XIndexAccess_ReadIndex_Single(self): + doc = self.createBlankTextDocument() + self.readValuesTestFixture(doc, 0, -1, IndexError) + self.readValuesTestFixture(doc, 0, 0, IndexError) + self.readValuesTestFixture(doc, 0, 1, IndexError) + self.readValuesTestFixture(doc, 1, -3, IndexError) + self.readValuesTestFixture(doc, 1, -2, IndexError) + self.readValuesTestFixture(doc, 1, -1, 0) + self.readValuesTestFixture(doc, 1, 0, 0) + self.readValuesTestFixture(doc, 1, 1, IndexError) + self.readValuesTestFixture(doc, 1, 2, IndexError) + self.readValuesTestFixture(doc, 2, -4, IndexError) + self.readValuesTestFixture(doc, 2, -3, IndexError) + self.readValuesTestFixture(doc, 2, -2, 0) + self.readValuesTestFixture(doc, 2, -1, 1) + self.readValuesTestFixture(doc, 2, 0, 0) + self.readValuesTestFixture(doc, 2, 1, 1) + self.readValuesTestFixture(doc, 2, 2, IndexError) + self.readValuesTestFixture(doc, 2, 3, IndexError) + doc.close(True); + + def test_XIndexAccess_ReadIndex_Single_Invalid(self): + doc = self.createBlankTextDocument() + self.readValuesTestFixture(doc, 0, None, TypeError) + self.readValuesTestFixture(doc, 0, 'foo', TypeError) + self.readValuesTestFixture(doc, 0, 12.34, TypeError) + self.readValuesTestFixture(doc, 0, (0, 1), TypeError) + self.readValuesTestFixture(doc, 0, [0, 1], TypeError) + self.readValuesTestFixture(doc, 0, {'a': 'b'}, TypeError) + doc.close(True); + + # Tests syntax: + # val1,val2 = obj[2:4] # Access by slice + def test_XIndexAccess_ReadSlice(self): + doc = self.createBlankTextDocument() + test_max = 4 + for i in range(test_max): + t = tuple(range(i)) + for j in [x for x in range(-test_max-2, test_max+3)] + [None]: + for k in [x for x in range(-test_max-2, test_max+3)] + [None]: + key = slice(j, k) + expected = t[key] + self.readValuesTestFixture(doc, i, key, expected) + doc.close(True); + + # Tests syntax: + # val1,val2 = obj[0:3:2] # Access by extended slice + def test_XIndexAccess_ReadExtendedSlice(self): + doc = self.createBlankTextDocument() + test_max = 4 + for i in range(test_max): + t = tuple(range(i)) + for j in [x for x in range(-test_max-2, test_max+3)] + [None]: + for k in [x for x in range(-test_max-2, test_max+3)] + [None]: + for l in [-2, -1, 2]: + key = slice(j, k, l) + expected = t[key] + self.readValuesTestFixture(doc, i, key, expected) + doc.close(True); + + # Tests syntax: + # if val in obj: ... # Test value presence + # For: + # Present element + def test_XIndexAccess_In_Present(self): + # Given + doc = self.createBlankTextDocument() + cursor = doc.Text.createTextCursor() + footnote = getFootnoteInstance(doc) + footnote.setLabel('foo') + doc.Text.insertTextContent(cursor, footnote, 0) + footnote = doc.Footnotes[0] + + # When + present = footnote in doc.Footnotes + + # Then + self.assertTrue(present) + + doc.close(True); + + # Tests syntax: + # if val in obj: ... # Test value presence + # For: + # None + def test_XIndexAccess_In_None(self): + # Given + doc = self.createBlankTextDocument() + + # When + present = None in doc.Footnotes + + # Then + self.assertFalse(present) + + doc.close(True); + + # Tests syntax: + # if val in obj: ... # Test value presence + # For: + # Absent element (string) + def test_XIndexAccess_In_String(self): + # Given + doc = self.createBlankTextDocument() + + # When / Then + present = "foo" in doc.Footnotes + + # Then + self.assertFalse(present) + + doc.close(True); + + # Tests syntax: + # if val in obj: ... # Test value presence + # For: + # Absent element (dict) + def test_XIndexAccess_In_Dict(self): + # Given + doc = self.createBlankTextDocument() + + # When / Then + with self.assertRaises(TypeError): + present = {} in doc.Footnotes + + doc.close(True); + + # Tests syntax: + # for val in obj: ... # Implicit iterator (values) + # For: + # 0 elements + def test_XIndexAccess_ForIn_0(self): + # Given + doc = self.createBlankTextDocument() + + # When + read_footnotes = [] + for f in doc.Footnotes: + read_footnotes.append(f) + + # Then + self.assertEqual(0, len(read_footnotes)) + + doc.close(True); + + # Tests syntax: + # for val in obj: ... # Implicit iterator (values) + # For: + # 1 element + def test_XIndexAccess_ForIn_1(self): + # Given + doc = self.createBlankTextDocument() + cursor = doc.Text.createTextCursor() + footnote = getFootnoteInstance(doc) + footnote.setLabel('foo') + doc.Text.insertTextContent(cursor, footnote, 0) + + # When + read_footnotes = [] + for f in doc.Footnotes: + read_footnotes.append(f) + + # Then + self.assertEqual(1, len(read_footnotes)) + self.assertEqual('foo', read_footnotes[0].Label) + + doc.close(True); + + # Tests syntax: + # for val in obj: ... # Implicit iterator (values) + # For: + # 2 elements + def test_XIndexAccess_ForIn_2(self): + # Given + doc = self.createBlankTextDocument() + cursor = doc.Text.createTextCursor() + footnote1 = getFootnoteInstance(doc) + footnote2 = getFootnoteInstance(doc) + footnote1.setLabel('foo') + footnote2.setLabel('bar') + doc.Text.insertTextContent(cursor, footnote1, 0) + doc.Text.insertTextContent(cursor, footnote2, 0) + + # When + read_footnotes = [] + for f in doc.Footnotes: + read_footnotes.append(f) + + # Then + self.assertEqual(2, len(read_footnotes)) + self.assertEqual('foo', read_footnotes[0].Label) + self.assertEqual('bar', read_footnotes[1].Label) + + doc.close(True); + + # Tests syntax: + # itr = iter(obj) # Named iterator (values) + # For: + # 1 element + def test_XIndexAccess_Iter_0(self): + # Given + doc = self.createBlankTextDocument() + cursor = doc.Text.createTextCursor() + footnote = getFootnoteInstance(doc) + footnote.setLabel('foo') + doc.Text.insertTextContent(cursor, footnote, 0) + + # When + itr = iter(doc.Footnotes) + + # Then + self.assertIsNotNone(next(itr)) + with self.assertRaises(StopIteration): + next(itr) + + doc.close(True); + + +if __name__ == '__main__': + unittest.main() + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testcollections_XIndexContainer.py b/pyuno/qa/pytests/testcollections_XIndexContainer.py new file mode 100644 index 000000000..1df5f0774 --- /dev/null +++ b/pyuno/qa/pytests/testcollections_XIndexContainer.py @@ -0,0 +1,204 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from testcollections_base import CollectionsTestBase +from com.sun.star.beans import PropertyValue + +# DataForm factory +def getDataFormInstance(doc): + return doc.createInstance("com.sun.star.form.component.DataForm") + + +# Tests behaviour of objects implementing XIndexContainer using the new-style +# collection accessors +# The objects chosen have no special meaning, they just happen to implement the +# tested interfaces + +class TestXIndexContainer(CollectionsTestBase): + + def generateTestPropertyValues(self, count): + sm = self.context.ServiceManager + values = sm.createInstanceWithContext("com.sun.star.document.IndexedPropertyValues", self.context) + for i in range(count): + properties = (PropertyValue(Name='n'+str(i), Value='v'+str(i)),) + uno.invoke(values, "insertByIndex", (i, uno.Any("[]com.sun.star.beans.PropertyValue", properties))) + return values + + def generateTestTuple(self, values): + properties = [] + for i in values: + properties.append((PropertyValue(Name='n'+str(i), Value='v'+str(i)),)) + return tuple(properties) + + def assignValuesTestFixture(self, count, key, values, expected): + # Given + property_values = self.generateTestPropertyValues(count) + if type(values) is list: + to_assign = self.generateTestTuple(values) + else: + to_assign = values + if not (isinstance(expected, Exception)): + to_compare = self.generateTestTuple(expected) + + # When + captured = None + try: + property_values[key] = to_assign + except Exception as e: + captured = e + + # Then + if isinstance(expected, Exception): + # expected is exception + self.assertNotEqual(None, captured) + self.assertEqual(type(expected).__name__, type(captured).__name__) + else: + # expected is list + self.assertEqual(None, captured) + self.assertEqual(len(expected), property_values.getCount()) + for i in range(property_values.getCount()): + self.assertEqual(to_compare[i][0].Name, property_values[i][0].Name) + + def deleteValuesTestFixture(self, count, key, expected): + # Given + property_values = self.generateTestPropertyValues(count) + if not (isinstance(expected, Exception)): + to_compare = self.generateTestTuple(expected) + + # When + captured = None + try: + del property_values[key] + except Exception as e: + captured = e + + # Then + if isinstance(expected, Exception): + # expected is exception + self.assertNotEqual(None, captured) + self.assertEqual(type(expected).__name__, type(captured).__name__) + else: + # expected is list + self.assertEqual(None, captured) + self.assertEqual(len(expected), property_values.getCount()) + for i in range(property_values.getCount()): + self.assertEqual(to_compare[i][0].Name, property_values[i][0].Name) + + # Tests syntax: + # obj[2:4] = val1,val2 # Replace by slice + # obj[2:3] = val1,val2 # Insert/replace by slice + # obj[2:2] = (val,) # Insert by slice + # obj[2:4] = (val,) # Replace/delete by slice + # obj[2:3] = () # Delete by slice (implicit) + # For: + # Cases requiring sequence type coercion + def test_XIndexContainer_AssignSlice(self): + base_max = 5 + assign_max = 5 + for i in range(base_max): + for j in [x for x in range(-base_max-2, base_max+3)] + [None]: + for k in [x for x in range(-base_max-2, base_max+3)] + [None]: + key = slice(j, k) + for l in range(assign_max): + assign = [y+100 for y in range(l)] + expected = list(range(i)) + expected[key] = assign + self.assignValuesTestFixture(i, key, assign, expected) + + # Tests syntax: + # obj[2:4] = val1,val2 # Replace by slice + # obj[2:3] = val1,val2 # Insert/replace by slice + # obj[2:2] = (val,) # Insert by slice + # For: + # Cases not requiring sequence type coercion + # Invalid values + def test_XIndexContainer_AssignSlice_Invalid(self): + self.assignValuesTestFixture(2, slice(0, 2), None, TypeError()) + self.assignValuesTestFixture(2, slice(0, 2), 'foo', TypeError()) + self.assignValuesTestFixture(2, slice(0, 2), 12.34, TypeError()) + self.assignValuesTestFixture(2, slice(0, 2), {'a': 'b'}, TypeError()) + self.assignValuesTestFixture(2, slice(0, 2), ('foo',), TypeError()) + self.assignValuesTestFixture(2, slice(0, 2), ('foo', 'foo'), TypeError()) + + # Tests syntax: + # obj[2:2] = (val,) # Insert by slice + # For: + # Cases not requiring sequence type coercion + def test_XIndexContainer_AssignSlice_NoCoercion(self): + # Given + doc = self.createBlankTextDocument() + form = getDataFormInstance(doc) + form.Name = 'foo' + + # When + doc.DrawPage.Forms[0:0] = (form,) + + # Then + self.assertEqual('foo', doc.DrawPage.Forms[0].Name) + + doc.close(True) + + # Tests syntax: + # obj[0:3:2] = val1,val2 # Replace by extended slice + # For: + # Cases requiring sequence type coercion + def test_XIndexContainer_AssignExtendedSlice(self): + base_max = 5 + assign_max = 5 + for i in range(base_max): + for j in [x for x in range(-base_max-2, base_max+3)] + [None]: + for k in [x for x in range(-base_max-2, base_max+3)] + [None]: + for l in [-2, -1, 1, 2]: + key = slice(j, k, l) + for m in range(assign_max): + assign = [y+100 for y in range(m)] + expected = list(range(i)) + try: + expected[key] = assign + except Exception as e: + expected = e + + self.assignValuesTestFixture(i, key, assign, expected) + + # Tests syntax: + # del obj[0] # Delete by index + def test_XIndexContainer_DelIndex(self): + base_max = 5 + for i in range(base_max): + for j in [x for x in range(-base_max-2, base_max+3)]: + expected = list(range(i)) + try: + del expected[j] + except Exception as e: + expected = e + self.deleteValuesTestFixture(i, j, expected) + + # Tests syntax: + # del obj[2:4] # Delete by slice + def test_XIndexContainer_DelSlice(self): + baseMax = 5 + for i in range(baseMax): + for j in [x for x in range(-baseMax-2, baseMax+3)] + [None]: + for k in [x for x in range(-baseMax-2, baseMax+3)] + [None]: + key = slice(j, k) + expected = list(range(i)) + try: + del expected[key] + except Exception as e: + expected = e + self.deleteValuesTestFixture(i, key, expected) + + +if __name__ == '__main__': + unittest.main() + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testcollections_XIndexReplace.py b/pyuno/qa/pytests/testcollections_XIndexReplace.py new file mode 100644 index 000000000..78361cbca --- /dev/null +++ b/pyuno/qa/pytests/testcollections_XIndexReplace.py @@ -0,0 +1,241 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from testcollections_base import CollectionsTestBase +from com.sun.star.beans import PropertyValue + + +# ContentIndex instance factory +def getContentIndexInstance(doc): + return doc.createInstance("com.sun.star.text.ContentIndex") + +# Tests behaviour of objects implementing XIndexReplace using the new-style +# collection accessors +# The objects chosen have no special meaning, they just happen to implement the +# tested interfaces + +class TestXIndexReplace(CollectionsTestBase): + + def generateTestContentIndex(self, doc): + index = getContentIndexInstance(doc) + for i in range(10): + styles = ('n'+str(i),) + uno.invoke(index.LevelParagraphStyles, "replaceByIndex", (i, uno.Any("[]string", styles))) + return index + + def generateTestTuple(self, values): + properties = [] + for i in values: + properties.append(('n'+str(i),),) + return tuple(properties) + + def assignValuesTestFixture(self, doc, key, values, expected): + # Given + index = self.generateTestContentIndex(doc) + to_assign = self.generateTestTuple(values) + if not (isinstance(expected, Exception)): + toCompare = self.generateTestTuple(expected) + + # When + captured = None + try: + index.LevelParagraphStyles[key] = to_assign + except Exception as e: + captured = e + + # Then + if isinstance(expected, Exception): + # expected is exception + self.assertNotEqual(None, captured) + self.assertEqual(type(expected).__name__, type(captured).__name__) + else: + # expected is list + self.assertEqual(None, captured) + for i in range(10): + self.assertEqual(toCompare[i][0], + index.LevelParagraphStyles[i][0]) + + # Tests syntax: + # obj[0] = val # Replace by index + # For: + # Cases requiring sequence type coercion + def test_XIndexReplace_ReplaceIndex(self): + # Given + doc = self.createBlankTextDocument() + index = getContentIndexInstance(doc) + + # When + index.LevelParagraphStyles[0] = ('Caption',) + + # Then + self.assertEqual(('Caption',), index.LevelParagraphStyles[0]) + + doc.close(True) + + # Tests syntax: + # obj[0] = val # Replace by index + # For: + # Invalid value (None) + def test_XIndexReplace_ReplaceIndex_Invalid_None(self): + # Given + doc = self.createBlankTextDocument() + index = getContentIndexInstance(doc) + + # When / Then + with self.assertRaises(TypeError): + index.LevelParagraphStyles[0] = None + + doc.close(True) + + # Tests syntax: + # obj[0] = val # Replace by index + # For: + # Invalid value (String) + def test_XIndexReplace_ReplaceIndex_Invalid_String(self): + # Given + doc = self.createBlankTextDocument() + index = getContentIndexInstance(doc) + + # When / Then + with self.assertRaises(TypeError): + index.LevelParagraphStyles[0] = 'foo' + + doc.close(True) + + # Tests syntax: + # obj[0] = val # Replace by index + # For: + # Invalid value (Float) + def test_XIndexReplace_ReplaceIndex_Invalid_Float(self): + # Given + doc = self.createBlankTextDocument() + index = getContentIndexInstance(doc) + + # When / Then + with self.assertRaises(TypeError): + index.LevelParagraphStyles[0] = 12.34 + + doc.close(True) + + # Tests syntax: + # obj[0] = val # Replace by index + # For: + # Invalid value (List) + def test_XIndexReplace_ReplaceIndex_Invalid_List(self): + # Given + doc = self.createBlankTextDocument() + index = getContentIndexInstance(doc) + + # When / Then + with self.assertRaises(TypeError): + index.LevelParagraphStyles[0] = [0, 1] + + doc.close(True) + + # Tests syntax: + # obj[0] = val # Replace by index + # For: + # Invalid value (Dict) + def test_XIndexReplace_ReplaceIndex_Invalid_Dict(self): + # Given + doc = self.createBlankTextDocument() + index = getContentIndexInstance(doc) + + # When / Then + with self.assertRaises(TypeError): + index.LevelParagraphStyles[0] = {'a': 'b'} + + doc.close(True) + + # Tests syntax: + # obj[0] = val # Replace by index + # For: + # Invalid value (inconsistently typed tuple) + def test_XIndexReplace_ReplaceIndex_Invalid_InconsistentTuple(self): + # Given + doc = self.createBlankTextDocument() + index = getContentIndexInstance(doc) + + # When / Then + with self.assertRaises(TypeError): + index.LevelParagraphStyles[0] = ('Caption', ()) + + doc.close(True) + + # Tests syntax: + # obj[2:4] = val1,val2 # Replace by slice + # For: + # Cases requiring sequence type coercion + def test_XIndexReplace_ReplaceSlice(self): + assign_max = 12 + doc = self.createBlankTextDocument() + t = tuple(range(10)) + for j in [x for x in range(-12, 13)] + [None]: + for k in [x for x in range(-12, 13)] + [None]: + key = slice(j, k) + for l in range(assign_max): + assign = [y+100 for y in range(l)] + expected = list(range(10)) + try: + expected[key] = assign + except Exception as e: + expected = e + if (len(expected) != 10): + expected = ValueError() + self.assignValuesTestFixture(doc, key, assign, expected) + doc.close(True) + + # Tests syntax: + # obj[2:4] = val1,val2 # Replace by slice + # For: + # Invalid values (inconsistently value types in tuple) + def test_XIndexReplace_ReplaceSlice_Invalid_InconsistentTuple(self): + # Given + doc = self.createBlankTextDocument() + index = getContentIndexInstance(doc) + + # When / Then + with self.assertRaises(TypeError): + index.LevelParagraphStyles[0:2] = ( + ('Caption',), + 12.34 + ) + + doc.close(True) + + # Tests syntax: + # obj[0:3:2] = val1,val2 # Replace by extended slice + # For: + # Cases requiring sequence type coercion + def test_XIndexReplace_ReplaceExtendedSlice(self): + assign_max = 12 + doc = self.createBlankTextDocument() + t = tuple(range(10)) + for j in [x for x in range(-12, 13)] + [None]: + for k in [x for x in range(-12, 13)] + [None]: + for l in [-2, -1, 2]: + key = slice(j, k, l) + for m in range(assign_max): + assign = [y+100 for y in range(m)] + expected = list(range(10)) + try: + expected[key] = assign + except Exception as e: + expected = e + self.assignValuesTestFixture(doc, key, assign, expected) + doc.close(True) + + +if __name__ == '__main__': + unittest.main() + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testcollections_XNameAccess.py b/pyuno/qa/pytests/testcollections_XNameAccess.py new file mode 100644 index 000000000..498e17e28 --- /dev/null +++ b/pyuno/qa/pytests/testcollections_XNameAccess.py @@ -0,0 +1,203 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from testcollections_base import CollectionsTestBase +from com.sun.star.beans import PropertyValue + + +# Tests behaviour of objects implementing XNameAccess using the new-style +# collection accessors +# The objects chosen have no special meaning, they just happen to implement the +# tested interfaces + +class TestXNameAccess(CollectionsTestBase): + + # Tests syntax: + # num = len(obj) # Number of keys + # For: + # 2 elements + def test_XNameAccess_Len(self): + # Given + drw = self.createBlankDrawing() + + # When + length = len(drw.Links) + + # Then + self.assertEqual(2, length) + + drw.close(True) + + # Tests syntax: + # val = obj[key] # Access by key + # For: + # 1/2 elements + def test_XNameAccess_ReadKey(self): + # Given + drw = self.createBlankDrawing() + drw.DrawPages[0].Name = 'foo' + + # When + link = drw.Links['foo'] + + # Then + self.assertEqual('foo', link.getName()) + + drw.close(True) + + # Tests syntax: + # val = obj[key] # Access by key + # For: + # Missing key + def test_XNameAccess_ReadKey_Missing(self): + # Given + drw = self.createBlankDrawing() + + # When / Then + with self.assertRaises(KeyError): + link = drw.Links['foo'] + + drw.close(True) + + # Tests syntax: + # val = obj[key] # Access by key + # For: + # Invalid key type (None) + def test_XNameAccess_ReadKey_Invalid_None(self): + # Given + drw = self.createBlankDrawing() + + # When / Then + with self.assertRaises(TypeError): + link = drw.Links[None] + + drw.close(True) + + # Tests syntax: + # val = obj[key] # Access by key + # For: + # Invalid key type (float) + def test_XNameAccess_ReadKey_Invalid_Float(self): + # Given + drw = self.createBlankDrawing() + + # When / Then + with self.assertRaises(TypeError): + link = drw.Links[12.34] + + drw.close(True) + + # Tests syntax: + # val = obj[key] # Access by key + # For: + # Invalid key type (tuple) + def test_XNameAccess_ReadKey_Invalid_Tuple(self): + # Given + drw = self.createBlankDrawing() + + # When / Then + with self.assertRaises(TypeError): + link = drw.Links[(1, 2)] + + drw.close(True) + + # Tests syntax: + # val = obj[key] # Access by key + # For: + # Invalid key type (list) + def test_XNameAccess_ReadKey_Invalid_List(self): + # Given + drw = self.createBlankDrawing() + + # When / Then + with self.assertRaises(TypeError): + link = drw.Links[[1, 2]] + + drw.close(True) + + # Tests syntax: + # val = obj[key] # Access by key + # For: + # Invalid key type (dict) + def test_XNameAccess_ReadKey_Invalid_Dict(self): + # Given + drw = self.createBlankDrawing() + + # When / Then + with self.assertRaises(TypeError): + link = drw.Links[{'a': 'b'}] + + drw.close(True) + + # Tests syntax: + # if key in obj: ... # Test key presence + # For: + # 1/2 elements + def test_XNameAccess_In(self): + # Given + drw = self.createBlankDrawing() + drw.DrawPages[0].Name = 'foo' + + # When + present = 'foo' in drw.Links + + # Then + self.assertTrue(present) + + drw.close(True) + + # Tests syntax: + # for key in obj: ... # Implicit iterator (keys) + # For: + # 2 elements + def test_XNameAccess_ForIn(self): + # Given + drw = self.createBlankDrawing() + i = 0 + for name in drw.Links.getElementNames(): + drw.Links.getByName(name).Name = 'foo' + str(i) + i += 1 + + # When + read_links = [] + for link in drw.Links: + read_links.append(link) + + # Then + self.assertEqual(['foo0', 'foo1'], read_links) + + drw.close(True) + + # Tests syntax: + # itr = iter(obj) # Named iterator (keys) + # For: + # 2 elements + def test_XNameAccess_Iter(self): + # Given + drw = self.createBlankDrawing() + + # When + itr = iter(drw.Links) + + # Then + self.assertIsNotNone(next(itr)) + self.assertIsNotNone(next(itr)) + with self.assertRaises(StopIteration): + next(itr) + + drw.close(True) + + +if __name__ == '__main__': + unittest.main() + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testcollections_XNameContainer.py b/pyuno/qa/pytests/testcollections_XNameContainer.py new file mode 100644 index 000000000..c544ca9dd --- /dev/null +++ b/pyuno/qa/pytests/testcollections_XNameContainer.py @@ -0,0 +1,132 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from testcollections_base import CollectionsTestBase +from com.sun.star.beans import PropertyValue + +# SheetCellRanges instance factory +def getSheetCellRangesInstance(spr): + return spr.createInstance("com.sun.star.sheet.SheetCellRanges") + + +# Tests behaviour of objects implementing XNameContainer using the new-style +# collection accessors +# The objects chosen have no special meaning, they just happen to implement the +# tested interfaces + +class TestXNameContainer(CollectionsTestBase): + + # Tests syntax: + # obj[key] = val # Insert by key + # For: + # 0->1 element + def test_XNameContainer_InsertName(self): + # Given + spr = self.createBlankSpreadsheet() + ranges = getSheetCellRangesInstance(spr) + new_range = spr.Sheets[0].getCellRangeByPosition(1, 2, 1, 2) + + # When + ranges['foo'] = new_range + + # Then + self.assertEqual(1, len(ranges.ElementNames)) + + spr.close(True) + + # Tests syntax: + # obj[key] = val # Insert by key + # For: + # Invalid key + def test_XNameContainer_InsertName_Invalid(self): + # Given + spr = self.createBlankSpreadsheet() + ranges = getSheetCellRangesInstance(spr) + new_range = spr.Sheets[0].getCellRangeByPosition(1, 2, 1, 2) + + # When / Then + with self.assertRaises(TypeError): + ranges[12.34] = new_range + + spr.close(True) + + # Tests syntax: + # obj[key] = val # Replace by key + def test_XNameContainer_ReplaceName(self): + # Given + spr = self.createBlankSpreadsheet() + ranges = getSheetCellRangesInstance(spr) + new_range1 = spr.Sheets[0].getCellRangeByPosition(1, 2, 1, 2) + new_range2 = spr.Sheets[0].getCellRangeByPosition(6, 6, 6, 6) + + # When + ranges['foo'] = new_range1 + ranges['foo'] = new_range2 + + # Then + self.assertEqual(1, len(ranges.ElementNames)) + read_range = ranges['foo'] + self.assertEqual(6, read_range.CellAddress.Column) + + spr.close(True) + + # Tests syntax: + # del obj[key] # Delete by key + # For: + # 1/2 elements + def test_XNameContainer_DelKey(self): + # Given + spr = self.createBlankSpreadsheet() + spr.Sheets.insertNewByName('foo', 1) + + # When + del spr.Sheets['foo'] + + # Then + self.assertEqual(1, len(spr.Sheets)) + self.assertFalse('foo' in spr.Sheets) + + spr.close(True) + + # Tests syntax: + # del obj[key] # Delete by key + # For: + # Missing key + def test_XNameContainer_DelKey_Missing(self): + # Given + spr = self.createBlankSpreadsheet() + + # When / Then + with self.assertRaises(KeyError): + del spr.Sheets['foo'] + + spr.close(True) + + # Tests syntax: + # del obj[key] # Delete by key + # For: + # Invalid key (float) + def test_XNameContainer_DelKey_Invalid(self): + # Given + spr = self.createBlankSpreadsheet() + + # When / Then + with self.assertRaises(TypeError): + del spr.Sheets[12.34] + + spr.close(True) + + +if __name__ == '__main__': + unittest.main() + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testcollections_XNameReplace.py b/pyuno/qa/pytests/testcollections_XNameReplace.py new file mode 100644 index 000000000..18476fd2b --- /dev/null +++ b/pyuno/qa/pytests/testcollections_XNameReplace.py @@ -0,0 +1,79 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from testcollections_base import CollectionsTestBase +from com.sun.star.beans import PropertyValue + + +def getScriptName(): + return 'macro://Standard.Module1.MySave()' + +# Tests behaviour of objects implementing XNameReplace using the new-style +# collection accessors +# The objects chosen have no special meaning, they just happen to implement the +# tested interfaces + +class TestXNameReplace(CollectionsTestBase): + + # Tests syntax: + # obj[key] = val # Replace by key + # For: + # 1 element + def test_XNameReplace_ReplaceName(self): + # Given + doc = self.createBlankTextDocument() + event_properties = (PropertyValue(Name='Script', Value=getScriptName()),) + + # When + doc.Events['OnSave'] = event_properties + + # Then + on_save = [p.Value for p in doc.Events['OnSave'] if p.Name == 'Script'][0] + self.assertEqual(getScriptName(), on_save) + + doc.close(True) + + # Tests syntax: + # obj[key] = val # Replace by key + # For: + # Invalid key + def test_XNameReplace_ReplaceName_Invalid(self): + # Given + doc = self.createBlankTextDocument() + event_properties = (PropertyValue(Name='Script', Value=getScriptName()),) + + # When / Then + with self.assertRaises(KeyError): + doc.Events['qqqqq'] = event_properties + + doc.close(True) + + # Tests syntax: + # obj[key] = val # Replace by key + # For: + # Invalid key type + def test_XNameReplace_ReplaceName_Invalid(self): + # Given + doc = self.createBlankTextDocument() + event_properties = (PropertyValue(Name='Script', Value=getScriptName()),) + + # When / Then + with self.assertRaises(TypeError): + doc.Events[12.34] = event_properties + + doc.close(True) + + +if __name__ == '__main__': + unittest.main() + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testcollections_base.py b/pyuno/qa/pytests/testcollections_base.py new file mode 100644 index 000000000..d3e806882 --- /dev/null +++ b/pyuno/qa/pytests/testcollections_base.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from org.libreoffice.unotest import pyuno +from com.sun.star.beans import PropertyValue + +testEnvironmentInitialized = False + +class CollectionsTestBase(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.context = pyuno.getComponentContext() + global testEnvironmentInitialized + if not testEnvironmentInitialized: + pyuno.private_initTestEnvironment() + testEnvironmentInitialized = True + + def setUp(self): + self._components = [] + + def tearDown(self): + for component in self._components: + try: + component.close(True) + except Exception: + pass + + def createHiddenWindow(self, url): + service_manager = self.context.ServiceManager + desktop = service_manager.createInstanceWithContext('com.sun.star.frame.Desktop', self.context) + load_props = ( + PropertyValue(Name='Hidden', Value=True), + PropertyValue(Name='ReadOnly', Value=False) + ) + component = desktop.loadComponentFromURL(url, '_blank', 0, load_props) + return component + + def createBlankTextDocument(self): + component = self.createHiddenWindow('private:factory/swriter') + self._components.append(component) + return component + + def createBlankSpreadsheet(self): + component = self.createHiddenWindow('private:factory/scalc') + self._components.append(component) + return component + + def createBlankDrawing(self): + component = self.createHiddenWindow('private:factory/sdraw') + self._components.append(component) + return component + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testcollections_misc.py b/pyuno/qa/pytests/testcollections_misc.py new file mode 100644 index 000000000..1dba098ee --- /dev/null +++ b/pyuno/qa/pytests/testcollections_misc.py @@ -0,0 +1,83 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from testcollections_base import CollectionsTestBase +from com.sun.star.beans import PropertyValue + + +# Miscellaneous tests of the behaviour of UNO objects using the new-style +# collection accessors + +class TestMisc(CollectionsTestBase): + + # Tests syntax: + # for val in obj: ... # Implicit iterator + # For: + # Invalid type + def test_misc_IterateInvalidType(self): + # Given + doc = self.createBlankTextDocument() + + # When / Then + with self.assertRaises(TypeError): + for val in doc.UIConfigurationManager: + pass + + doc.close(True) + + # Tests syntax: + # if val in itr: ... # Test value presence + # For: + # Invalid type + def test_misc_InInvalidType(self): + # Given + doc = self.createBlankTextDocument() + + # When / Then + with self.assertRaises(TypeError): + foo = "bar" in doc.UIConfigurationManager + + doc.close(True) + + # Tests syntax: + # num = len(obj) # Number of elements + # For: + # Invalid type + def test_misc_LenInvalidType(self): + # Given + doc = self.createBlankTextDocument() + + # When / Then + with self.assertRaises(TypeError): + len(doc.UIConfigurationManager) + + doc.close(True) + + # Tests syntax: + # val = obj[0] # Access by index + # For: + # Invalid type + def test_misc_SubscriptInvalidType(self): + # Given + doc = self.createBlankTextDocument() + + # When / Then + with self.assertRaises(TypeError): + doc.UIConfigurationManager[0] + + doc.close(True) + + +if __name__ == '__main__': + unittest.main() + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testcollections_misc2.py b/pyuno/qa/pytests/testcollections_misc2.py new file mode 100644 index 000000000..b696e050a --- /dev/null +++ b/pyuno/qa/pytests/testcollections_misc2.py @@ -0,0 +1,62 @@ + +# execute run procedure as Python macro for testing + +import uno +import sys +import unittest + +from com.sun.star.awt.FontSlant import ITALIC +from com.sun.star.awt.FontSlant import NONE +from com.sun.star.uno.TypeClass import STRING +from com.sun.star.uno.TypeClass import LONG +from com.sun.star.awt import Point + +class Test124953(unittest.TestCase): + + def test_Enum(self): + italic = uno.Enum("com.sun.star.awt.FontSlant", "ITALIC") + none_ = uno.Enum("com.sun.star.awt.FontSlant", "NONE") + self.assertEqual(ITALIC, ITALIC) + self.assertEqual(ITALIC, italic) + self.assertFalse((ITALIC != italic)) + self.assertNotEqual(ITALIC, NONE) + self.assertEqual(NONE, none_) + + def test_Type(self): + + STRING_TYPE = uno.getTypeByName("string") + LONG_TYPE = uno.getTypeByName("long") + string_type = uno.Type("string", STRING) + long_type = uno.Type("long", LONG) + self.assertEqual(STRING_TYPE, STRING_TYPE) + self.assertEqual(STRING_TYPE, string_type) + self.assertFalse((STRING_TYPE != string_type)) + self.assertNotEqual(STRING_TYPE, LONG) + self.assertEqual(LONG_TYPE, long_type) + + def test_Char(self): + char_a = uno.Char("a") + char_a2 = uno.Char("a") + char_b = uno.Char("b") + self.assertEqual(char_a, char_a) + self.assertEqual(char_a, char_a2) + self.assertFalse((char_a != char_a2)) + self.assertNotEqual(char_a, char_b) + + def test_ByteSequence(self): + b1 = uno.ByteSequence(bytes("abcdefg", encoding="utf8")) + b2 = uno.ByteSequence(bytes("abcdefg", encoding="utf8")) + b3 = uno.ByteSequence(bytes("1234567", encoding="utf8")) + self.assertEqual(b1, b1) + self.assertEqual(b1, b2) + self.assertFalse(b1 != b2) + self.assertNotEqual(b1, b3) + + def test_Struct(self): + point1 = Point(100, 200) + point2 = Point(100, 200) + point3 = Point(0, 10) + self.assertEqual(point1, point1) + self.assertEqual(point1, point2) + self.assertFalse((point1 != point2)) + self.assertNotEqual(point1, point3) diff --git a/pyuno/qa/pytests/testcollections_mixednameindex.py b/pyuno/qa/pytests/testcollections_mixednameindex.py new file mode 100644 index 000000000..b4c7958c6 --- /dev/null +++ b/pyuno/qa/pytests/testcollections_mixednameindex.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python +# +# 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/. +# + +import unittest +import uno + +from testcollections_base import CollectionsTestBase +from com.sun.star.beans import PropertyValue + + +# Tests behaviour of objects implementing both XIndexAccess and XNameAccess +# using the new-style collection accessors +# The objects chosen have no special meaning, they just happen to implement the +# tested interfaces + +class TestMixedNameIndex(CollectionsTestBase): + + # Tests: + # Ability to access a dual XName*/XIndex* object by both name and index + def testWriterTextTableNameAndIndex(self): + # Given + doc = self.createBlankTextDocument() + text_table = doc.createInstance("com.sun.star.text.TextTable") + text_table.initialize(2, 2) + text_table.Name = 'foo' + cursor = doc.Text.createTextCursor() + doc.Text.insertTextContent(cursor, text_table, False) + + # When + table_by_name = doc.TextTables['foo'] + table_by_index = doc.TextTables[0] + + # Then + self.assertEqual('foo', table_by_name.Name) + self.assertEqual('foo', table_by_index.Name) + self.assertEqual(table_by_name, table_by_index) + + doc.close(True) + + +if __name__ == '__main__': + unittest.main() + +# vim:set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/qa/pytests/testdocuments/fdo74824.ods b/pyuno/qa/pytests/testdocuments/fdo74824.ods Binary files differnew file mode 100644 index 000000000..122bae22d --- /dev/null +++ b/pyuno/qa/pytests/testdocuments/fdo74824.ods diff --git a/pyuno/qa/pytests/testssl.py b/pyuno/qa/pytests/testssl.py new file mode 100644 index 000000000..6ec9875fb --- /dev/null +++ b/pyuno/qa/pytests/testssl.py @@ -0,0 +1,10 @@ +import unittest + + +# I want to ensure that import ssl works on all platforms +class SSLTest(unittest.TestCase): + def test_ssl_import(self): + import ssl + +if __name__ == '__main__': + unittest.main() diff --git a/pyuno/source/loader/pythonloader.component b/pyuno/source/loader/pythonloader.component new file mode 100644 index 000000000..b98b1cd57 --- /dev/null +++ b/pyuno/source/loader/pythonloader.component @@ -0,0 +1,25 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + * 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 . + --> + +<component loader="com.sun.star.loader.SharedLibrary" environment="@CPPU_ENV@" + prefix="pythonloader" xmlns="http://openoffice.org/2010/uno-components"> + <implementation name="org.openoffice.comp.pyuno.Loader"> + <service name="com.sun.star.loader.Python"/> + </implementation> +</component> diff --git a/pyuno/source/loader/pythonloader.py b/pyuno/source/loader/pythonloader.py new file mode 100644 index 000000000..5b824a3c2 --- /dev/null +++ b/pyuno/source/loader/pythonloader.py @@ -0,0 +1,162 @@ +# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-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 . +# +import uno +import unohelper +import sys +import types +import os +from com.sun.star.uno import Exception,RuntimeException +from com.sun.star.loader import XImplementationLoader +from com.sun.star.lang import XServiceInfo + +MODULE_PROTOCOL = "vnd.openoffice.pymodule:" +DEBUG = 0 + +g_supportedServices = "com.sun.star.loader.Python", # referenced by the native C++ loader ! +g_implementationName = "org.openoffice.comp.pyuno.Loader" # referenced by the native C++ loader ! + +def splitUrl( url ): + nColon = url.find( ":" ) + if -1 == nColon: + raise RuntimeException( "PythonLoader: No protocol in url " + url, None ) + return url[0:nColon], url[nColon+1:len(url)] + +g_loadedComponents = {} +def checkForPythonPathBesideComponent( url ): + path = unohelper.fileUrlToSystemPath( url+"/pythonpath.zip" ); + if DEBUG == 1: + print(b"checking for existence of " + encfile( path )) + if 1 == os.access( encfile( path ), os.F_OK) and not path in sys.path: + if DEBUG == 1: + print(b"adding " + encfile( path ) + b" to sys.path") + sys.path.append( path ) + + path = unohelper.fileUrlToSystemPath( url+"/pythonpath" ); + if 1 == os.access( encfile( path ), os.F_OK) and not path in sys.path: + if DEBUG == 1: + print(b"adding " + encfile( path ) + b" to sys.path") + sys.path.append( path ) + +def encfile(uni): + return uni.encode( sys.getfilesystemencoding()) + +class Loader( XImplementationLoader, XServiceInfo, unohelper.Base ): + def __init__(self, ctx ): + if DEBUG: + print("pythonloader.Loader ctor") + self.ctx = ctx + + def getModuleFromUrl( self, url ): + if DEBUG: + print("pythonloader: interpreting url " + url) + protocol, dependent = splitUrl( url ) + if "vnd.sun.star.expand" == protocol: + exp = self.ctx.getValueByName( "/singletons/com.sun.star.util.theMacroExpander" ) + url = exp.expandMacros(dependent) + protocol,dependent = splitUrl( url ) + + if DEBUG: + print("pythonloader: after expansion " + protocol + ":" + dependent) + + try: + if "file" == protocol: + # remove \..\ sequence, which may be useful e.g. in the build env + url = unohelper.absolutize( url, url ) + + # did we load the module already ? + mod = g_loadedComponents.get( url ) + if not mod: + mod = types.ModuleType("uno_component") + + # check for pythonpath.zip beside .py files + checkForPythonPathBesideComponent( url[0:url.rfind('/')] ) + + # read the file + filename = unohelper.fileUrlToSystemPath( url ) + + fileHandle = open( filename, encoding='utf_8' ) + src = fileHandle.read().replace("\r","") + if not src.endswith( "\n" ): + src = src + "\n" + + # compile and execute the module + codeobject = compile( src, encfile(filename), "exec" ) + mod.__file__ = filename + exec(codeobject, mod.__dict__) + g_loadedComponents[url] = mod + return mod + elif "vnd.openoffice.pymodule" == protocol: + nSlash = dependent.rfind('/') + if -1 != nSlash: + path = unohelper.fileUrlToSystemPath( dependent[0:nSlash] ) + dependent = dependent[nSlash+1:len(dependent)] + if not path in sys.path: + sys.path.append( path ) + mod = __import__( dependent ) + path_component, dot, rest = dependent.partition('.') + while dot == '.': + path_component, dot, rest = rest.partition('.') + mod = getattr(mod, path_component) + return mod + else: + if DEBUG: + print("Unknown protocol '" + protocol + "'"); + raise RuntimeException( "PythonLoader: Unknown protocol " + + protocol + " in url " +url, self ) + except Exception as e: + if DEBUG: + print ("Python import exception " + str(type(e)) + + " message " + str(e) + " args " + str(e.args)); + raise RuntimeException( "Couldn't load " + url + " for reason " + str(e), None ) + return None + + def activate( self, implementationName, dummy, locationUrl, regKey ): + if DEBUG: + print("pythonloader.Loader.activate") + + mod = self.getModuleFromUrl( locationUrl ) + implHelper = mod.__dict__.get( "g_ImplementationHelper" , None ) + if DEBUG: + print ("Fetched ImplHelper as " + str(implHelper)) + if implHelper is None: + return mod.getComponentFactory( implementationName, self.ctx.ServiceManager, regKey ) + else: + return implHelper.getComponentFactory( implementationName,regKey,self.ctx.ServiceManager) + + def writeRegistryInfo( self, regKey, dummy, locationUrl ): + if DEBUG: + print( "pythonloader.Loader.writeRegistryInfo" ) + + mod = self.getModuleFromUrl( locationUrl ) + implHelper = mod.__dict__.get( "g_ImplementationHelper" , None ) + if implHelper is None: + return mod.writeRegistryInfo( self.ctx.ServiceManager, regKey ) + else: + return implHelper.writeRegistryInfo( regKey, self.ctx.ServiceManager ) + + def getImplementationName( self ): + return g_implementationName + + def supportsService( self, ServiceName ): + return ServiceName in self.getSupportedServiceNames() + + def getSupportedServiceNames( self ): + return g_supportedServices + +# vim: set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/source/loader/pyuno_loader.cxx b/pyuno/source/loader/pyuno_loader.cxx new file mode 100644 index 000000000..07dc74823 --- /dev/null +++ b/pyuno/source/loader/pyuno_loader.cxx @@ -0,0 +1,300 @@ +/* -*- 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 <config_features.h> +#include <config_folders.h> + +#include <pyuno.hxx> + +#include <o3tl/any.hxx> + +#include <osl/process.h> +#include <osl/file.hxx> +#include <osl/thread.h> + +#include <rtl/ustrbuf.hxx> +#include <rtl/bootstrap.hxx> + +#include <cppuhelper/implementationentry.hxx> +#include <cppuhelper/factory.hxx> + +#include <com/sun/star/uno/XComponentContext.hpp> + +// apparently PATH_MAX is not standard and not defined by MSVC +#ifndef PATH_MAX +#ifdef _MAX_PATH +#define PATH_MAX _MAX_PATH +#else +#ifdef MAX_PATH +#define PATH_MAX MAX_PATH +#else +#error no PATH_MAX +#endif +#endif +#endif + +using pyuno::PyRef; +using pyuno::NOT_NULL; +using pyuno::Runtime; +using pyuno::PyThreadAttach; + +using com::sun::star::uno::Reference; +using com::sun::star::uno::XInterface; +using com::sun::star::uno::Sequence; +using com::sun::star::uno::XComponentContext; +using com::sun::star::uno::RuntimeException; + +namespace pyuno_loader +{ + +/// @throws RuntimeException +static void raiseRuntimeExceptionWhenNeeded() +{ + if( PyErr_Occurred() ) + { + PyRef excType, excValue, excTraceback; + PyErr_Fetch(reinterpret_cast<PyObject **>(&excType), reinterpret_cast<PyObject**>(&excValue), reinterpret_cast<PyObject**>(&excTraceback)); + Runtime runtime; + css::uno::Any a = runtime.extractUnoException( excType, excValue, excTraceback ); + OUStringBuffer buf; + buf.append( "python-loader:" ); + if( auto e = o3tl::tryAccess<css::uno::Exception>(a) ) + buf.append( e->Message ); + throw RuntimeException( buf.makeStringAndClear() ); + } +} + +/// @throws RuntimeException +static PyRef getLoaderModule() +{ + PyRef module( + PyImport_ImportModule( "pythonloader" ), + SAL_NO_ACQUIRE ); + raiseRuntimeExceptionWhenNeeded(); + if( !module.is() ) + { + throw RuntimeException( "pythonloader: Couldn't load pythonloader module" ); + } + return PyRef( PyModule_GetDict( module.get() )); +} + +/// @throws RuntimeException +static PyRef getObjectFromLoaderModule( const char * func ) +{ + PyRef object( PyDict_GetItemString(getLoaderModule().get(), func ) ); + if( !object.is() ) + { + throw RuntimeException( "pythonloader: couldn't find core element pythonloader." + + OUString::createFromAscii( func )); + } + return object; +} + +static OUString getImplementationName() +{ + return "org.openoffice.comp.pyuno.Loader"; +} + +static Sequence< OUString > getSupportedServiceNames() +{ + return { "com.sun.star.loader.Python" }; +} + +static void setPythonHome ( const OUString & pythonHome ) +{ + OUString systemPythonHome; + osl_getSystemPathFromFileURL( pythonHome.pData, &(systemPythonHome.pData) ); + OString o = OUStringToOString( systemPythonHome, osl_getThreadTextEncoding() ); + // static because Py_SetPythonHome just copies the "wide" pointer + static wchar_t wide[PATH_MAX + 1]; + size_t len = mbstowcs(wide, o.pData->buffer, PATH_MAX + 1); + if(len == size_t(-1)) + { + PyErr_SetString(PyExc_SystemError, "invalid multibyte sequence in python home path"); + return; + } + if(len == PATH_MAX + 1) + { + PyErr_SetString(PyExc_SystemError, "python home path is too long"); + return; + } + Py_SetPythonHome(wide); +} + +static void prependPythonPath( const OUString & pythonPathBootstrap ) +{ + OUStringBuffer bufPYTHONPATH( 256 ); + bool bAppendSep = false; + sal_Int32 nIndex = 0; + while( true ) + { + sal_Int32 nNew = pythonPathBootstrap.indexOf( ' ', nIndex ); + OUString fileUrl; + if( nNew == -1 ) + { + fileUrl = pythonPathBootstrap.copy(nIndex); + } + else + { + fileUrl = pythonPathBootstrap.copy(nIndex, nNew - nIndex); + } + OUString systemPath; + osl_getSystemPathFromFileURL( fileUrl.pData, &(systemPath.pData) ); + if (!systemPath.isEmpty()) + { + if (bAppendSep) + bufPYTHONPATH.append(static_cast<sal_Unicode>(SAL_PATHSEPARATOR)); + bufPYTHONPATH.append(systemPath); + bAppendSep = true; + } + if( nNew == -1 ) + break; + nIndex = nNew + 1; + } + const char * oldEnv = getenv( "PYTHONPATH"); + if( oldEnv ) + { + if (bAppendSep) + bufPYTHONPATH.append( static_cast<sal_Unicode>(SAL_PATHSEPARATOR) ); + bufPYTHONPATH.append( OUString(oldEnv, strlen(oldEnv), osl_getThreadTextEncoding()) ); + } + + OUString envVar("PYTHONPATH"); + OUString envValue(bufPYTHONPATH.makeStringAndClear()); + osl_setEnvironment(envVar.pData, envValue.pData); +} + +namespace { + +struct PythonInit +{ +PythonInit() { + if ( Py_IsInitialized()) // may be inited by getComponentContext() already + return; + + OUString pythonPath; + OUString pythonHome; + OUString path( "$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("pythonloader.uno" )); + rtl::Bootstrap::expandMacros(path); //TODO: detect failure + rtl::Bootstrap bootstrap(path); + + // look for pythonhome + bootstrap.getFrom( "PYUNO_LOADER_PYTHONHOME", pythonHome ); + bootstrap.getFrom( "PYUNO_LOADER_PYTHONPATH", pythonPath ); + + // pythonhome+pythonpath must be set before Py_Initialize(), otherwise there appear warning on the console + // sadly, there is no api for setting the pythonpath, we have to use the environment variable + if( !pythonHome.isEmpty() ) + setPythonHome( pythonHome ); + + if( !pythonPath.isEmpty() ) + prependPythonPath( pythonPath ); + +#ifdef _WIN32 + //extend PATH under windows to include the branddir/program so ssl libs will be found + //for use by terminal mailmerge dependency _ssl.pyd + OUString sEnvName("PATH"); + OUString sPath; + osl_getEnvironment(sEnvName.pData, &sPath.pData); + OUString sBrandLocation("$BRAND_BASE_DIR/program"); + rtl::Bootstrap::expandMacros(sBrandLocation); + osl::FileBase::getSystemPathFromFileURL(sBrandLocation, sBrandLocation); + sPath = OUStringBuffer(sPath). + append(static_cast<sal_Unicode>(SAL_PATHSEPARATOR)). + append(sBrandLocation).makeStringAndClear(); + osl_setEnvironment(sEnvName.pData, sPath.pData); +#endif + + PyImport_AppendInittab( "pyuno", PyInit_pyuno ); + +#if HAVE_FEATURE_READONLY_INSTALLSET + Py_DontWriteBytecodeFlag = 1; +#endif + + // initialize python + Py_Initialize(); + PyEval_InitThreads(); + + PyThreadState *tstate = PyThreadState_Get(); + PyEval_ReleaseThread( tstate ); + // This tstate is never used again, so delete it here. + // This prevents an assertion in PyThreadState_Swap on the + // PyThreadAttach below. + PyThreadState_Delete(tstate); +} +}; + +} + +static Reference<XInterface> CreateInstance(const Reference<XComponentContext> & ctx) +{ + // tdf#114815 thread-safe static to init python only once + static PythonInit s_Init; + + Reference< XInterface > ret; + + PyThreadAttach attach( PyInterpreterState_Head() ); + { + // note: this can't race against getComponentContext() because + // either (in soffice.bin) CreateInstance() must be called before + // getComponentContext() can be called, or (in python.bin) the other + // way around + if( ! Runtime::isInitialized() ) + { + Runtime::initialize( ctx ); + } + Runtime runtime; + + PyRef pyCtx = runtime.any2PyObject( + css::uno::makeAny( ctx ) ); + + PyRef clazz = getObjectFromLoaderModule( "Loader" ); + PyRef args ( PyTuple_New( 1 ), SAL_NO_ACQUIRE, NOT_NULL ); + PyTuple_SetItem( args.get(), 0 , pyCtx.getAcquired() ); + PyRef pyInstance( PyObject_CallObject( clazz.get() , args.get() ), SAL_NO_ACQUIRE ); + runtime.pyObject2Any( pyInstance ) >>= ret; + } + return ret; +} + +} + + +static const struct cppu::ImplementationEntry g_entries[] = +{ + { + pyuno_loader::CreateInstance, pyuno_loader::getImplementationName, + pyuno_loader::getSupportedServiceNames, cppu::createSingleComponentFactory, + nullptr , 0 + }, + { nullptr, nullptr, nullptr, nullptr, nullptr, 0 } +}; + +extern "C" +{ + +SAL_DLLPUBLIC_EXPORT void * pythonloader_component_getFactory( + const char * pImplName, void * pServiceManager, void * pRegistryKey ) +{ + return cppu::component_getFactoryHelper( pImplName, pServiceManager, pRegistryKey , g_entries ); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/pyuno.cxx b/pyuno/source/module/pyuno.cxx new file mode 100644 index 000000000..25aea6436 --- /dev/null +++ b/pyuno/source/module/pyuno.cxx @@ -0,0 +1,1718 @@ +/* -*- 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/strbuf.hxx> +#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::makeAny; +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 "void"; + + 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=" ); + buf.append(serviceInfo->getImplementationName() ); + buf.append(", 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( "{ " ); + buf.append( val2str( static_cast<uno_Any const *>(pVal)->pData, + static_cast<uno_Any const *>(pVal)->pType , + mode) ); + buf.append( " }" ); + 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( '\'' ); + buf.append( *static_cast<sal_Unicode const *>(pVal) ); + buf.append( '\'' ); + 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::makeAny( e ) ); + } + catch (const css::script::CannotConvertException &e) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch (const css::uno::RuntimeException &e) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch (const css::uno::Exception &e) + { + raisePyExceptionWithAny( css::uno::makeAny( 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( makeAny(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::makeAny( 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::makeAny( 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 ( "getRows", aParams, aOutParamIndex, aOutParam ); + Reference< XIndexAccess > xIndexAccessRows( aRet, UNO_QUERY ); + nRows = xIndexAccessRows->getCount(); + aRet = me->members->xInvocation->invoke ( "getColumns", 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.realloc (1); + aParams[0] <<= pyString2ustring( pKey ); + { + PyThreadDetach antiguard; + aRet = me->members->xInvocation->invoke ( + "getCellRangeByName", 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.realloc( 2 ); + aParams[0] <<= nKey1_s; + aParams[1] <<= nKey0_s; + { + PyThreadDetach antiguard; + aRet = me->members->xInvocation->invoke ( + "getCellByPosition", 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, "com.sun.star.table.XColumnRowRange" ) ) + { + 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.realloc (4); + aParams[0] <<= nStart1; + aParams[1] <<= nStart0; + aParams[2] <<= nStop1 - 1; + aParams[3] <<= nStop0 - 1; + { + PyThreadDetach antiguard; + aRet = me->members->xInvocation->invoke ( + "getCellRangeByPosition", 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.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 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(); + } + + return nullptr; +} + +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, "com.sun.star.table.XCellRange" ); + } + 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::makeAny( e ) ); + } + catch( const css::lang::IllegalArgumentException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::lang::WrappedTargetException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::uno::RuntimeException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( 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::makeAny( e ) ); + } + catch( const css::lang::WrappedTargetException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::uno::RuntimeException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( 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::makeAny( e ) ); + } + catch( css::lang::IllegalArgumentException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::uno::RuntimeException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( 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::makeAny( e ) ); + } + catch( const css::lang::IndexOutOfBoundsException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::lang::IllegalArgumentException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::lang::WrappedTargetException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::uno::RuntimeException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + + return -1; +} + +static PyObject* PyUNO_getattr (PyObject* self, char* name) +{ + PyUNO* me; + + try + { + + Runtime runtime; + + 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... + if (me->members->xInvocation->hasMethod (attrName)) + { + //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 + if (me->members->xInvocation->hasProperty ( attrName)) + { + //Return the value of the property + Any anyRet; + { + PyThreadDetach antiguard; + anyRet = me->members->xInvocation->getValue (attrName); + } + 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( makeAny(e) ); + } + catch( const css::lang::IllegalArgumentException &e ) + { + raisePyExceptionWithAny( makeAny(e) ); + } + catch( const css::script::CannotConvertException &e ) + { + raisePyExceptionWithAny( makeAny(e) ); + } + catch( const RuntimeException &e ) + { + raisePyExceptionWithAny( makeAny(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( makeAny(e) ); + return 1; + } + catch( const css::script::CannotConvertException &e ) + { + raisePyExceptionWithAny( makeAny(e) ); + return 1; + } + catch( const RuntimeException & e ) + { + raisePyExceptionWithAny( makeAny( 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( makeAny( e ) ); + } + + result = (op == Py_EQ ? Py_False : Py_True); + Py_INCREF(result); + return result; +} + +static PyMethodDef PyUNOMethods[] = +{ + {"__dir__", reinterpret_cast<PyCFunction>(PyUNO_dir), METH_NOARGS, nullptr}, + {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 +#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::getUnoTunnelImplementation<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: */ diff --git a/pyuno/source/module/pyuno_adapter.cxx b/pyuno/source/module/pyuno_adapter.cxx new file mode 100644 index 000000000..a8efd4153 --- /dev/null +++ b/pyuno/source/module/pyuno_adapter.cxx @@ -0,0 +1,416 @@ +/* -*- 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 "pyuno_impl.hxx" + +#include <o3tl/any.hxx> + +#include <com/sun/star/beans/MethodConcept.hpp> +#include <com/sun/star/beans/UnknownPropertyException.hpp> +#include <com/sun/star/script/CannotConvertException.hpp> +#include <com/sun/star/script/XInvocationAdapterFactory2.hpp> +#include <com/sun/star/beans/XIntrospection.hpp> + +#include <comphelper/sequence.hxx> +#include <cppuhelper/exc_hlp.hxx> +#include <cppuhelper/typeprovider.hxx> + + +using com::sun::star::beans::XIntrospectionAccess; +using com::sun::star::uno::Any; +using com::sun::star::uno::makeAny; +using com::sun::star::uno::Reference; +using com::sun::star::uno::Sequence; +using com::sun::star::uno::RuntimeException; +using com::sun::star::uno::XInterface; +using com::sun::star::uno::Type; +using com::sun::star::lang::XUnoTunnel; +using com::sun::star::lang::IllegalArgumentException; +using com::sun::star::beans::UnknownPropertyException; +using com::sun::star::script::CannotConvertException; +using com::sun::star::reflection::InvocationTargetException; +using com::sun::star::reflection::XIdlMethod; +using com::sun::star::reflection::ParamInfo; + +#define TO_ASCII(x) OUStringToOString( x , RTL_TEXTENCODING_ASCII_US).getStr() + +namespace pyuno +{ + +Adapter::Adapter( const PyRef & ref, const Sequence< Type > &types ) + : mWrappedObject( ref ), + mInterpreter( (PyThreadState_Get()->interp) ), + mTypes( types ) +{} + +Adapter::~Adapter() +{ + // Problem: We don't know, if we have the python interpreter lock + // There is no runtime function to get to know this. + decreaseRefCount( mInterpreter, mWrappedObject.get() ); + mWrappedObject.scratch(); +} + +static cppu::OImplementationId g_id( false ); + +Sequence<sal_Int8> Adapter::getUnoTunnelId() +{ + return g_id.getImplementationId(); +} + +sal_Int64 Adapter::getSomething( const Sequence< sal_Int8 > &id) +{ + if( id == g_id.getImplementationId() ) + return reinterpret_cast<sal_Int64>(this); + return 0; +} + +void raiseInvocationTargetExceptionWhenNeeded( const Runtime &runtime ) +{ + if( !Py_IsInitialized() ) + throw InvocationTargetException(); + + if( PyErr_Occurred() ) + { + PyRef excType, excValue, excTraceback; + PyErr_Fetch(reinterpret_cast<PyObject **>(&excType), reinterpret_cast<PyObject**>(&excValue), reinterpret_cast<PyObject**>(&excTraceback)); + Any unoExc( runtime.extractUnoException( excType, excValue, excTraceback ) ); + throw InvocationTargetException( + o3tl::doAccess<css::uno::Exception>(unoExc)->Message, + Reference<XInterface>(), unoExc ); + } +} + +Reference< XIntrospectionAccess > Adapter::getIntrospection() +{ + // not supported + return Reference< XIntrospectionAccess > (); +} + +Sequence< sal_Int16 > Adapter::getOutIndexes( const OUString & functionName ) +{ + Sequence< sal_Int16 > ret; + MethodOutIndexMap::const_iterator ii = m_methodOutIndexMap.find( functionName ); + if( ii == m_methodOutIndexMap.end() ) + { + + Runtime runtime; + { + PyThreadDetach antiguard; + + // retrieve the adapter object again. It will be the same instance as before, + // (the adapter factory keeps a weak map inside, which I couldn't have outside) + Reference< XInterface > unoAdapterObject = + runtime.getImpl()->cargo->xAdapterFactory->createAdapter( this, mTypes ); + + // uuuh, that's really expensive. The alternative would have been, to store + // an instance of the introspection at (this), but this results in a cyclic + // reference, which is never broken (as it is up to OOo1.1.0). + Reference< XIntrospectionAccess > introspection = + runtime.getImpl()->cargo->xIntrospection->inspect( makeAny( unoAdapterObject ) ); + + if( !introspection.is() ) + { + throw RuntimeException( + "pyuno bridge: Couldn't inspect uno adapter ( the python class must implement com.sun.star.lang.XTypeProvider !)" ); + } + + Reference< XIdlMethod > method = introspection->getMethod( + functionName, css::beans::MethodConcept::ALL ); + if( ! method.is( ) ) + { + throw RuntimeException( + "pyuno bridge: Couldn't get reflection for method " + functionName ); + } + + const Sequence< ParamInfo > seqInfo = method->getParameterInfos(); + std::vector<sal_Int16> retVec; + for( sal_Int32 i = 0; i < seqInfo.getLength(); ++i ) + { + if( seqInfo[i].aMode == css::reflection::ParamMode_OUT || + seqInfo[i].aMode == css::reflection::ParamMode_INOUT ) + { + retVec.push_back(static_cast<sal_Int16>(i)); + } + } + + ret = comphelper::containerToSequence(retVec); + } + // guard active again ! + m_methodOutIndexMap[ functionName ] = ret; + } + else + { + ret = ii->second; + } + return ret; +} + +Any Adapter::invoke( const OUString &aFunctionName, + const Sequence< Any >& aParams, + Sequence< sal_Int16 > &aOutParamIndex, + Sequence< Any > &aOutParam) +{ + Any ret; + + // special hack for the uno object identity concept. The XUnoTunnel.getSomething() call is + // always handled by the adapter directly. + if( aParams.getLength() == 1 && aFunctionName == "getSomething" ) + { + Sequence< sal_Int8 > id; + if( aParams[0] >>= id ) + return css::uno::makeAny( getSomething( id ) ); + + } + + RuntimeCargo *cargo = nullptr; + try + { + PyThreadAttach guard( mInterpreter ); + { + if( !Py_IsInitialized() ) + throw InvocationTargetException(); + + // convert parameters to python args + // TODO: Out parameter + Runtime runtime; + cargo = runtime.getImpl()->cargo; + if( isLog( cargo, LogLevel::CALL ) ) + { + logCall( cargo, "try uno->py[0x", + mWrappedObject.get(), aFunctionName, aParams ); + } + + sal_Int32 size = aParams.getLength(); + PyRef argsTuple(PyTuple_New( size ), SAL_NO_ACQUIRE, NOT_NULL ); + int i; + // fill tuple with default values in case of exceptions + for( i = 0 ;i < size ; i ++ ) + { + Py_INCREF( Py_None ); + PyTuple_SetItem( argsTuple.get(), i, Py_None ); + } + + // convert args to python + for( i = 0; i < size ; i ++ ) + { + PyRef val = runtime.any2PyObject( aParams[i] ); + + // any2PyObject() can release the GIL + if( !Py_IsInitialized() ) + throw InvocationTargetException(); + + PyTuple_SetItem( argsTuple.get(), i, val.getAcquired() ); + } + + // get callable + PyRef method(PyObject_GetAttrString( mWrappedObject.get(), TO_ASCII(aFunctionName)), + SAL_NO_ACQUIRE); + + raiseInvocationTargetExceptionWhenNeeded( runtime); + if( !method.is() ) + { + PyRef str( PyObject_Repr( mWrappedObject.get() ), SAL_NO_ACQUIRE ); + + OUString sMsg = "pyuno::Adapter: Method " + + aFunctionName + + " is not implemented at object " + + pyString2ustring(str.get()); + throw IllegalArgumentException( sMsg, Reference< XInterface > (),0 ); + } + + PyRef pyRet( PyObject_CallObject( method.get(), argsTuple.get() ), SAL_NO_ACQUIRE ); + raiseInvocationTargetExceptionWhenNeeded( runtime); + if( pyRet.is() ) + { + ret = runtime.pyObject2Any( pyRet ); + + if( ret.hasValue() && + ret.getValueTypeClass() == css::uno::TypeClass_SEQUENCE && + aFunctionName != "getTypes" && // needed by introspection itself ! + aFunctionName != "getImplementationId" ) // needed by introspection itself ! + { + // the sequence can either be + // 1) a simple sequence return value + // 2) a sequence, where the first element is the return value + // and the following elements are interpreted as the outparameter + // I can only decide for one solution by checking the method signature, + // so I need the reflection of the adapter ! + aOutParamIndex = getOutIndexes( aFunctionName ); + if( aOutParamIndex.hasElements() ) + { + // out parameters exist, extract the sequence + Sequence< Any > seq; + if( ! ( ret >>= seq ) ) + { + throw RuntimeException( + "pyuno bridge: Couldn't extract out parameters for method " + aFunctionName ); + } + + auto nOutLength = aOutParamIndex.getLength(); + if( nOutLength + 1 != seq.getLength() ) + { + OUString sMsg = "pyuno bridge: expected for method " + + aFunctionName + + " one return value and " + + OUString::number(nOutLength) + + " out parameters, got a sequence of " + + OUString::number(seq.getLength()) + + " elements as return value."; + throw RuntimeException( sMsg, *this ); + } + + aOutParam.realloc( nOutLength ); + ret = seq[0]; + std::copy_n(std::next(seq.begin()), nOutLength, aOutParam.begin()); + } + // else { sequence is a return value !} + } + } + + // log the reply, if desired + if( isLog( cargo, LogLevel::CALL ) ) + { + logReply( cargo, "success uno->py[0x" , + mWrappedObject.get(), aFunctionName, ret, aOutParam ); + } + } + + } + catch( const InvocationTargetException & e ) + { + if( isLog( cargo, LogLevel::CALL ) ) + { + logException( + cargo, "except uno->py[0x" , + mWrappedObject.get(), aFunctionName, + e.TargetException.getValue(),e.TargetException.getValueType() ); + } + throw; + } + catch( const IllegalArgumentException & e ) + { + if( isLog( cargo, LogLevel::CALL ) ) + { + logException( + cargo, "except uno->py[0x" , + mWrappedObject.get(), aFunctionName, &e,cppu::UnoType<decltype(e)>::get() ); + } + throw; + } + catch( const RuntimeException & e ) + { + if( cargo && isLog( cargo, LogLevel::CALL ) ) + { + logException( + cargo, "except uno->py[0x" , + mWrappedObject.get(), aFunctionName, &e,cppu::UnoType<decltype(e)>::get() ); + } + throw; + } + catch( const CannotConvertException & e ) + { + if( isLog( cargo, LogLevel::CALL ) ) + { + logException( + cargo, "except uno->py[0x" , + mWrappedObject.get(), aFunctionName, &e,cppu::UnoType<decltype(e)>::get() ); + } + throw; + } + return ret; +} + +void Adapter::setValue( const OUString & aPropertyName, const Any & value ) +{ + if( !hasProperty( aPropertyName ) ) + { + throw UnknownPropertyException( "pyuno::Adapter: Property " + aPropertyName + " is unknown." ); + } + + PyThreadAttach guard( mInterpreter ); + try + { + if( !Py_IsInitialized() ) + throw InvocationTargetException(); + + Runtime runtime; + PyRef obj = runtime.any2PyObject( value ); + + // any2PyObject() can release the GIL + if( !Py_IsInitialized() ) + throw InvocationTargetException(); + + PyObject_SetAttrString( + mWrappedObject.get(), TO_ASCII(aPropertyName), obj.get() ); + raiseInvocationTargetExceptionWhenNeeded( runtime); + + } + catch( const IllegalArgumentException & exc ) + { + css::uno::Any anyEx = cppu::getCaughtException(); + throw InvocationTargetException( exc.Message, *this, anyEx ); + } +} + +Any Adapter::getValue( const OUString & aPropertyName ) +{ + Any ret; + PyThreadAttach guard( mInterpreter ); + { + // Should probably be InvocationTargetException, but the interface doesn't allow it + if( !Py_IsInitialized() ) + throw RuntimeException(); + + Runtime runtime; + PyRef pyRef( + PyObject_GetAttrString( mWrappedObject.get(), TO_ASCII(aPropertyName) ), + SAL_NO_ACQUIRE ); + + if (!pyRef.is() || PyErr_Occurred()) + { + throw UnknownPropertyException( "pyuno::Adapter: Property " + aPropertyName + " is unknown." ); + } + ret = runtime.pyObject2Any( pyRef ); + } + return ret; +} + +sal_Bool Adapter::hasMethod( const OUString & aMethodName ) +{ + return hasProperty( aMethodName ); +} + +sal_Bool Adapter::hasProperty( const OUString & aPropertyName ) +{ + bool bRet = false; + PyThreadAttach guard( mInterpreter ); + { + // Should probably be InvocationTargetException, but the interface doesn't allow it + if( !Py_IsInitialized() ) + throw RuntimeException(); + + bRet = PyObject_HasAttrString( + mWrappedObject.get() , TO_ASCII( aPropertyName )); + } + return bRet; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/pyuno_callable.cxx b/pyuno/source/module/pyuno_callable.cxx new file mode 100644 index 000000000..1c138f71b --- /dev/null +++ b/pyuno/source/module/pyuno_callable.cxx @@ -0,0 +1,275 @@ +/* -*- 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 "pyuno_impl.hxx" + +#include <osl/diagnose.h> + +#include <com/sun/star/script/CannotConvertException.hpp> +#include <com/sun/star/script/XInvocation2.hpp> + +using com::sun::star::uno::Sequence; +using com::sun::star::uno::Reference; +using com::sun::star::uno::Any; +using com::sun::star::uno::RuntimeException; +using com::sun::star::script::XInvocation2; + +namespace pyuno +{ +namespace { + +struct PyUNO_callable_Internals +{ + Reference<XInvocation2> xInvocation; + OUString methodName; + ConversionMode mode; +}; + +struct PyUNO_callable +{ + PyObject_HEAD + PyUNO_callable_Internals* members; +}; + +} + +static void PyUNO_callable_del (PyObject* self) +{ + PyUNO_callable* me; + + me = reinterpret_cast<PyUNO_callable*>(self); + delete me->members; + PyObject_Del (self); +} + +static PyObject* PyUNO_callable_call( + PyObject* self, PyObject* args, SAL_UNUSED_PARAMETER PyObject*) +{ + PyUNO_callable* me; + + Sequence<short> aOutParamIndex; + Sequence<Any> aOutParam; + Sequence<Any> aParams; + Any any_params; + Any ret_value; + RuntimeCargo *cargo = nullptr; + me = reinterpret_cast<PyUNO_callable*>(self); + + PyRef ret; + try + { + Runtime runtime; + cargo = runtime.getImpl()->cargo; + any_params = runtime.pyObject2Any (args, me->members->mode); + + if (any_params.getValueTypeClass () == css::uno::TypeClass_SEQUENCE) + { + any_params >>= aParams; + } + else + { + aParams.realloc (1); + aParams [0] = any_params; + } + + { + PyThreadDetach antiguard; //python free zone + + // do some logging if desired ... + if( isLog( cargo, LogLevel::CALL ) ) + { + logCall( cargo, "try py->uno[0x", me->members->xInvocation.get(), + me->members->methodName, aParams ); + } + + // do the call + ret_value = me->members->xInvocation->invoke ( + me->members->methodName, aParams, aOutParamIndex, aOutParam); + + // log the reply, if desired + if( isLog( cargo, LogLevel::CALL ) ) + { + logReply( cargo, "success py->uno[0x", me->members->xInvocation.get(), + me->members->methodName, ret_value, aOutParam); + } + } + + + PyRef temp = runtime.any2PyObject (ret_value); + if( aOutParam.getLength() ) + { + PyRef return_list( PyTuple_New (1+aOutParam.getLength()), SAL_NO_ACQUIRE, NOT_NULL ); + PyTuple_SetItem (return_list.get(), 0, temp.getAcquired()); + + // initialize with defaults in case of exceptions + int i; + for( i = 1 ; i < 1+aOutParam.getLength() ; i ++ ) + { + Py_INCREF( Py_None ); + PyTuple_SetItem( return_list.get() , i , Py_None ); + } + + for( i = 0 ; i < aOutParam.getLength() ; i ++ ) + { + PyRef ref = runtime.any2PyObject( aOutParam[i] ); + PyTuple_SetItem (return_list.get(), 1+i, ref.getAcquired()); + } + ret = return_list; + } + else + { + ret = temp; + } + } + catch( const css::reflection::InvocationTargetException & e ) + { + + if( isLog( cargo, LogLevel::CALL ) ) + { + logException( cargo, "except py->uno[0x", me->members->xInvocation.get() , + me->members->methodName, e.TargetException.getValue(), e.TargetException.getValueTypeRef()); + } + raisePyExceptionWithAny( e.TargetException ); + } + catch( const css::script::CannotConvertException &e ) + { + if( isLog( cargo, LogLevel::CALL ) ) + { + logException( cargo, "error py->uno[0x", me->members->xInvocation.get() , + me->members->methodName, &e, cppu::UnoType<decltype(e)>::get().getTypeLibType()); + } + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::lang::IllegalArgumentException &e ) + { + if( isLog( cargo, LogLevel::CALL ) ) + { + logException( cargo, "error py->uno[0x", me->members->xInvocation.get() , + me->members->methodName, &e, cppu::UnoType<decltype(e)>::get().getTypeLibType()); + } + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch (const css::uno::RuntimeException &e) + { + if( cargo && isLog( cargo, LogLevel::CALL ) ) + { + logException( cargo, "error py->uno[0x", me->members->xInvocation.get() , + me->members->methodName, &e, cppu::UnoType<decltype(e)>::get().getTypeLibType()); + } + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + + return ret.getAcquired(); +} + + +static PyTypeObject PyUNO_callable_Type = +{ + PyVarObject_HEAD_INIT( &PyType_Type, 0 ) + "PyUNO_callable", + sizeof (PyUNO_callable), + 0, + ::pyuno::PyUNO_callable_del, +#if PY_VERSION_HEX >= 0x03080000 + 0, // Py_ssize_t tp_vectorcall_offset +#else + nullptr, // printfunc tp_print +#endif + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + ::pyuno::PyUNO_callable_call, + nullptr, + nullptr, + nullptr, + nullptr, + 0, + nullptr, + nullptr, + nullptr, + nullptr, + 0, + nullptr, + nullptr, + nullptr, + 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 +#endif +#endif +}; + +PyRef PyUNO_callable_new ( + const Reference<XInvocation2> &my_inv, + const OUString & methodName, + enum ConversionMode mode ) +{ + PyUNO_callable* self; + + OSL_ENSURE (my_inv.is(), "XInvocation must be valid"); + + self = PyObject_New (PyUNO_callable, &PyUNO_callable_Type); + if (self == nullptr) + return nullptr; //NULL == Error! + + self->members = new PyUNO_callable_Internals; + self->members->xInvocation = my_inv; + self->members->methodName = methodName; + self->members->mode = mode; + + return PyRef( reinterpret_cast<PyObject*>(self), SAL_NO_ACQUIRE ); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/pyuno_dlopenwrapper.c b/pyuno/source/module/pyuno_dlopenwrapper.c new file mode 100644 index 000000000..78e6982e8 --- /dev/null +++ b/pyuno/source/module/pyuno_dlopenwrapper.c @@ -0,0 +1,84 @@ +/* -*- 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 . + */ + +/* make Python.h go first as a hack to work around _POSIX_C_SOURCE redefinition + warnings: */ +#include <Python.h> + +#include <sal/config.h> + +#include <stdlib.h> +#include <string.h> + +#if defined LINUX && !defined __USE_GNU +#define __USE_GNU +#endif +#include <dlfcn.h> + +#include <rtl/string.h> + +/* A wrapper around libpyuno.so, making sure the latter is loaded RTLD_GLOBAL + so that C++ exception handling works with old GCC versions (that determine + RTTI identity by comparing string addresses rather than string content). +*/ + +static void * load(void const * address, char const * symbol) { + Dl_info dl_info; + char * slash; + size_t len; + char * libname; + void * h; + void * func; + if (dladdr(address, &dl_info) == 0) { + abort(); + } + slash = strrchr(dl_info.dli_fname, '/'); + if (slash == NULL) { + abort(); + } + len = slash - dl_info.dli_fname + 1; + libname = malloc( + len + RTL_CONSTASCII_LENGTH(SAL_DLLPREFIX "pyuno" SAL_DLLEXTENSION) + + 1); + if (libname == NULL) { + abort(); + } + strncpy(libname, dl_info.dli_fname, len); + strcpy(libname + len, SAL_DLLPREFIX "pyuno" SAL_DLLEXTENSION); + h = dlopen(libname, RTLD_LAZY | RTLD_GLOBAL); + free(libname); + if (h == NULL) { + fprintf(stderr, "failed to load pyuno: '%s'\n", dlerror()); + abort(); + } + func = dlsym(h, symbol); + if (func == NULL) { + dlclose(h); + abort(); + } + // coverity[leaked_storage] - this is on purpose + return func; +} + +SAL_DLLPUBLIC_EXPORT PyObject * PyInit_pyuno(void) { + return + ((PyObject * (*)(void)) load((void *) &PyInit_pyuno, "PyInit_pyuno"))(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/pyuno_except.cxx b/pyuno/source/module/pyuno_except.cxx new file mode 100644 index 000000000..7cd879f0e --- /dev/null +++ b/pyuno/source/module/pyuno_except.cxx @@ -0,0 +1,234 @@ +/* -*- 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 "pyuno_impl.hxx" + +#include <rtl/ustrbuf.hxx> + +#include <typelib/typedescription.hxx> +#include <com/sun/star/script/CannotConvertException.hpp> + + +using com::sun::star::uno::RuntimeException; +using com::sun::star::uno::XInterface; +using com::sun::star::uno::TypeDescription; + +namespace pyuno +{ + +void raisePyExceptionWithAny( const css::uno::Any &anyExc ) +{ + try + { + Runtime runtime; + PyRef exc = runtime.any2PyObject( anyExc ); + if( exc.is() ) + { + PyRef type( getClass( anyExc.getValueType().getTypeName(),runtime ) ); + PyErr_SetObject( type.get(), exc.get()); + } + else + { + css::uno::Exception e; + anyExc >>= e; + + OUString buf = "Couldn't convert uno exception to a python exception (" + + anyExc.getValueType().getTypeName() + ": " + e.Message + ")"; + PyErr_SetString( + PyExc_SystemError, + OUStringToOString(buf,RTL_TEXTENCODING_ASCII_US).getStr() ); + } + } + catch(const css::lang::IllegalArgumentException & e) + { + PyErr_SetString( PyExc_SystemError, + OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US).getStr() ); + } + catch(const css::script::CannotConvertException & e) + { + PyErr_SetString( PyExc_SystemError, + OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US).getStr() ); + } + catch(const RuntimeException & e) + { + PyErr_SetString( PyExc_SystemError, + OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US).getStr() ); + } +} + +/// @throws RuntimeException +static PyRef createClass( const OUString & name, const Runtime &runtime ) +{ + // assuming that this is never deleted ! + // note I don't have the knowledge how to initialize these type objects correctly ! + TypeDescription desc( name ); + if( ! desc.is() ) + { + throw RuntimeException( "pyuno.getClass: uno exception " + name + " is unknown" ); + } + + bool isStruct = desc.get()->eTypeClass == typelib_TypeClass_STRUCT; + bool isExc = desc.get()->eTypeClass == typelib_TypeClass_EXCEPTION; + bool isInterface = desc.get()->eTypeClass == typelib_TypeClass_INTERFACE; + if( !isStruct && !isExc && ! isInterface ) + { + throw RuntimeException( "pyuno.getClass: " + name + "is a " + + OUString::createFromAscii( typeClassToString( static_cast<css::uno::TypeClass>(desc.get()->eTypeClass)) ) + + ", expected EXCEPTION, STRUCT or INTERFACE" ); + } + + // retrieve base class + PyRef base; + if( isInterface ) + { + typelib_InterfaceTypeDescription *pDesc = reinterpret_cast<typelib_InterfaceTypeDescription *>(desc.get()); + if( pDesc->pBaseTypeDescription ) + { + base = getClass( pDesc->pBaseTypeDescription->aBase.pTypeName, runtime ); + } + else + { + // must be XInterface ! + } + } + else + { + typelib_CompoundTypeDescription *pDesc = reinterpret_cast<typelib_CompoundTypeDescription*>(desc.get()); + if( pDesc->pBaseTypeDescription ) + { + base = getClass( pDesc->pBaseTypeDescription->aBase.pTypeName, runtime ); + } + else + { + if( isExc ) + // we are currently creating the root UNO exception + base = PyRef(PyExc_Exception); + } + } + PyRef args( PyTuple_New( 3 ), SAL_NO_ACQUIRE, NOT_NULL ); + + PyRef pyTypeName = ustring2PyString( name /*.replace( '.', '_' )*/ ); + + PyRef bases; + if( base.is() ) + { + { // for CC, keeping ref-count being 1 + bases = PyRef( PyTuple_New( 1 ), SAL_NO_ACQUIRE ); + } + PyTuple_SetItem( bases.get(), 0 , base.getAcquired() ); + } + else + { + bases = PyRef( PyTuple_New( 0 ), SAL_NO_ACQUIRE ); + } + + PyTuple_SetItem( args.get(), 0, pyTypeName.getAcquired()); + PyTuple_SetItem( args.get(), 1, bases.getAcquired() ); + PyTuple_SetItem( args.get(), 2, PyDict_New() ); + + PyRef ret( + PyObject_CallObject(reinterpret_cast<PyObject *>(&PyType_Type) , args.get()), + SAL_NO_ACQUIRE ); + + // now overwrite ctor and attrib functions + if( isInterface ) + { + PyObject_SetAttrString( + ret.get(), "__pyunointerface__", + ustring2PyString(name).get() ); + } + else + { + PyRef ctor = getObjectFromUnoModule( runtime,"_uno_struct__init__" ); + PyRef setter = getObjectFromUnoModule( runtime,"_uno_struct__setattr__" ); + PyRef getter = getObjectFromUnoModule( runtime,"_uno_struct__getattr__" ); + PyRef repr = getObjectFromUnoModule( runtime,"_uno_struct__repr__" ); + PyRef eq = getObjectFromUnoModule( runtime,"_uno_struct__eq__" ); + PyRef ne = getObjectFromUnoModule( runtime,"_uno_struct__ne__" ); + + PyObject_SetAttrString( + ret.get(), "__pyunostruct__", + ustring2PyString(name).get() ); + PyObject_SetAttrString( + ret.get(), "typeName", + ustring2PyString(name).get() ); + PyObject_SetAttrString( + ret.get(), "__init__", ctor.get() ); + PyObject_SetAttrString( + ret.get(), "__getattr__", getter.get() ); + PyObject_SetAttrString( + ret.get(), "__setattr__", setter.get() ); + PyObject_SetAttrString( + ret.get(), "__repr__", repr.get() ); + PyObject_SetAttrString( + ret.get(), "__str__", repr.get() ); + PyObject_SetAttrString( + ret.get(), "__eq__", eq.get() ); + PyObject_SetAttrString( + ret.get(), "__ne__", ne.get() ); + } + return ret; +} + +bool isInstanceOfStructOrException( PyObject *obj) +{ + PyRef attr( + PyObject_GetAttrString(obj, "__class__"), + SAL_NO_ACQUIRE ); + if(attr.is()) + return PyObject_HasAttrString(attr.get(), "__pyunostruct__"); + else + return false; +} + +bool isInterfaceClass( const Runtime &runtime, PyObject * obj ) +{ + const ClassSet & set = runtime.getImpl()->cargo->interfaceSet; + return set.find( obj ) != set.end(); +} + +PyRef getClass( const OUString & name , const Runtime &runtime) +{ + PyRef ret; + + RuntimeCargo *cargo =runtime.getImpl()->cargo; + ExceptionClassMap::iterator ii = cargo->exceptionMap.find( name ); + if( ii == cargo->exceptionMap.end() ) + { + ret = createClass( name, runtime ); + cargo->exceptionMap[name] = ret; + if( PyObject_HasAttrString( + ret.get(), "__pyunointerface__" ) ) + cargo->interfaceSet.insert( ret ); + + PyObject_SetAttrString( + ret.get(), "__pyunointerface__", + ustring2PyString(name).get() ); + } + else + { + ret = ii->second; + } + + return ret; +} + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/pyuno_gc.cxx b/pyuno/source/module/pyuno_gc.cxx new file mode 100644 index 000000000..e4ed6cb9d --- /dev/null +++ b/pyuno/source/module/pyuno_gc.cxx @@ -0,0 +1,123 @@ +/* -*- 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 "pyuno_impl.hxx" + +#include <sal/config.h> + +#include <rtl/ref.hxx> +#include <salhelper/thread.hxx> + +namespace pyuno +{ + +static bool g_destructorsOfStaticObjectsHaveBeenCalled; + +namespace { + +class StaticDestructorGuard +{ +public: + ~StaticDestructorGuard() + { + g_destructorsOfStaticObjectsHaveBeenCalled = true; + } +}; + +} + +static StaticDestructorGuard guard; + +static bool isAfterUnloadOrPy_Finalize() +{ + return g_destructorsOfStaticObjectsHaveBeenCalled || + !Py_IsInitialized(); +} + +namespace { + +class GCThread: public salhelper::Thread { +public: + GCThread( PyInterpreterState *interpreter, PyObject * object ); + +private: + virtual ~GCThread() override {} + + virtual void execute() override; + + PyObject *mPyObject; + PyInterpreterState *mPyInterpreter; +}; + +} + +GCThread::GCThread( PyInterpreterState *interpreter, PyObject * object ) : + Thread( "pyunoGCThread" ), mPyObject( object ), + mPyInterpreter( interpreter ) +{} + +void GCThread::execute() +{ + // otherwise we crash here, when main has been left already + if( isAfterUnloadOrPy_Finalize() ) + return; + try + { + PyThreadAttach g( mPyInterpreter ); + { + Runtime runtime; + + // remove the reference from the pythonobject2adapter map + PyRef2Adapter::iterator ii = + runtime.getImpl()->cargo->mappedObjects.find( mPyObject ); + if( ii != runtime.getImpl()->cargo->mappedObjects.end() ) + { + runtime.getImpl()->cargo->mappedObjects.erase( ii ); + } + + Py_XDECREF( mPyObject ); + } + } + catch( const css::uno::RuntimeException & e ) + { + OString msg = OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ); + fprintf( stderr, "Leaking python objects bridged to UNO for reason %s\n",msg.getStr()); + } +} + +void decreaseRefCount( PyInterpreterState *interpreter, PyObject *object ) +{ + // otherwise we crash in the last after main ... + if( isAfterUnloadOrPy_Finalize() ) + return; + + // delegate to a new thread, because there does not seem + // to be a method, which tells, whether the global + // interpreter lock is held or not + // TODO: Look for a more efficient solution + rtl::Reference< GCThread >(new GCThread(interpreter, object))->launch(); + //TODO: a protocol is missing how to join with the launched thread + // before exit(3), to ensure the thread is no longer relying on any + // infrastructure while that infrastructure is being shut down in + // atexit handlers +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/pyuno_impl.hxx b/pyuno/source/module/pyuno_impl.hxx new file mode 100644 index 000000000..05ff32252 --- /dev/null +++ b/pyuno/source/module/pyuno_impl.hxx @@ -0,0 +1,304 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_PYUNO_SOURCE_MODULE_PYUNO_IMPL_HXX +#define INCLUDED_PYUNO_SOURCE_MODULE_PYUNO_IMPL_HXX + +#if defined(_MSC_VER) +// Workaround for some horrible hypot() mess +#include <math.h> +#endif + +#include <Python.h> + +//Python 3.0 and newer don't have these flags +#ifndef Py_TPFLAGS_HAVE_ITER +# define Py_TPFLAGS_HAVE_ITER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_RICHCOMPARE +# define Py_TPFLAGS_HAVE_RICHCOMPARE 0 +#endif +#ifndef Py_TPFLAGS_HAVE_SEQUENCE_IN +# define Py_TPFLAGS_HAVE_SEQUENCE_IN 0 +#endif + +#include <pyuno.hxx> + +#include <unordered_map> +#include <unordered_set> + +#include <com/sun/star/container/XIndexAccess.hpp> +#include <com/sun/star/lang/XUnoTunnel.hpp> +#include <com/sun/star/script/XInvocation.hpp> + +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/weakref.hxx> + +#include <osl/module.hxx> + +namespace com::sun::star::beans { class XIntrospection; } +namespace com::sun::star::container { class XEnumeration; } +namespace com::sun::star::container { class XHierarchicalNameAccess; } +namespace com::sun::star::lang { class XSingleServiceFactory; } +namespace com::sun::star::reflection { class XIdlReflection; } +namespace com::sun::star::script { class XInvocation2; } +namespace com::sun::star::script { class XInvocationAdapterFactory2; } +namespace com::sun::star::script { class XTypeConverter; } + +namespace pyuno +{ + + +// Logging API - implementation can be found in pyuno_util + +struct RuntimeCargo; +namespace LogLevel +{ +// when you add a loglevel, extend the log function ! +static const sal_Int32 NONE = 0; +static const sal_Int32 CALL = 1; +static const sal_Int32 ARGS = 2; +} + +bool isLog( RuntimeCargo const *cargo, sal_Int32 loglevel ); +void log( RuntimeCargo *cargo, sal_Int32 level, const OUString &logString ); +void log( RuntimeCargo *cargo, sal_Int32 level, const char *str ); +void logCall( RuntimeCargo *cargo, const char *intro, + void * ptr, const OUString & aFunctionName, + const css::uno::Sequence< css::uno::Any > & args ); +void logReply( RuntimeCargo *cargo, const char *intro, + void * ptr, const OUString & aFunctionName, + const css::uno::Any &returnValue, + const css::uno::Sequence< css::uno::Any > & args ); +void logException( RuntimeCargo *cargo, const char *intro, + void * ptr, const OUString &aFunctionName, + const void * data, const css::uno::Type & type ); +static const sal_Int32 VAL2STR_MODE_DEEP = 0; +static const sal_Int32 VAL2STR_MODE_SHALLOW = 1; +OUString val2str( const void * pVal, typelib_TypeDescriptionReference * pTypeRef, sal_Int32 mode = VAL2STR_MODE_DEEP ); + + +typedef std::unordered_map +< + PyRef, + css::uno::WeakReference< css::script::XInvocation >, + PyRef::Hash +> PyRef2Adapter; + + +typedef std::unordered_map +< + OUString, + PyRef +> ExceptionClassMap; + +typedef std::unordered_map +< + OUString, + css::uno::Sequence< sal_Int16 > +> MethodOutIndexMap; + +typedef std::unordered_set< PyRef , PyRef::Hash > ClassSet; + +int PyUNO_initType(); +int PyUNOStruct_initType(); + +PyRef PyUNO_new ( + const css::uno::Any & targetInterface, + const css::uno::Reference<css::lang::XSingleServiceFactory> & ssf ); + +PyRef PyUNOStruct_new ( + const css::uno::Any &targetInterface, + const css::uno::Reference<css::lang::XSingleServiceFactory> &ssf ); + +struct PyUNOInternals +{ + css::uno::Reference <css::script::XInvocation2> xInvocation; + css::uno::Any wrappedObject; +}; + +typedef struct +{ + PyObject_HEAD + PyUNOInternals* members; +} PyUNO; + +PyObject* PyUNO_iterator_new ( + const css::uno::Reference<css::container::XEnumeration>& xEnumeration); + +struct PyUNO_iterator_Internals +{ + css::uno::Reference <css::container::XEnumeration> xEnumeration; +}; + +typedef struct +{ + PyObject_HEAD + PyUNO_iterator_Internals* members; +} PyUNO_iterator; + +PyObject* PyUNO_list_iterator_new ( + const css::uno::Reference<css::container::XIndexAccess> &xIndexAccess); + +struct PyUNO_list_iterator_Internals +{ + css::uno::Reference <css::container::XIndexAccess> xIndexAccess; + int index; +}; + +typedef struct +{ + PyObject_HEAD + PyUNO_list_iterator_Internals* members; +} PyUNO_list_iterator; + +PyRef ustring2PyUnicode( const OUString &source ); +PyRef ustring2PyString( const OUString & source ); +OUString pyString2ustring( PyObject *str ); + +/// @throws css::reflection::InvocationTargetException +/// @throws css::uno::RuntimeException +void raiseInvocationTargetExceptionWhenNeeded( const Runtime &runtime ); + +PyRef PyUNO_callable_new ( + const css::uno::Reference<css::script::XInvocation2> &xInv, + const OUString &methodName, + ConversionMode mode = REJECT_UNO_ANY ); + +PyObject* PyUNO_Type_new (const char *typeName , css::uno::TypeClass t , const Runtime &r ); +PyObject* PyUNO_Enum_new( const char *enumBase, const char *enumValue, const Runtime &r ); +PyObject* PyUNO_char_new (sal_Unicode c , const Runtime &r); +PyObject *PyUNO_ByteSequence_new( const css::uno::Sequence< sal_Int8 > &, const Runtime &r ); + +PyRef getTypeClass( const Runtime &); +PyRef getEnumClass( const Runtime &); +PyRef getCharClass( const Runtime &); +PyRef getByteSequenceClass( const Runtime & ); +PyRef getPyUnoClass(); +PyRef getPyUnoStructClass(); +PyRef getClass( const OUString & name , const Runtime & runtime ); +PyRef getAnyClass( const Runtime &); +PyObject *PyUNO_invoke( PyObject *object, const char *name , PyObject *args ); + +/// @throws css::uno::RuntimeException +css::uno::Any PyEnum2Enum( PyObject *obj ); +/// @throws css::uno::RuntimeException +sal_Unicode PyChar2Unicode( PyObject *o ); +/// @throws css::uno::RuntimeException +css::uno::Type PyType2Type( PyObject * o ); + +void raisePyExceptionWithAny( const css::uno::Any &a ); +const char *typeClassToString( css::uno::TypeClass t ); + +/// @throws css::uno::RuntimeException +PyRef getObjectFromUnoModule( const Runtime &runtime, const char * object ); + +bool isInterfaceClass( const Runtime &, PyObject *obj ); +bool isInstanceOfStructOrException( PyObject *obj); + +struct RuntimeCargo +{ + css::uno::Reference< css::lang::XSingleServiceFactory > xInvocation; + css::uno::Reference< css::script::XTypeConverter> xTypeConverter; + css::uno::Reference< css::uno::XComponentContext > xContext; + css::uno::Reference< css::reflection::XIdlReflection > xCoreReflection; + css::uno::Reference< css::container::XHierarchicalNameAccess > xTdMgr; + css::uno::Reference< css::script::XInvocationAdapterFactory2 > xAdapterFactory; + css::uno::Reference< css::beans::XIntrospection > xIntrospection; + PyRef dictUnoModule; + osl::Module testModule; + bool valid; + ExceptionClassMap exceptionMap; + ClassSet interfaceSet; + PyRef2Adapter mappedObjects; + FILE *logFile; + sal_Int32 logLevel; + + PyRef const & getUnoModule(); +}; + +struct stRuntimeImpl +{ + PyObject_HEAD + struct RuntimeCargo *cargo; +public: + static void del( PyObject *self ); + + /// @throws css::uno::RuntimeException + static PyRef create( + const css::uno::Reference< css::uno::XComponentContext > & xContext ); +}; + + +class Adapter : public cppu::WeakImplHelper< + css::script::XInvocation, css::lang::XUnoTunnel > +{ + PyRef mWrappedObject; + PyInterpreterState *mInterpreter; // interpreters don't seem to be refcounted ! + css::uno::Sequence< css::uno::Type > mTypes; + MethodOutIndexMap m_methodOutIndexMap; + +private: + css::uno::Sequence< sal_Int16 > getOutIndexes( const OUString & functionName ); + +public: +public: + Adapter( const PyRef &obj, + const css::uno::Sequence< css::uno::Type > & types ); + + static css::uno::Sequence< sal_Int8 > getUnoTunnelId(); + const PyRef& getWrappedObject() const { return mWrappedObject; } + const css::uno::Sequence< css::uno::Type >& getWrappedTypes() const { return mTypes; } + virtual ~Adapter() override; + + // XInvocation + virtual css::uno::Reference< css::beans::XIntrospectionAccess > + SAL_CALL getIntrospection( ) override; + virtual css::uno::Any SAL_CALL invoke( + const OUString& aFunctionName, + const css::uno::Sequence< css::uno::Any >& aParams, + css::uno::Sequence< sal_Int16 >& aOutParamIndex, + css::uno::Sequence< css::uno::Any >& aOutParam ) override; + + virtual void SAL_CALL setValue( + const OUString& aPropertyName, + const css::uno::Any& aValue ) override; + + virtual css::uno::Any SAL_CALL getValue( const OUString& aPropertyName ) override; + virtual sal_Bool SAL_CALL hasMethod( const OUString& aName ) override; + virtual sal_Bool SAL_CALL hasProperty( const OUString& aName ) override; + + // XUnoTunnel + virtual sal_Int64 SAL_CALL getSomething( + const css::uno::Sequence< sal_Int8 >& aIdentifier ) override; +}; + + +/** releases a refcount on the interpreter object and on another given python object. + + The function can be called from any thread regardless of whether the global + interpreter lock is held. + + */ +void decreaseRefCount( PyInterpreterState *interpreter, PyObject *object ); + +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/pyuno_iterator.cxx b/pyuno/source/module/pyuno_iterator.cxx new file mode 100644 index 000000000..840fc9770 --- /dev/null +++ b/pyuno/source/module/pyuno_iterator.cxx @@ -0,0 +1,343 @@ +/* -*- 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 "pyuno_impl.hxx" + +#include <com/sun/star/container/XEnumeration.hpp> +#include <com/sun/star/container/XIndexAccess.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <com/sun/star/lang/WrappedTargetException.hpp> +#include <com/sun/star/script/CannotConvertException.hpp> + +using com::sun::star::container::XEnumeration; +using com::sun::star::container::XIndexAccess; +using com::sun::star::lang::IndexOutOfBoundsException; +using com::sun::star::lang::WrappedTargetException; +using com::sun::star::uno::Any; +using com::sun::star::uno::Reference; +using com::sun::star::uno::RuntimeException; + + +namespace pyuno +{ + +static void PyUNO_iterator_del( PyObject* self ) +{ + PyUNO_iterator* me = reinterpret_cast<PyUNO_iterator*>(self); + + { + PyThreadDetach antiguard; + delete me->members; + } + PyObject_Del( self ); +} + +static PyObject* PyUNO_iterator_iter( PyObject *self ) +{ + Py_INCREF( self ); + return self; +} + +static PyObject* PyUNO_iterator_next( PyObject *self ) +{ + PyUNO_iterator* me = reinterpret_cast<PyUNO_iterator*>(self); + + Runtime runtime; + Any aRet; + + try + { + bool hasMoreElements = false; + + { + PyThreadDetach antiguard; + + hasMoreElements = me->members->xEnumeration->hasMoreElements(); + if ( hasMoreElements ) + { + aRet = me->members->xEnumeration->nextElement(); + } + } + + if ( hasMoreElements ) + { + PyRef rRet = runtime.any2PyObject( aRet ); + return rRet.getAcquired(); + } + + PyErr_SetString( PyExc_StopIteration, "" ); + return nullptr; + } + catch( css::container::NoSuchElementException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( css::script::CannotConvertException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( css::lang::IllegalArgumentException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::lang::WrappedTargetException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::uno::RuntimeException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + + return nullptr; +} + +static PyTypeObject PyUNO_iterator_Type = +{ + PyVarObject_HEAD_INIT( &PyType_Type, 0 ) + "PyUNO_iterator", + sizeof (PyUNO_iterator), + 0, + PyUNO_iterator_del, +#if PY_VERSION_HEX >= 0x03080000 + 0, // Py_ssize_t tp_vectorcall_offset +#else + nullptr, // printfunc tp_print +#endif + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + Py_TPFLAGS_HAVE_ITER, + nullptr, + nullptr, + nullptr, + nullptr, + 0, + PyUNO_iterator_iter, // Generic, reused between the iterator types + PyUNO_iterator_next, + nullptr, + 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 +#endif +#endif +}; + +PyObject* PyUNO_iterator_new( const Reference< XEnumeration >& xEnumeration ) +{ + PyUNO_iterator* self = PyObject_New( PyUNO_iterator, &PyUNO_iterator_Type ); + if ( self == nullptr ) + return nullptr; // == error + self->members = new PyUNO_iterator_Internals; + self->members->xEnumeration = xEnumeration; + return reinterpret_cast<PyObject*>(self); +} + +/////////////////////////////////////////////////////////////////////////////// + +static void PyUNO_list_iterator_del( PyObject* self ) +{ + PyUNO_list_iterator* me = reinterpret_cast<PyUNO_list_iterator*>(self); + + { + PyThreadDetach antiguard; + delete me->members; + } + PyObject_Del( self ); +} + + +static PyObject* PyUNO_list_iterator_next( PyObject *self ) +{ + PyUNO_list_iterator* me = reinterpret_cast<PyUNO_list_iterator*>(self); + + Runtime runtime; + Any aRet; + bool noMoreElements = false; + + try + { + { + PyThreadDetach antiguard; + try { + aRet = me->members->xIndexAccess->getByIndex( me->members->index ); + } + catch( const css::lang::IndexOutOfBoundsException & ) + { + noMoreElements = true; + } + } + + if ( noMoreElements ) + { + PyErr_SetString( PyExc_StopIteration, "" ); + return nullptr; + } + + PyRef rRet = runtime.any2PyObject( aRet ); + me->members->index++; + return rRet.getAcquired(); + } + catch( css::script::CannotConvertException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( css::lang::IllegalArgumentException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::lang::WrappedTargetException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + catch( const css::uno::RuntimeException &e ) + { + raisePyExceptionWithAny( css::uno::makeAny( e ) ); + } + + return nullptr; +} + +static PyTypeObject PyUNO_list_iterator_Type = +{ + PyVarObject_HEAD_INIT( &PyType_Type, 0 ) + "PyUNO_iterator", + sizeof (PyUNO_list_iterator), + 0, + PyUNO_list_iterator_del, +#if PY_VERSION_HEX >= 0x03080000 + 0, // Py_ssize_t tp_vectorcall_offset +#else + nullptr, // printfunc tp_print +#endif + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + Py_TPFLAGS_HAVE_ITER, + nullptr, + nullptr, + nullptr, + nullptr, + 0, + PyUNO_iterator_iter, // Generic, reused between the iterator types + PyUNO_list_iterator_next, + nullptr, + 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 +#endif +#endif +}; + +PyObject* PyUNO_list_iterator_new( const Reference<XIndexAccess> &xIndexAccess ) +{ + PyUNO_list_iterator* self = PyObject_New( PyUNO_list_iterator, &PyUNO_list_iterator_Type ); + if ( self == nullptr ) + return nullptr; // == error + self->members = new PyUNO_list_iterator_Internals; + self->members->xIndexAccess = xIndexAccess; + self->members->index = 0; + return reinterpret_cast<PyObject*>(self); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/pyuno_module.cxx b/pyuno/source/module/pyuno_module.cxx new file mode 100644 index 000000000..579da0a58 --- /dev/null +++ b/pyuno/source/module/pyuno_module.cxx @@ -0,0 +1,901 @@ +/* -*- Mode: C++; eval:(c-set-style "bsd"); 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 <config_folders.h> + +#include "pyuno_impl.hxx" + +#include <cassert> +#include <unordered_map> + +#include <osl/module.hxx> +#include <osl/thread.h> +#include <osl/file.hxx> +#include <sal/log.hxx> + +#include <typelib/typedescription.hxx> + +#include <rtl/ustring.hxx> +#include <rtl/strbuf.hxx> +#include <rtl/ustrbuf.hxx> +#include <rtl/uuid.h> +#include <rtl/bootstrap.hxx> + +#include <uno/current_context.hxx> +#include <cppuhelper/bootstrap.hxx> + +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/reflection/XConstantTypeDescription.hpp> +#include <com/sun/star/reflection/XIdlClass.hpp> +#include <com/sun/star/registry/InvalidRegistryException.hpp> +#include <com/sun/star/script/CannotConvertException.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <com/sun/star/script/XInvocation2.hpp> +#include <com/sun/star/reflection/XIdlReflection.hpp> +#include <com/sun/star/container/XHierarchicalNameAccess.hpp> + +using osl::Module; + + +using com::sun::star::uno::Sequence; +using com::sun::star::uno::Reference; +using com::sun::star::uno::Any; +using com::sun::star::uno::makeAny; +using com::sun::star::uno::RuntimeException; +using com::sun::star::uno::TypeDescription; +using com::sun::star::uno::XComponentContext; +using com::sun::star::container::NoSuchElementException; +using com::sun::star::reflection::XIdlClass; +using com::sun::star::script::XInvocation2; + +using namespace pyuno; + +namespace { + +/** + @ index of the next to be used member in the initializer list ! + */ +// LEM TODO: export member names as keyword arguments in initialiser? +// Python supports very flexible variadic functions. By marking +// variables with one asterisk (e.g. *var) the given variable is +// defined to be a tuple of all the extra arguments. By marking +// variables with two asterisks (e.g. **var) the given variable is a +// dictionary of all extra keyword arguments; the keys are strings, +// which are the names that were used to identify the arguments. If +// they exist, these arguments must be the last one in the list. + +class fillStructState +{ + // Keyword arguments used + PyObject *used; + // Which structure members are initialised + std::unordered_map <OUString, bool> initialised; + // How many positional arguments are consumed + // This is always the so-many first ones + sal_Int32 nPosConsumed; + +public: + fillStructState() + : used (PyDict_New()) + , initialised () + , nPosConsumed (0) + { + if ( ! used ) + throw RuntimeException("pyuno._createUnoStructHelper failed to create new dictionary"); + } + ~fillStructState() + { + Py_DECREF(used); + } + void setUsed(PyObject *key) + { + PyDict_SetItem(used, key, Py_True); + } + void setInitialised(const OUString& key, sal_Int32 pos = -1) + { + if (initialised[key]) + { + OUStringBuffer buf; + buf.append( "pyuno._createUnoStructHelper: member '" + key + "'"); + if ( pos >= 0 ) + { + buf.append( " at position " + OUString::number(pos)); + } + buf.append( " initialised multiple times."); + throw RuntimeException(buf.makeStringAndClear()); + } + initialised[key] = true; + if ( pos >= 0 ) + ++nPosConsumed; + } + bool isInitialised(const OUString& key) + { + return initialised[key]; + } + PyObject *getUsed() const + { + return used; + } + sal_Int32 getCntConsumed() const + { + return nPosConsumed; + } +}; + +/// @throws RuntimeException +void fillStruct( + const Reference< XInvocation2 > &inv, + typelib_CompoundTypeDescription *pCompType, + PyObject *initializer, + PyObject *kwinitializer, + fillStructState &state, + const Runtime &runtime) +{ + if( pCompType->pBaseTypeDescription ) + fillStruct( inv, pCompType->pBaseTypeDescription, initializer, kwinitializer, state, runtime ); + + const sal_Int32 nMembers = pCompType->nMembers; + { + for( int i = 0 ; i < nMembers ; i ++ ) + { + const OUString OUMemberName (pCompType->ppMemberNames[i]); + PyObject *pyMemberName = + PyUnicode_FromString(OUStringToOString(OUMemberName, + RTL_TEXTENCODING_UTF8).getStr()); + if ( PyObject *element = PyDict_GetItem(kwinitializer, pyMemberName ) ) + { + state.setInitialised(OUMemberName); + state.setUsed(pyMemberName); + Any a = runtime.pyObject2Any( element, ACCEPT_UNO_ANY ); + inv->setValue( OUMemberName, a ); + } + } + } + { + const int remainingPosInitialisers = PyTuple_Size(initializer) - state.getCntConsumed(); + for( int i = 0 ; i < remainingPosInitialisers && i < nMembers ; i ++ ) + { + const int tupleIndex = state.getCntConsumed(); + const OUString& rMemberName (pCompType->ppMemberNames[i]); + state.setInitialised(rMemberName, tupleIndex); + PyObject *element = PyTuple_GetItem( initializer, tupleIndex ); + Any a = runtime.pyObject2Any( element, ACCEPT_UNO_ANY ); + inv->setValue( rMemberName, a ); + } + } + if ( PyTuple_Size( initializer ) <= 0 ) + return; + + // Allow partial initialisation when only keyword arguments are given + for ( int i = 0; i < nMembers ; ++i) + { + const OUString memberName (pCompType->ppMemberNames[i]); + if ( ! state.isInitialised( memberName ) ) + { + OUString buf = "pyuno._createUnoStructHelper: member '" + + memberName + + "' of struct type '" + + OUString::unacquired(&pCompType->aBase.pTypeName) + + "' not given a value."; + throw RuntimeException(buf); + } + } +} + +OUString getLibDir() +{ + static OUString sLibDir = []() { + OUString libDir; + + // workarounds the $(ORIGIN) until it is available + if (Module::getUrlFromAddress(reinterpret_cast<oslGenericFunction>(getLibDir), libDir)) + { + libDir = libDir.copy(0, libDir.lastIndexOf('/')); + OUString name("PYUNOLIBDIR"); + rtl_bootstrap_set(name.pData, libDir.pData); + } + return libDir; + }(); + + return sLibDir; +} + +void raisePySystemException( const char * exceptionType, const OUString & message ) +{ + OString buf = OStringLiteral("Error during bootstrapping uno (") + + exceptionType + + "):" + + OUStringToOString( message, osl_getThreadTextEncoding() ); + PyErr_SetString( PyExc_SystemError, buf.getStr() ); +} + +extern "C" { + +static PyObject* getComponentContext( + SAL_UNUSED_PARAMETER PyObject*, SAL_UNUSED_PARAMETER PyObject*) +{ + PyRef ret; + try + { + Reference<XComponentContext> ctx; + + // getLibDir() must be called in order to set bootstrap variables correctly ! + OUString path( getLibDir()); + if( Runtime::isInitialized() ) + { + Runtime runtime; + ctx = runtime.getImpl()->cargo->xContext; + } + else + { + if( path.isEmpty() ) + { + PyErr_SetString( + PyExc_RuntimeError, "osl_getUrlFromAddress fails, that's why I cannot find ini " + "file for bootstrapping python uno bridge\n" ); + return nullptr; + } + + OUString iniFile = path + +#ifdef MACOSX + "/../" LIBO_ETC_FOLDER +#endif + "/" SAL_CONFIGFILE( "pyuno" ); + osl::DirectoryItem item; + if( osl::DirectoryItem::get( iniFile, item ) == osl::FileBase::E_None ) + { + // in case pyuno.ini exists, use this file for bootstrapping + PyThreadDetach antiguard; + ctx = cppu::defaultBootstrap_InitialComponentContext (iniFile); + } + else + { + // defaulting to the standard bootstrapping + PyThreadDetach antiguard; + ctx = cppu::defaultBootstrap_InitialComponentContext (); + } + + } + + if( ! Runtime::isInitialized() ) + { + Runtime::initialize( ctx ); + } + Runtime runtime; + ret = runtime.any2PyObject( makeAny( ctx ) ); + } + catch (const css::registry::InvalidRegistryException &e) + { + // can't use raisePyExceptionWithAny() here, because the function + // does any conversions, which will not work with a + // wrongly bootstrapped pyuno! + raisePySystemException( "InvalidRegistryException", e.Message ); + } + catch(const css::lang::IllegalArgumentException & e) + { + raisePySystemException( "IllegalArgumentException", e.Message ); + } + catch(const css::script::CannotConvertException & e) + { + raisePySystemException( "CannotConvertException", e.Message ); + } + catch (const css::uno::RuntimeException & e) + { + raisePySystemException( "RuntimeException", e.Message ); + } + catch (const css::uno::Exception & e) + { + raisePySystemException( "uno::Exception", e.Message ); + } + return ret.getAcquired(); +} + +// While pyuno.private_initTestEnvironment is called from individual Python tests (e.g., from +// UnoInProcess in unotest/source/python/org/libreoffice/unotest.py, which makes sure to call it +// only once), pyuno.private_deinitTestEnvironment is called centrally from +// unotest/source/python/org/libreoffice/unittest.py at the end of every PythonTest (to DeInitVCL +// exactly once near the end of the process, if InitVCL has ever been called via +// pyuno.private_initTestEnvironment): + +static osl::Module * testModule = nullptr; + +static PyObject* initTestEnvironment( + SAL_UNUSED_PARAMETER PyObject*, SAL_UNUSED_PARAMETER PyObject*) +{ + // this tries to bootstrap enough of the soffice from python to run + // unit tests, which is only possible indirectly because pyuno is URE + // so load "test" library and invoke a function there to do the work + assert(testModule == nullptr); + try + { + PyObject *const ctx(getComponentContext(nullptr, nullptr)); + if (!ctx) { abort(); } + Runtime const runtime; + Any const a(runtime.pyObject2Any(ctx)); + Reference<XComponentContext> xContext; + a >>= xContext; + if (!xContext.is()) { abort(); } + using css::lang::XMultiServiceFactory; + Reference<XMultiServiceFactory> const xMSF( + xContext->getServiceManager(), + css::uno::UNO_QUERY_THROW); + char *const testlib = getenv("TEST_LIB"); + if (!testlib) { abort(); } +#ifdef _WIN32 + OString const libname = OString(testlib, strlen(testlib)) + .replaceAll(OString('/'), OString('\\')); +#else + OString const libname(testlib, strlen(testlib)); +#endif + + osl::Module &mod = runtime.getImpl()->cargo->testModule; + mod.load(OStringToOUString(libname, osl_getThreadTextEncoding()), + SAL_LOADMODULE_LAZY | SAL_LOADMODULE_GLOBAL); + if (!mod.is()) { abort(); } + oslGenericFunction const pFunc( + mod.getFunctionSymbol("test_init")); + if (!pFunc) { abort(); } + reinterpret_cast<void (SAL_CALL *)(XMultiServiceFactory*)>(pFunc)(xMSF.get()); + testModule = &mod; + } + catch (const css::uno::Exception &) + { + abort(); + } + return Py_None; +} + +static PyObject* deinitTestEnvironment( + SAL_UNUSED_PARAMETER PyObject*, SAL_UNUSED_PARAMETER PyObject*) +{ + if (testModule != nullptr) + { + try + { + oslGenericFunction const pFunc( + testModule->getFunctionSymbol("test_deinit")); + if (!pFunc) { abort(); } + reinterpret_cast<void (SAL_CALL *)()>(pFunc)(); + } + catch (const css::uno::Exception &) + { + abort(); + } + } + return Py_None; +} + +PyObject * extractOneStringArg( PyObject *args, char const *funcName ) +{ + if( !PyTuple_Check( args ) || PyTuple_Size( args) != 1 ) + { + OString buf = funcName + OStringLiteral(": expecting one string argument"); + PyErr_SetString( PyExc_RuntimeError, buf.getStr() ); + return nullptr; + } + PyObject *obj = PyTuple_GetItem( args, 0 ); + if (!PyUnicode_Check(obj)) + { + OString buf = funcName + OStringLiteral(": expecting one string argument"); + PyErr_SetString( PyExc_TypeError, buf.getStr()); + return nullptr; + } + return obj; +} + +static PyObject *createUnoStructHelper( + SAL_UNUSED_PARAMETER PyObject *, PyObject* args, PyObject* keywordArgs) +{ + Any IdlStruct; + PyRef ret; + try + { + Runtime runtime; + if( PyTuple_Size( args ) == 2 ) + { + PyObject *structName = PyTuple_GetItem(args, 0); + PyObject *initializer = PyTuple_GetItem(args, 1); + + if (PyUnicode_Check(structName)) + { + if( PyTuple_Check( initializer ) && PyDict_Check ( keywordArgs ) ) + { + OUString typeName( OUString::createFromAscii(PyUnicode_AsUTF8(structName))); + RuntimeCargo *c = runtime.getImpl()->cargo; + Reference<XIdlClass> idl_class = c->xCoreReflection->forName (typeName); + if (idl_class.is ()) + { + idl_class->createObject (IdlStruct); + PyRef returnCandidate( PyUNOStruct_new( IdlStruct, c->xInvocation ) ); + PyUNO *me = reinterpret_cast<PyUNO*>( returnCandidate.get() ); + TypeDescription desc( typeName ); + OSL_ASSERT( desc.is() ); // could already instantiate an XInvocation2 ! + + typelib_CompoundTypeDescription *pCompType = + reinterpret_cast<typelib_CompoundTypeDescription *>(desc.get()); + fillStructState state; + if ( PyTuple_Size( initializer ) > 0 || PyDict_Size( keywordArgs ) > 0 ) + fillStruct( me->members->xInvocation, pCompType, initializer, keywordArgs, state, runtime ); + if( state.getCntConsumed() != PyTuple_Size(initializer) ) + { + throw RuntimeException( "pyuno._createUnoStructHelper: too many " + "elements in the initializer list, expected " + + OUString::number(state.getCntConsumed()) + ", got " + + OUString::number( PyTuple_Size(initializer) ) ); + } + ret = PyRef( PyTuple_Pack(2, returnCandidate.get(), state.getUsed()), SAL_NO_ACQUIRE); + } + else + { + OStringBuffer buf; + buf.append( "UNO struct " ); + buf.append( PyUnicode_AsUTF8(structName) ); + buf.append( " is unknown" ); + PyErr_SetString (PyExc_RuntimeError, buf.getStr()); + } + } + else + { + PyErr_SetString( + PyExc_RuntimeError, + "pyuno._createUnoStructHelper: 2nd argument (initializer sequence) is no tuple" ); + } + } + else + { + PyErr_SetString (PyExc_AttributeError, "createUnoStruct: first argument wasn't a string"); + } + } + else + { + PyErr_SetString (PyExc_AttributeError, "pyuno._createUnoStructHelper: expects exactly two non-keyword arguments:\n\tStructure Name\n\tinitialiser tuple; may be the empty tuple"); + } + } + catch( const css::uno::RuntimeException & e ) + { + raisePyExceptionWithAny( makeAny( e ) ); + } + catch( const css::script::CannotConvertException & e ) + { + raisePyExceptionWithAny( makeAny( e ) ); + } + catch( const css::uno::Exception & e ) + { + raisePyExceptionWithAny( makeAny( e ) ); + } + return ret.getAcquired(); +} + +static PyObject *getTypeByName( + SAL_UNUSED_PARAMETER PyObject *, PyObject *args ) +{ + PyObject * ret = nullptr; + + try + { + char *name; + + if (PyArg_ParseTuple (args, "s", &name)) + { + OUString typeName ( OUString::createFromAscii( name ) ); + TypeDescription typeDesc( typeName ); + if( typeDesc.is() ) + { + Runtime runtime; + ret = PyUNO_Type_new( + name, static_cast<css::uno::TypeClass>(typeDesc.get()->eTypeClass), runtime ); + } + else + { + OString buf = OStringLiteral("Type ") + name + " is unknown"; + PyErr_SetString( PyExc_RuntimeError, buf.getStr() ); + } + } + } + catch ( const RuntimeException & e ) + { + raisePyExceptionWithAny( makeAny( e ) ); + } + return ret; +} + +static PyObject *getConstantByName( + SAL_UNUSED_PARAMETER PyObject *, PyObject *args ) +{ + PyObject *ret = nullptr; + try + { + char *name; + + if (PyArg_ParseTuple (args, "s", &name)) + { + OUString typeName ( OUString::createFromAscii( name ) ); + Runtime runtime; + css::uno::Reference< css::reflection::XConstantTypeDescription > td; + if (!(runtime.getImpl()->cargo->xTdMgr->getByHierarchicalName( + typeName) + >>= td)) + { + throw RuntimeException( "pyuno.getConstantByName: " + typeName + "is not a constant" ); + } + PyRef constant = runtime.any2PyObject( td->getConstantValue() ); + ret = constant.getAcquired(); + } + } + catch( const NoSuchElementException & e ) + { + // to the python programmer, this is a runtime exception, + // do not support tweakings with the type system + RuntimeException runExc( e.Message ); + raisePyExceptionWithAny( makeAny( runExc ) ); + } + catch(const css::script::CannotConvertException & e) + { + raisePyExceptionWithAny( makeAny( e ) ); + } + catch(const css::lang::IllegalArgumentException & e) + { + raisePyExceptionWithAny( makeAny( e ) ); + } + catch( const RuntimeException & e ) + { + raisePyExceptionWithAny( makeAny(e) ); + } + return ret; +} + +static PyObject *checkType( SAL_UNUSED_PARAMETER PyObject *, PyObject *args ) +{ + if( !PyTuple_Check( args ) || PyTuple_Size( args) != 1 ) + { + OString buf = "pyuno.checkType : expecting one uno.Type argument"; + PyErr_SetString( PyExc_RuntimeError, buf.getStr() ); + return nullptr; + } + PyObject *obj = PyTuple_GetItem( args, 0 ); + + try + { + PyType2Type( obj ); + } + catch(const RuntimeException & e) + { + raisePyExceptionWithAny( makeAny( e ) ); + return nullptr; + } + Py_INCREF( Py_None ); + return Py_None; +} + +static PyObject *checkEnum( SAL_UNUSED_PARAMETER PyObject *, PyObject *args ) +{ + if( !PyTuple_Check( args ) || PyTuple_Size( args) != 1 ) + { + OString buf = "pyuno.checkType : expecting one uno.Type argument"; + PyErr_SetString( PyExc_RuntimeError, buf.getStr() ); + return nullptr; + } + PyObject *obj = PyTuple_GetItem( args, 0 ); + + try + { + PyEnum2Enum( obj ); + } + catch(const RuntimeException & e) + { + raisePyExceptionWithAny( makeAny( e) ); + return nullptr; + } + Py_INCREF( Py_None ); + return Py_None; +} + +static PyObject *getClass( SAL_UNUSED_PARAMETER PyObject *, PyObject *args ) +{ + PyObject *obj = extractOneStringArg( args, "pyuno.getClass"); + if( ! obj ) + return nullptr; + + try + { + Runtime runtime; + PyRef ret = getClass(pyString2ustring(obj), runtime); + Py_XINCREF( ret.get() ); + return ret.get(); + } + catch(const RuntimeException & e) + { + raisePyExceptionWithAny( makeAny(e) ); + } + return nullptr; +} + +static PyObject *isInterface( SAL_UNUSED_PARAMETER PyObject *, PyObject *args ) +{ + + if( PyTuple_Check( args ) && PyTuple_Size( args ) == 1 ) + { + PyObject *obj = PyTuple_GetItem( args, 0 ); + Runtime r; + return PyLong_FromLong( isInterfaceClass( r, obj ) ); + } + return PyLong_FromLong( 0 ); +} + +static PyObject * generateUuid( + SAL_UNUSED_PARAMETER PyObject *, SAL_UNUSED_PARAMETER PyObject * ) +{ + Sequence< sal_Int8 > seq( 16 ); + rtl_createUuid( reinterpret_cast<sal_uInt8*>(seq.getArray()) , nullptr , false ); + PyRef ret; + try + { + Runtime runtime; + ret = runtime.any2PyObject( makeAny( seq ) ); + } + catch( const RuntimeException & e ) + { + raisePyExceptionWithAny( makeAny(e) ); + } + return ret.getAcquired(); +} + +static PyObject *systemPathToFileUrl( + SAL_UNUSED_PARAMETER PyObject *, PyObject * args ) +{ + PyObject *obj = extractOneStringArg( args, "pyuno.systemPathToFileUrl" ); + if( ! obj ) + return nullptr; + + OUString sysPath = pyString2ustring( obj ); + OUString url; + osl::FileBase::RC e = osl::FileBase::getFileURLFromSystemPath( sysPath, url ); + + if( e != osl::FileBase::E_None ) + { + OUString buf = "Couldn't convert " + + sysPath + + " to a file url for reason (" + + OUString::number( static_cast<sal_Int32>(e) ) + + ")"; + raisePyExceptionWithAny( + makeAny( RuntimeException( buf ))); + return nullptr; + } + return ustring2PyUnicode( url ).getAcquired(); +} + +static PyObject * fileUrlToSystemPath( + SAL_UNUSED_PARAMETER PyObject *, PyObject * args ) +{ + PyObject *obj = extractOneStringArg( args, "pyuno.fileUrlToSystemPath" ); + if( ! obj ) + return nullptr; + + OUString url = pyString2ustring( obj ); + OUString sysPath; + osl::FileBase::RC e = osl::FileBase::getSystemPathFromFileURL( url, sysPath ); + + if( e != osl::FileBase::E_None ) + { + OUString buf = "Couldn't convert file url " + + sysPath + + " to a system path for reason (" + + OUString::number( static_cast<sal_Int32>(e) ) + + ")"; + raisePyExceptionWithAny( + makeAny( RuntimeException( buf ))); + return nullptr; + } + return ustring2PyUnicode( sysPath ).getAcquired(); +} + +static PyObject * absolutize( SAL_UNUSED_PARAMETER PyObject *, PyObject * args ) +{ + if( PyTuple_Check( args ) && PyTuple_Size( args ) == 2 ) + { + OUString ouPath = pyString2ustring( PyTuple_GetItem( args , 0 ) ); + OUString ouRel = pyString2ustring( PyTuple_GetItem( args, 1 ) ); + OUString ret; + oslFileError e = osl_getAbsoluteFileURL( ouPath.pData, ouRel.pData, &(ret.pData) ); + if( e != osl_File_E_None ) + { + OUString buf = + "Couldn't absolutize " + + ouRel + + " using root " + + ouPath + + " for reason (" + + OUString::number(static_cast<sal_Int32>(e) ) + + ")"; + + PyErr_SetString( + PyExc_OSError, + OUStringToOString(buf,osl_getThreadTextEncoding()).getStr()); + return nullptr; + } + return ustring2PyUnicode( ret ).getAcquired(); + } + return nullptr; +} + +static PyObject * invoke(SAL_UNUSED_PARAMETER PyObject *, PyObject *args) +{ + PyObject *ret = nullptr; + if(PyTuple_Check(args) && PyTuple_Size(args) == 3) + { + PyObject *object = PyTuple_GetItem(args, 0); + PyObject *item1 = PyTuple_GetItem(args, 1); + if (PyUnicode_Check(item1)) + { + const char *name = PyUnicode_AsUTF8(item1); + PyObject *item2 = PyTuple_GetItem(args, 2); + if(PyTuple_Check(item2)) + { + ret = PyUNO_invoke(object, name, item2); + } + else + { + OStringBuffer buf; + buf.append("uno.invoke expects a tuple as 3rd argument, got "); + buf.append(PyUnicode_AsUTF8(PyObject_Str(item2))); + PyErr_SetString( + PyExc_RuntimeError, buf.makeStringAndClear().getStr()); + } + } + else + { + OStringBuffer buf; + buf.append("uno.invoke expected a string as 2nd argument, got "); + buf.append(PyUnicode_AsUTF8(PyObject_Str(item1))); + PyErr_SetString( + PyExc_RuntimeError, buf.makeStringAndClear().getStr()); + } + } + else + { + OString buf = "uno.invoke expects object, name, (arg1, arg2, ... )\n"; + PyErr_SetString(PyExc_RuntimeError, buf.getStr()); + } + return ret; +} + +static PyObject *getCurrentContext( + SAL_UNUSED_PARAMETER PyObject *, SAL_UNUSED_PARAMETER PyObject * ) +{ + PyRef ret; + try + { + Runtime runtime; + ret = runtime.any2PyObject( + makeAny( css::uno::getCurrentContext() ) ); + } + catch( const css::uno::Exception & e ) + { + raisePyExceptionWithAny( makeAny( e ) ); + } + return ret.getAcquired(); +} + +static PyObject *setCurrentContext( + SAL_UNUSED_PARAMETER PyObject *, SAL_UNUSED_PARAMETER PyObject * args ) +{ + PyRef ret; + try + { + if( PyTuple_Check( args ) && PyTuple_Size( args ) == 1 ) + { + + Runtime runtime; + Any a = runtime.pyObject2Any( PyTuple_GetItem( args, 0 ) ); + + Reference< css::uno::XCurrentContext > context; + + if( (a.hasValue() && (a >>= context)) || ! a.hasValue() ) + { + ret = css::uno::setCurrentContext( context ) ? Py_True : Py_False; + } + else + { + OStringBuffer buf; + buf.append( "uno.setCurrentContext expects an XComponentContext implementation, got " ); + buf.append( + PyUnicode_AsUTF8(PyObject_Str(PyTuple_GetItem(args, 0)))); + PyErr_SetString( + PyExc_RuntimeError, buf.makeStringAndClear().getStr() ); + } + } + else + { + OString buf = "uno.setCurrentContext expects exactly one argument (the current Context)\n"; + PyErr_SetString( + PyExc_RuntimeError, buf.getStr() ); + } + } + catch( const css::uno::Exception & e ) + { + raisePyExceptionWithAny( makeAny( e ) ); + } + return ret.getAcquired(); +} + +static PyObject *sal_debug( + SAL_UNUSED_PARAMETER PyObject *, SAL_UNUSED_PARAMETER PyObject * args ) +{ + Py_INCREF( Py_None ); + if( !PyTuple_Check( args ) || PyTuple_Size( args) != 1 ) + return Py_None; + + OUString line = pyString2ustring( PyTuple_GetItem( args, 0 ) ); + + SAL_DEBUG(line); + + return Py_None; +} + +} + +struct PyMethodDef PyUNOModule_methods [] = +{ + {"private_initTestEnvironment", initTestEnvironment, METH_VARARGS, nullptr}, + {"private_deinitTestEnvironment", deinitTestEnvironment, METH_VARARGS, nullptr}, + {"getComponentContext", getComponentContext, METH_VARARGS, nullptr}, + {"_createUnoStructHelper", reinterpret_cast<PyCFunction>(createUnoStructHelper), METH_VARARGS | METH_KEYWORDS, nullptr}, + {"getTypeByName", getTypeByName, METH_VARARGS, nullptr}, + {"getConstantByName", getConstantByName, METH_VARARGS, nullptr}, + {"getClass", getClass, METH_VARARGS, nullptr}, + {"checkEnum", checkEnum, METH_VARARGS, nullptr}, + {"checkType", checkType, METH_VARARGS, nullptr}, + {"generateUuid", generateUuid, METH_VARARGS, nullptr}, + {"systemPathToFileUrl", systemPathToFileUrl, METH_VARARGS, nullptr}, + {"fileUrlToSystemPath", fileUrlToSystemPath, METH_VARARGS, nullptr}, + {"absolutize", absolutize, METH_VARARGS | METH_KEYWORDS, nullptr}, + {"isInterface", isInterface, METH_VARARGS, nullptr}, + {"invoke", invoke, METH_VARARGS | METH_KEYWORDS, nullptr}, + {"setCurrentContext", setCurrentContext, METH_VARARGS, nullptr}, + {"getCurrentContext", getCurrentContext, METH_VARARGS, nullptr}, + {"sal_debug", sal_debug, METH_VARARGS, nullptr}, + {nullptr, nullptr, 0, nullptr} +}; + +} + +extern "C" +PyObject* PyInit_pyuno() +{ + PyUNO_initType(); + PyUNOStruct_initType(); + // noop when called already, otherwise needed to allow multiple threads + PyEval_InitThreads(); + static struct PyModuleDef moduledef = + { + PyModuleDef_HEAD_INIT, + "pyuno", // module name + nullptr, // module documentation + -1, // module keeps state in global variables, + PyUNOModule_methods, // modules methods + nullptr, // m_reload (must be 0) + nullptr, // m_traverse + nullptr, // m_clear + nullptr, // m_free + }; + return PyModule_Create(&moduledef); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/pyuno_runtime.cxx b/pyuno/source/module/pyuno_runtime.cxx new file mode 100644 index 000000000..91005f1e1 --- /dev/null +++ b/pyuno/source/module/pyuno_runtime.cxx @@ -0,0 +1,1008 @@ +/* -*- Mode: C++; eval:(c-set-style "bsd"); 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 <config_folders.h> + +#include "pyuno_impl.hxx" + +#include <o3tl/any.hxx> +#include <osl/diagnose.h> +#include <osl/thread.h> +#include <osl/module.h> +#include <osl/process.h> +#include <rtl/ustrbuf.hxx> +#include <rtl/bootstrap.hxx> + +#include <typelib/typedescription.hxx> + +#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp> +#include <com/sun/star/beans/XMaterialHolder.hpp> +#include <com/sun/star/beans/theIntrospection.hpp> +#include <com/sun/star/container/XHierarchicalNameAccess.hpp> +#include <com/sun/star/script/Converter.hpp> +#include <com/sun/star/script/InvocationAdapterFactory.hpp> +#include <com/sun/star/script/XInvocation2.hpp> +#include <com/sun/star/reflection/theCoreReflection.hpp> +#include <com/sun/star/lang/XSingleServiceFactory.hpp> +#include <comphelper/sequence.hxx> +#include <comphelper/servicehelper.hxx> +#include <cppuhelper/exc_hlp.hxx> + +#include <vector> + +using com::sun::star::uno::Reference; +using com::sun::star::uno::XInterface; +using com::sun::star::uno::Any; +using com::sun::star::uno::TypeDescription; +using com::sun::star::uno::Sequence; +using com::sun::star::uno::Type; +using com::sun::star::uno::UNO_QUERY; +using com::sun::star::uno::Exception; +using com::sun::star::uno::RuntimeException; +using com::sun::star::uno::XComponentContext; +using com::sun::star::lang::WrappedTargetRuntimeException; +using com::sun::star::lang::XSingleServiceFactory; +using com::sun::star::lang::XUnoTunnel; +using com::sun::star::reflection::theCoreReflection; +using com::sun::star::reflection::InvocationTargetException; +using com::sun::star::script::Converter; +using com::sun::star::script::XTypeConverter; +using com::sun::star::script::XInvocation; +using com::sun::star::beans::XMaterialHolder; +using com::sun::star::beans::theIntrospection; + +namespace pyuno +{ + +static PyTypeObject RuntimeImpl_Type = +{ + PyVarObject_HEAD_INIT (&PyType_Type, 0) + "pyuno_runtime", + sizeof (RuntimeImpl), + 0, + RuntimeImpl::del, +#if PY_VERSION_HEX >= 0x03080000 + 0, // Py_ssize_t tp_vectorcall_offset +#else + nullptr, // printfunc tp_print +#endif + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + 0, + nullptr, + nullptr, + nullptr, + nullptr, + 0, + nullptr, + nullptr, + nullptr, + 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 +#endif +#endif +}; + +/*---------------------------------------------------------------------- + Runtime implementation + -----------------------------------------------------------------------*/ +/// @throws css::uno::RuntimeException +static void getRuntimeImpl( PyRef & globalDict, PyRef &runtimeImpl ) +{ + PyThreadState * state = PyThreadState_Get(); + if( ! state ) + { + throw RuntimeException( "python global interpreter must be held (thread must be attached)" ); + } + + PyObject* pModule = PyImport_AddModule("__main__"); + + if (!pModule) + { + throw RuntimeException("can't import __main__ module"); + } + + globalDict = PyRef( PyModule_GetDict(pModule)); + + if( ! globalDict.is() ) // FATAL ! + { + throw RuntimeException("can't find __main__ module"); + } + runtimeImpl = PyDict_GetItemString( globalDict.get() , "pyuno_runtime" ); +} + +/// @throws RuntimeException +static PyRef importUnoModule( ) +{ + // import the uno module + PyRef module( PyImport_ImportModule( "uno" ), SAL_NO_ACQUIRE, NOT_NULL ); + if( PyErr_Occurred() ) + { + PyRef excType, excValue, excTraceback; + PyErr_Fetch( reinterpret_cast<PyObject **>(&excType), reinterpret_cast<PyObject**>(&excValue), reinterpret_cast<PyObject**>(&excTraceback)); + // As of Python 2.7 this gives a rather non-useful "<traceback object at 0xADDRESS>", + // but it is the best we can do in the absence of uno._uno_extract_printable_stacktrace + // Who knows, a future Python might print something better. + PyRef str( PyObject_Str( excTraceback.get() ), SAL_NO_ACQUIRE ); + + OUStringBuffer buf; + buf.append( "python object raised an unknown exception (" ); + PyRef valueRep( PyObject_Repr( excValue.get() ), SAL_NO_ACQUIRE ); + buf.appendAscii( PyUnicode_AsUTF8( valueRep.get())).append( ", traceback follows\n" ); + buf.appendAscii( PyUnicode_AsUTF8( str.get() ) ); + buf.append( ")" ); + throw RuntimeException( buf.makeStringAndClear() ); + } + PyRef dict( PyModule_GetDict( module.get() ) ); + return dict; +} + +static void readLoggingConfig( sal_Int32 *pLevel, FILE **ppFile ) +{ + *pLevel = LogLevel::NONE; + *ppFile = nullptr; + OUString fileName; + osl_getModuleURLFromFunctionAddress( + reinterpret_cast< oslGenericFunction >(readLoggingConfig), + &fileName.pData ); + fileName = fileName.copy( fileName.lastIndexOf( '/' )+1 ); +#ifdef MACOSX + fileName += "../" LIBO_ETC_FOLDER "/"; +#endif + fileName += SAL_CONFIGFILE("pyuno" ); + rtl::Bootstrap bootstrapHandle( fileName ); + + OUString str; + if( bootstrapHandle.getFrom( "PYUNO_LOGLEVEL", str ) ) + { + if ( str == "NONE" ) + *pLevel = LogLevel::NONE; + else if ( str == "CALL" ) + *pLevel = LogLevel::CALL; + else if ( str == "ARGS" ) + *pLevel = LogLevel::ARGS; + else + { + fprintf( stderr, "unknown loglevel %s\n", + OUStringToOString( str, RTL_TEXTENCODING_UTF8 ).getStr() ); + } + } + if( *pLevel <= LogLevel::NONE ) + return; + + *ppFile = stdout; + if( !bootstrapHandle.getFrom( "PYUNO_LOGTARGET", str ) ) + return; + + if ( str == "stdout" ) + *ppFile = stdout; + else if ( str == "stderr" ) + *ppFile = stderr; + else + { + oslProcessInfo data; + data.Size = sizeof( data ); + osl_getProcessInfo( + nullptr , osl_Process_IDENTIFIER , &data ); + osl_getSystemPathFromFileURL( str.pData, &str.pData); + OString o = OUStringToOString( str, osl_getThreadTextEncoding() ); + o += "."; + o += OString::number( data.Ident ); + + *ppFile = fopen( o.getStr() , "w" ); + if ( *ppFile ) + { + // do not buffer (useful if e.g. analyzing a crash) + setvbuf( *ppFile, nullptr, _IONBF, 0 ); + } + else + { + fprintf( stderr, "couldn't create file %s\n", + OUStringToOString( str, RTL_TEXTENCODING_UTF8 ).getStr() ); + + } + } +} + +/*------------------------------------------------------------------- + RuntimeImpl implementations + *-------------------------------------------------------------------*/ +PyRef stRuntimeImpl::create( const Reference< XComponentContext > &ctx ) +{ + RuntimeImpl *me = PyObject_New (RuntimeImpl, &RuntimeImpl_Type); + if( ! me ) + throw RuntimeException( "cannot instantiate pyuno::RuntimeImpl" ); + me->cargo = nullptr; + // must use a different struct here, as the PyObject_New + // makes C++ unusable + RuntimeCargo *c = new RuntimeCargo; + readLoggingConfig( &(c->logLevel) , &(c->logFile) ); + log( c, LogLevel::CALL, "Instantiating pyuno bridge" ); + + c->valid = true; + c->xContext = ctx; + c->xInvocation = Reference< XSingleServiceFactory > ( + ctx->getServiceManager()->createInstanceWithContext( + "com.sun.star.script.Invocation", + ctx ), + css::uno::UNO_QUERY_THROW ); + + c->xTypeConverter = Converter::create(ctx); + if( ! c->xTypeConverter.is() ) + throw RuntimeException( "pyuno: couldn't instantiate typeconverter service" ); + + c->xCoreReflection = theCoreReflection::get(ctx); + + c->xAdapterFactory = css::script::InvocationAdapterFactory::create(ctx); + + c->xIntrospection = theIntrospection::get(ctx); + + Any a = ctx->getValueByName("/singletons/com.sun.star.reflection.theTypeDescriptionManager"); + a >>= c->xTdMgr; + if( ! c->xTdMgr.is() ) + throw RuntimeException( "pyuno: couldn't retrieve typedescriptionmanager" ); + + me->cargo =c; + return PyRef( reinterpret_cast< PyObject * > ( me ), SAL_NO_ACQUIRE ); +} + +void stRuntimeImpl::del(PyObject* self) +{ + RuntimeImpl *me = reinterpret_cast< RuntimeImpl * > ( self ); + if( me->cargo->logFile ) + fclose( me->cargo->logFile ); + delete me->cargo; + PyObject_Del (self); +} + + +void Runtime::initialize( const Reference< XComponentContext > & ctx ) +{ + PyRef globalDict, runtime; + getRuntimeImpl( globalDict , runtime ); + RuntimeImpl *impl = reinterpret_cast< RuntimeImpl * > (runtime.get()); + + if( runtime.is() && impl->cargo->valid ) + { + throw RuntimeException("pyuno runtime has already been initialized before" ); + } + PyRef keep( RuntimeImpl::create( ctx ) ); + PyDict_SetItemString( globalDict.get(), "pyuno_runtime" , keep.get() ); + Py_XINCREF( keep.get() ); +} + + +bool Runtime::isInitialized() +{ + PyRef globalDict, runtime; + getRuntimeImpl( globalDict , runtime ); + RuntimeImpl *impl = reinterpret_cast< RuntimeImpl * > (runtime.get()); + return runtime.is() && impl->cargo->valid; +} + +Runtime::Runtime() + : impl( nullptr ) +{ + PyRef globalDict, runtime; + getRuntimeImpl( globalDict , runtime ); + if( ! runtime.is() ) + { + throw RuntimeException( + "pyuno runtime is not initialized, " + "(the pyuno.bootstrap needs to be called before using any uno classes)" ); + } + impl = reinterpret_cast< RuntimeImpl * > (runtime.get()); + Py_XINCREF( runtime.get() ); +} + +Runtime::Runtime( const Runtime & r ) +{ + impl = r.impl; + Py_XINCREF( reinterpret_cast< PyObject * >(impl) ); +} + +Runtime::~Runtime() +{ + Py_XDECREF( reinterpret_cast< PyObject * >(impl) ); +} + +Runtime & Runtime::operator = ( const Runtime & r ) +{ + PyRef temp( reinterpret_cast< PyObject * >(r.impl) ); + Py_XINCREF( temp.get() ); + Py_XDECREF( reinterpret_cast< PyObject * >(impl) ); + impl = r.impl; + return *this; +} + +PyRef Runtime::any2PyObject (const Any &a ) const +{ + if( ! impl->cargo->valid ) + { + throw RuntimeException("pyuno runtime must be initialized before calling any2PyObject" ); + } + + switch (a.getValueTypeClass ()) + { + case css::uno::TypeClass_VOID: + { + Py_INCREF (Py_None); + return PyRef(Py_None); + } + case css::uno::TypeClass_CHAR: + { + sal_Unicode c = *o3tl::forceAccess<sal_Unicode>(a); + return PyRef( PyUNO_char_new( c , *this ), SAL_NO_ACQUIRE ); + } + case css::uno::TypeClass_BOOLEAN: + { + bool b; + if ((a >>= b) && b) + return Py_True; + else + return Py_False; + } + case css::uno::TypeClass_BYTE: + case css::uno::TypeClass_SHORT: + case css::uno::TypeClass_UNSIGNED_SHORT: + case css::uno::TypeClass_LONG: + { + sal_Int32 l = 0; + a >>= l; + return PyRef( PyLong_FromLong (l), SAL_NO_ACQUIRE ); + } + case css::uno::TypeClass_UNSIGNED_LONG: + { + sal_uInt32 l = 0; + a >>= l; + return PyRef( PyLong_FromUnsignedLong (l), SAL_NO_ACQUIRE ); + } + case css::uno::TypeClass_HYPER: + { + sal_Int64 l = 0; + a >>= l; + return PyRef( PyLong_FromLongLong (l), SAL_NO_ACQUIRE); + } + case css::uno::TypeClass_UNSIGNED_HYPER: + { + sal_uInt64 l = 0; + a >>= l; + return PyRef( PyLong_FromUnsignedLongLong (l), SAL_NO_ACQUIRE); + } + case css::uno::TypeClass_FLOAT: + { + float f = 0.0; + a >>= f; + return PyRef(PyFloat_FromDouble (f), SAL_NO_ACQUIRE); + } + case css::uno::TypeClass_DOUBLE: + { + double d = 0.0; + a >>= d; + return PyRef( PyFloat_FromDouble (d), SAL_NO_ACQUIRE); + } + case css::uno::TypeClass_STRING: + { + OUString tmp_ostr; + a >>= tmp_ostr; + return ustring2PyUnicode( tmp_ostr ); + } + case css::uno::TypeClass_TYPE: + { + Type t; + a >>= t; + OString o = OUStringToOString( t.getTypeName(), RTL_TEXTENCODING_ASCII_US ); + return PyRef( + PyUNO_Type_new ( + o.getStr(), t.getTypeClass(), *this), + SAL_NO_ACQUIRE); + } + case css::uno::TypeClass_ANY: + { + //I don't think this can happen. + Py_INCREF (Py_None); + return Py_None; + } + case css::uno::TypeClass_ENUM: + { + sal_Int32 l = *static_cast<sal_Int32 const *>(a.getValue()); + TypeDescription desc( a.getValueType() ); + if( desc.is() ) + { + desc.makeComplete(); + typelib_EnumTypeDescription *pEnumDesc = + reinterpret_cast<typelib_EnumTypeDescription *>(desc.get()); + for( int i = 0 ; i < pEnumDesc->nEnumValues ; i ++ ) + { + if( pEnumDesc->pEnumValues[i] == l ) + { + OString v = OUStringToOString( pEnumDesc->ppEnumNames[i], RTL_TEXTENCODING_ASCII_US); + OString e = OUStringToOString( pEnumDesc->aBase.pTypeName, RTL_TEXTENCODING_ASCII_US); + return PyRef( PyUNO_Enum_new(e.getStr(),v.getStr(), *this ), SAL_NO_ACQUIRE ); + } + } + } + throw RuntimeException( "Any carries enum " + a.getValueType().getTypeName() + + " with invalid value " + OUString::number(l) ); + } + case css::uno::TypeClass_EXCEPTION: + case css::uno::TypeClass_STRUCT: + { + PyRef excClass = getClass( a.getValueType().getTypeName(), *this ); + PyRef value = PyUNOStruct_new( a, getImpl()->cargo->xInvocation ); + PyRef argsTuple( PyTuple_New( 1 ) , SAL_NO_ACQUIRE, NOT_NULL ); + PyTuple_SetItem( argsTuple.get() , 0 , value.getAcquired() ); + PyRef ret( PyObject_CallObject( excClass.get() , argsTuple.get() ), SAL_NO_ACQUIRE ); + if( ! ret.is() ) + { + throw RuntimeException( "Couldn't instantiate python representation of structured UNO type " + + a.getValueType().getTypeName() ); + } + + if( auto e = o3tl::tryAccess<css::uno::Exception>(a) ) + { + // add the message in a standard python way ! + PyRef args( PyTuple_New( 1 ), SAL_NO_ACQUIRE, NOT_NULL ); + + PyRef pymsg = ustring2PyString( e->Message ); + PyTuple_SetItem( args.get(), 0 , pymsg.getAcquired() ); + // the exception base functions want to have an "args" tuple, + // which contains the message + PyObject_SetAttrString( ret.get(), "args", args.get() ); + } + return ret; + } + case css::uno::TypeClass_SEQUENCE: + { + Sequence<Any> s; + + Sequence< sal_Int8 > byteSequence; + if( a >>= byteSequence ) + { + // byte sequence is treated in a special way because of performance reasons + // @since 0.9.2 + return PyRef( PyUNO_ByteSequence_new( byteSequence, *this ), SAL_NO_ACQUIRE ); + } + else + { + Reference< XTypeConverter > tc = getImpl()->cargo->xTypeConverter; + tc->convertTo (a, cppu::UnoType<decltype(s)>::get()) >>= s; + PyRef tuple( PyTuple_New (s.getLength()), SAL_NO_ACQUIRE, NOT_NULL); + int i=0; + try + { + for ( i = 0; i < s.getLength (); i++) + { + PyRef element = any2PyObject (tc->convertTo (s[i], s[i].getValueType() )); + OSL_ASSERT( element.is() ); + PyTuple_SetItem( tuple.get(), i, element.getAcquired() ); + } + } + catch( css::uno::Exception & ) + { + for( ; i < s.getLength() ; i ++ ) + { + Py_INCREF( Py_None ); + PyTuple_SetItem( tuple.get(), i, Py_None ); + } + throw; + } + return tuple; + } + } + case css::uno::TypeClass_INTERFACE: + { + Reference<XInterface> tmp_interface; + a >>= tmp_interface; + if (!tmp_interface.is ()) + return Py_None; + + return PyUNO_new( a, getImpl()->cargo->xInvocation ); + } + default: + { + throw RuntimeException( "Unknown UNO type class " + OUString::number(static_cast<int>(a.getValueTypeClass())) ); + } + } +} + +static Sequence< Type > invokeGetTypes( const Runtime & r , PyObject * o ) +{ + Sequence< Type > ret; + + PyRef method( PyObject_GetAttrString( o , "getTypes" ), SAL_NO_ACQUIRE ); + raiseInvocationTargetExceptionWhenNeeded( r ); + if( method.is() && PyCallable_Check( method.get() ) ) + { + PyRef types( PyObject_CallObject( method.get(), nullptr ) , SAL_NO_ACQUIRE ); + raiseInvocationTargetExceptionWhenNeeded( r ); + if( types.is() && PyTuple_Check( types.get() ) ) + { + int size = PyTuple_Size( types.get() ); + + // add the XUnoTunnel interface for uno object identity concept (hack) + ret.realloc( size + 1 ); + for( int i = 0 ; i < size ; i ++ ) + { + Any a = r.pyObject2Any(PyTuple_GetItem(types.get(),i)); + a >>= ret[i]; + } + ret[size] = cppu::UnoType<css::lang::XUnoTunnel>::get(); + } + } + return ret; +} + +static OUString +lcl_ExceptionMessage(PyObject *const o, OUString const*const pWrapped) +{ + OUStringBuffer buf; + buf.append("Couldn't convert "); + PyRef reprString( PyObject_Str(o), SAL_NO_ACQUIRE ); + buf.appendAscii( PyUnicode_AsUTF8(reprString.get()) ); + buf.append(" to a UNO type"); + if (pWrapped) + { + buf.append("; caught exception: "); + buf.append(*pWrapped); + } + return buf.makeStringAndClear(); +} + +// For Python 2.7 - see https://bugs.python.org/issue24161 +// Fills aSeq and returns true if pObj is a valid iterator +bool Runtime::pyIterUnpack( PyObject *const pObj, Any &a ) const +{ + if( !PyIter_Check( pObj )) + return false; + + PyObject *pItem = PyIter_Next( pObj ); + if( !pItem ) + { + if( PyErr_Occurred() ) + { + PyErr_Clear(); + return false; + } + return true; + } + + ::std::vector<Any> items; + do + { + PyRef rItem( pItem, SAL_NO_ACQUIRE ); + items.push_back( pyObject2Any( rItem.get() ) ); + pItem = PyIter_Next( pObj ); + } + while( pItem ); + a <<= comphelper::containerToSequence(items); + return true; +} + +Any Runtime::pyObject2Any ( const PyRef & source, enum ConversionMode mode ) const +{ + if( ! impl->cargo->valid ) + { + throw RuntimeException("pyuno runtime must be initialized before calling any2PyObject" ); + } + + Any a; + PyObject *o = source.get(); + if( Py_None == o ) + { + + } + else if (PyLong_Check (o)) + { + // Convert the Python 3 booleans that are actually of type PyLong. + if(o == Py_True) + { + a <<= true; + } + else if(o == Py_False) + { + a <<= false; + } + else + { + sal_Int64 l = static_cast<sal_Int64>(PyLong_AsLong (o)); + if( l < 128 && l >= -128 ) + { + sal_Int8 b = static_cast<sal_Int8>(l); + a <<= b; + } + else if( l <= 0x7fff && l >= -0x8000 ) + { + sal_Int16 s = static_cast<sal_Int16>(l); + a <<= s; + } + else if( l <= SAL_CONST_INT64(0x7fffffff) && + l >= -SAL_CONST_INT64(0x80000000) ) + { + sal_Int32 l32 = static_cast<sal_Int32>(l); + a <<= l32; + } + else + { + a <<= l; + } + } + } + else if (PyFloat_Check (o)) + { + double d = PyFloat_AsDouble (o); + a <<= d; + } + else if (PyBytes_Check(o) || PyUnicode_Check(o)) + { + a <<= pyString2ustring(o); + } + else if (PyTuple_Check (o)) + { + Sequence<Any> s (PyTuple_Size (o)); + for (Py_ssize_t i = 0; i < PyTuple_Size (o); i++) + { + s[i] = pyObject2Any (PyTuple_GetItem (o, i), mode ); + } + a <<= s; + } + else if (PyList_Check (o)) + { + Py_ssize_t l = PyList_Size (o); + Sequence<Any> s (l); + for (Py_ssize_t i = 0; i < l; i++) + { + s[i] = pyObject2Any (PyList_GetItem (o, i), mode ); + } + a <<= s; + } + else if (!pyIterUnpack (o, a)) + { + Runtime runtime; + // should be removed, in case ByteSequence gets derived from String + if( PyObject_IsInstance( o, getByteSequenceClass( runtime ).get() ) ) + { + PyRef str(PyObject_GetAttrString( o , "value" ),SAL_NO_ACQUIRE); + Sequence< sal_Int8 > seq; + if( PyBytes_Check( str.get() ) ) + { + seq = Sequence<sal_Int8 > ( + reinterpret_cast<sal_Int8*>(PyBytes_AsString(str.get())), PyBytes_Size(str.get())); + } + a <<= seq; + } + else + if( PyObject_IsInstance( o, getTypeClass( runtime ).get() ) ) + { + Type t = PyType2Type( o ); + a <<= t; + } + else if( PyObject_IsInstance( o, getEnumClass( runtime ).get() ) ) + { + a = PyEnum2Enum( o ); + } + else if( isInstanceOfStructOrException( o ) ) + { + PyRef struc(PyObject_GetAttrString( o , "value" ),SAL_NO_ACQUIRE); + PyUNO * obj = reinterpret_cast<PyUNO*>(struc.get()); + Reference< XMaterialHolder > holder( obj->members->xInvocation, UNO_QUERY ); + if( !holder.is( ) ) + { + throw RuntimeException( + "struct or exception wrapper does not support XMaterialHolder" ); + } + + a = holder->getMaterial(); + + } + else if( PyObject_IsInstance( o, getPyUnoClass().get() ) ) + { + PyUNO* o_pi = reinterpret_cast<PyUNO*>(o); + a = o_pi->members->wrappedObject; + } + else if( PyObject_IsInstance( o, getPyUnoStructClass().get() ) ) + { + PyUNO* o_pi = reinterpret_cast<PyUNO*>(o); + Reference<XMaterialHolder> my_mh (o_pi->members->xInvocation, css::uno::UNO_QUERY_THROW); + a = my_mh->getMaterial(); + } + else if( PyObject_IsInstance( o, getCharClass( runtime ).get() ) ) + { + a <<= PyChar2Unicode( o ); + } + else if( PyObject_IsInstance( o, getAnyClass( runtime ).get() ) ) + { + if( ACCEPT_UNO_ANY != mode ) + { + throw RuntimeException( + "uno.Any instance not accepted during method call, " + "use uno.invoke instead" ); + } + + a = pyObject2Any( PyRef( PyObject_GetAttrString( o , "value" ), SAL_NO_ACQUIRE) ); + Type t; + pyObject2Any( PyRef( PyObject_GetAttrString( o, "type" ), SAL_NO_ACQUIRE ) ) >>= t; + + try + { + a = getImpl()->cargo->xTypeConverter->convertTo( a, t ); + } + catch( const css::uno::Exception & e ) + { + css::uno::Any anyEx = cppu::getCaughtException(); + throw WrappedTargetRuntimeException( + e.Message, e.Context, anyEx); + } + + } + else + { + Reference< XInterface > mappedObject; + Reference< XInvocation > adapterObject; + + // instance already mapped out to the world ? + PyRef2Adapter::iterator ii = impl->cargo->mappedObjects.find( PyRef( o ) ); + if( ii != impl->cargo->mappedObjects.end() ) + { + adapterObject = ii->second; + } + + if( adapterObject.is() ) + { + // object got already bridged ! + auto pAdapter = comphelper::getUnoTunnelImplementation<Adapter>(adapterObject); + + mappedObject = impl->cargo->xAdapterFactory->createAdapter( + adapterObject, pAdapter->getWrappedTypes() ); + } + else + { + try { + Sequence<Type> interfaces = invokeGetTypes(*this, o); + if (interfaces.getLength()) + { + Adapter *pAdapter = new Adapter( o, interfaces ); + mappedObject = + getImpl()->cargo->xAdapterFactory->createAdapter( + pAdapter, interfaces ); + + // keep a list of exported objects to ensure object identity ! + impl->cargo->mappedObjects[ PyRef(o) ] = + css::uno::WeakReference< XInvocation > ( pAdapter ); + } + } catch (InvocationTargetException const& e) { + OUString const msg(lcl_ExceptionMessage(o, &e.Message)); + throw WrappedTargetRuntimeException( // re-wrap that + msg, e.Context, e.TargetException); + } + } + if( mappedObject.is() ) + { + a <<= mappedObject; + } + else + { + OUString const msg(lcl_ExceptionMessage(o, nullptr)); + throw RuntimeException(msg); + } + } + } + return a; +} + +Any Runtime::extractUnoException( const PyRef & excType, const PyRef &excValue, const PyRef &excTraceback) const +{ + OUString str; + Any ret; + if( excTraceback.is() ) + { + Exception e; + PyRef unoModule; + if ( impl ) + { + try + { + unoModule = impl->cargo->getUnoModule(); + } + catch (const Exception &ei) + { + e=ei; + } + } + if( unoModule.is() ) + { + PyRef extractTraceback( + PyDict_GetItemString(unoModule.get(),"_uno_extract_printable_stacktrace" ) ); + + if( PyCallable_Check(extractTraceback.get()) ) + { + PyRef args( PyTuple_New( 1), SAL_NO_ACQUIRE, NOT_NULL ); + PyTuple_SetItem( args.get(), 0, excTraceback.getAcquired() ); + PyRef pyStr( PyObject_CallObject( extractTraceback.get(),args.get() ), SAL_NO_ACQUIRE); + str = OUString::createFromAscii( PyUnicode_AsUTF8(pyStr.get()) ); + } + else + { + str = "Couldn't find uno._uno_extract_printable_stacktrace"; + } + } + else + { + str = "Could not load uno.py, no stacktrace available"; + if ( !e.Message.isEmpty() ) + { + str += " (Error loading uno.py: " + e.Message + ")"; + } + } + + } + else + { + // it may occur, that no traceback is given (e.g. only native code below) + str = "no traceback available"; + } + + if( isInstanceOfStructOrException( excValue.get() ) ) + { + ret = pyObject2Any( excValue ); + } + else + { + OUStringBuffer buf; + PyRef typeName( PyObject_Str( excType.get() ), SAL_NO_ACQUIRE ); + if( typeName.is() ) + { + buf.appendAscii( PyUnicode_AsUTF8( typeName.get() ) ); + } + else + { + buf.append( "no typename available" ); + } + buf.append( ": " ); + PyRef valueRep( PyObject_Str( excValue.get() ), SAL_NO_ACQUIRE ); + if( valueRep.is() ) + { + buf.appendAscii( PyUnicode_AsUTF8( valueRep.get())); + } + else + { + buf.append( "Couldn't convert exception value to a string" ); + } + buf.append( ", traceback follows\n" ); + if( !str.isEmpty() ) + { + buf.append( str ); + buf.append( "\n" ); + } + else + { + buf.append( ", no traceback available\n" ); + } + RuntimeException e; + e.Message = buf.makeStringAndClear(); +#if OSL_DEBUG_LEVEL > 0 + fprintf( stderr, "Python exception: %s\n", + OUStringToOString(e.Message, RTL_TEXTENCODING_UTF8).getStr() ); +#endif + ret <<= e; + } + return ret; +} + + +PyThreadAttach::PyThreadAttach( PyInterpreterState *interp) + : m_isNewState(false) +{ + // note: *may* be called recursively, with PyThreadDetach between - in + // that case, don't create *new* PyThreadState but reuse! + tstate = PyGILState_GetThisThreadState(); // from TLS, possibly detached + if (!tstate) + { + m_isNewState = true; + tstate = PyThreadState_New( interp ); + } + if( !tstate ) + throw RuntimeException( "Couldn't create a pythreadstate" ); + PyEval_AcquireThread( tstate); +} + +PyThreadAttach::~PyThreadAttach() +{ + if (m_isNewState) + { // Clear needs GIL! + PyThreadState_Clear( tstate ); + // note: PyThreadState_Delete(tstate) cannot be called, it will assert + // because it requires a PyThreadState to be set, but not the tstate! + PyThreadState_DeleteCurrent(); + } + else + { + PyEval_ReleaseThread( tstate ); + } +} + +PyThreadDetach::PyThreadDetach() +{ + tstate = PyThreadState_Get(); + PyEval_ReleaseThread( tstate ); + // tstate must not be deleted here! lots of pointers to it on the stack +} + + /** Acquires the global interpreter lock again + + */ +PyThreadDetach::~PyThreadDetach() +{ + PyEval_AcquireThread( tstate ); +} + + +PyRef const & RuntimeCargo::getUnoModule() +{ + if( ! dictUnoModule.is() ) + { + dictUnoModule = importUnoModule(); + } + return dictUnoModule; +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/pyuno_struct.cxx b/pyuno/source/module/pyuno_struct.cxx new file mode 100644 index 000000000..a5b127dc2 --- /dev/null +++ b/pyuno/source/module/pyuno_struct.cxx @@ -0,0 +1,400 @@ +/* -*- 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 <rtl/strbuf.hxx> + +#include <com/sun/star/beans/UnknownPropertyException.hpp> +#include <com/sun/star/beans/XMaterialHolder.hpp> +#include <com/sun/star/script/CannotConvertException.hpp> +#include <com/sun/star/script/XInvocation2.hpp> +#include <com/sun/star/lang/XSingleServiceFactory.hpp> + +#include "pyuno_impl.hxx" + +using com::sun::star::uno::Sequence; +using com::sun::star::uno::Reference; +using com::sun::star::uno::Any; +using com::sun::star::uno::makeAny; +using com::sun::star::uno::UNO_QUERY; +using com::sun::star::uno::TypeClass; +using com::sun::star::uno::RuntimeException; +using com::sun::star::uno::Exception; +using com::sun::star::lang::XSingleServiceFactory; +using com::sun::star::script::XInvocation2; +using com::sun::star::beans::XMaterialHolder; + +namespace pyuno +{ + +static void PyUNOStruct_del( PyObject* self ) +{ + PyUNO *me = reinterpret_cast<PyUNO*>( self ); + { + PyThreadDetach antiguard; + delete me->members; + } + PyObject_Del( self ); +} + +static PyObject *PyUNOStruct_str( PyObject *self ) +{ + PyUNO *me = reinterpret_cast<PyUNO*>( self ); + OString buf; + + Reference<XMaterialHolder> rHolder( me->members->xInvocation,UNO_QUERY ); + if( rHolder.is() ) + { + PyThreadDetach antiguard; + Any a = rHolder->getMaterial(); + OUString s = val2str( a.getValue(), a.getValueType().getTypeLibType() ); + buf = OUStringToOString( s, RTL_TEXTENCODING_ASCII_US ); + } + + return PyUnicode_FromString( buf.getStr()); +} + +static PyObject *PyUNOStruct_repr( PyObject *self ) +{ + PyUNO *me = reinterpret_cast<PyUNO*>( self ); + PyObject *ret = nullptr; + + if( me->members->wrappedObject.getValueType().getTypeClass() + == css::uno::TypeClass_EXCEPTION ) + { + Reference< XMaterialHolder > rHolder(me->members->xInvocation,UNO_QUERY); + if( rHolder.is() ) + { + Any a = rHolder->getMaterial(); + Exception e; + a >>= e; + ret = ustring2PyUnicode(e.Message ).getAcquired(); + } + } + else + { + ret = PyUNOStruct_str( self ); + } + + return ret; +} + +static PyObject* PyUNOStruct_dir( PyObject *self ) +{ + PyUNO *me = reinterpret_cast<PyUNO*>( self ); + + PyObject* member_list = nullptr; + + try + { + member_list = PyList_New( 0 ); + const css::uno::Sequence<OUString> aMemberNames = me->members->xInvocation->getMemberNames(); + for( const auto& aMember : aMemberNames ) + { + // setitem steals a reference + PyList_Append( member_list, ustring2PyString( aMember ).getAcquired() ); + } + } + catch( const RuntimeException &e ) + { + raisePyExceptionWithAny( makeAny(e) ); + } + + return member_list; +} + +static PyObject* PyUNOStruct_getattr( PyObject* self, char* name ) +{ + PyUNO *me = reinterpret_cast<PyUNO*>( self ); + + try + { + Runtime runtime; + + 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 ) + { + return getClass( + me->members->wrappedObject.getValueType().getTypeName(), runtime ).getAcquired(); + } + + PyObject *pRet = PyObject_GenericGetAttr( self, PyUnicode_FromString( name ) ); + if( pRet ) + return pRet; + PyErr_Clear(); + + OUString attrName( OUString::createFromAscii( name ) ); + if( me->members->xInvocation->hasProperty( attrName ) ) + { + //Return the value of the property + Any anyRet; + { + PyThreadDetach antiguard; + anyRet = me->members->xInvocation->getValue( attrName ); + } + 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( makeAny(e) ); + } + catch( const css::lang::IllegalArgumentException &e ) + { + raisePyExceptionWithAny( makeAny(e) ); + } + catch( const css::script::CannotConvertException &e ) + { + raisePyExceptionWithAny( makeAny(e) ); + } + catch( const RuntimeException &e ) + { + raisePyExceptionWithAny( makeAny(e) ); + } + + return nullptr; +} + +static int PyUNOStruct_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( makeAny(e) ); + return 1; + } + catch( const css::script::CannotConvertException &e ) + { + raisePyExceptionWithAny( makeAny(e) ); + return 1; + } + catch( const RuntimeException & e ) + { + raisePyExceptionWithAny( makeAny( e ) ); + return 1; + } + PyErr_SetString (PyExc_AttributeError, name); + return 1; //as above. +} + + +static PyObject* PyUNOStruct_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, getPyUnoStructClass().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( tcMe == css::uno::TypeClass_STRUCT || + tcMe == css::uno::TypeClass_EXCEPTION ) + { + Reference< XMaterialHolder > xMe( me->members->xInvocation,UNO_QUERY ); + Reference< XMaterialHolder > xOther( other->members->xInvocation,UNO_QUERY ); + if( xMe->getMaterial() == xOther->getMaterial() ) + { + result = (op == Py_EQ ? Py_True : Py_False); + Py_INCREF( result ); + return result; + } + } + } + } + } + catch( const css::uno::RuntimeException & e) + { + raisePyExceptionWithAny( makeAny( e ) ); + } + + result = (op == Py_EQ ? Py_False : Py_True); + Py_INCREF(result); + return result; +} + +static PyMethodDef PyUNOStructMethods[] = +{ + {"__dir__", reinterpret_cast<PyCFunction>(PyUNOStruct_dir), METH_NOARGS, nullptr}, + {nullptr, nullptr, 0, nullptr} +}; + +static PyTypeObject PyUNOStructType = +{ + PyVarObject_HEAD_INIT( &PyType_Type, 0 ) + "pyuno.struct", + sizeof (PyUNO), + 0, + PyUNOStruct_del, +#if PY_VERSION_HEX >= 0x03080000 + 0, // Py_ssize_t tp_vectorcall_offset +#else + nullptr, // printfunc tp_print +#endif + PyUNOStruct_getattr, + PyUNOStruct_setattr, + /* this type does not exist in Python 3: (cmpfunc) */ nullptr, + PyUNOStruct_repr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + PyUNOStruct_str, + nullptr, + nullptr, + nullptr, + Py_TPFLAGS_HAVE_RICHCOMPARE, + nullptr, + nullptr, + nullptr, + PyUNOStruct_cmp, + 0, + nullptr, + nullptr, + PyUNOStructMethods, + 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 +#endif +#endif +}; + +int PyUNOStruct_initType() +{ + return PyType_Ready( &PyUNOStructType ); +} + +PyRef getPyUnoStructClass() +{ + return PyRef( reinterpret_cast< PyObject * > ( &PyUNOStructType ) ); +} + +PyRef PyUNOStruct_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 ); + } + if( !Py_IsInitialized() ) + throw RuntimeException(); + + PyUNO* self = PyObject_New (PyUNO, &PyUNOStructType); + 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: */ diff --git a/pyuno/source/module/pyuno_type.cxx b/pyuno/source/module/pyuno_type.cxx new file mode 100644 index 000000000..a6c1bc447 --- /dev/null +++ b/pyuno/source/module/pyuno_type.cxx @@ -0,0 +1,292 @@ +/* -*- 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 "pyuno_impl.hxx" + +#include <o3tl/any.hxx> + +#include <rtl/strbuf.hxx> + +#include <typelib/typedescription.hxx> + + +using com::sun::star::uno::TypeClass; +using com::sun::star::uno::Type; +using com::sun::star::uno::RuntimeException; +using com::sun::star::uno::Any; +using com::sun::star::uno::TypeDescription; + +namespace pyuno +{ +const char *typeClassToString( TypeClass t ) +{ + const char * ret = nullptr; + switch (t) + { + case css::uno::TypeClass_VOID: + ret = "VOID"; break; + case css::uno::TypeClass_CHAR: + ret = "CHAR"; break; + case css::uno::TypeClass_BOOLEAN: + ret = "BOOLEAN"; break; + case css::uno::TypeClass_BYTE: + ret = "BYTE"; break; + case css::uno::TypeClass_SHORT: + ret = "SHORT"; break; + case css::uno::TypeClass_UNSIGNED_SHORT: + ret = "UNSIGNED_SHORT"; break; + case css::uno::TypeClass_LONG: + ret = "LONG"; break; + case css::uno::TypeClass_UNSIGNED_LONG: + ret = "UNSIGNED_LONG"; break; + case css::uno::TypeClass_HYPER: + ret = "HYPER"; break; + case css::uno::TypeClass_UNSIGNED_HYPER: + ret = "UNSIGNED_HYPER"; break; + case css::uno::TypeClass_FLOAT: + ret = "FLOAT"; break; + case css::uno::TypeClass_DOUBLE: + ret = "DOUBLE"; break; + case css::uno::TypeClass_STRING: + ret = "STRING"; break; + case css::uno::TypeClass_TYPE: + ret = "TYPE"; break; + case css::uno::TypeClass_ANY: + ret = "ANY";break; + case css::uno::TypeClass_ENUM: + ret = "ENUM";break; + case css::uno::TypeClass_STRUCT: + ret = "STRUCT"; break; + case css::uno::TypeClass_EXCEPTION: + ret = "EXCEPTION"; break; + case css::uno::TypeClass_SEQUENCE: + ret = "SEQUENCE"; break; + case css::uno::TypeClass_INTERFACE: + ret = "INTERFACE"; break; + case css::uno::TypeClass_TYPEDEF: + ret = "TYPEDEF"; break; + case css::uno::TypeClass_SERVICE: + ret = "SERVICE"; break; + case css::uno::TypeClass_MODULE: + ret = "MODULE"; break; + case css::uno::TypeClass_INTERFACE_METHOD: + ret = "INTERFACE_METHOD"; break; + case css::uno::TypeClass_INTERFACE_ATTRIBUTE: + ret = "INTERFACE_ATTRIBUTE"; break; + default: + ret = "UNKNOWN"; break; + } + return ret; +} + +static PyRef getClass( const Runtime & r , const char * name) +{ + return PyRef( PyDict_GetItemString( r.getImpl()->cargo->getUnoModule().get(), name ) ); +} + +PyRef getTypeClass( const Runtime & r ) +{ + return getClass( r , "Type" ); +} + +PyRef getEnumClass( const Runtime & r ) +{ + return getClass( r , "Enum" ); +} + +PyRef getCharClass( const Runtime & r ) +{ + return getClass( r , "Char" ); +} + +PyRef getByteSequenceClass( const Runtime & r ) +{ + return getClass( r , "ByteSequence" ); +} + +PyRef getAnyClass( const Runtime & r ) +{ + return getClass( r , "Any" ); +} + + +sal_Unicode PyChar2Unicode( PyObject *obj ) +{ + PyRef value( PyObject_GetAttrString( obj, "value" ), SAL_NO_ACQUIRE ); + if( ! PyUnicode_Check( value.get() ) ) + { + throw RuntimeException( + "attribute value of uno.Char is not a unicode string" ); + } + + if( PyUnicode_GetLength( value.get() ) < 1 ) + { + throw RuntimeException( + "uno.Char contains an empty unicode string"); + } + + sal_Unicode c = static_cast<sal_Unicode>(PyUnicode_AsUnicode( value.get() )[0]); + return c; +} + +Any PyEnum2Enum( PyObject *obj ) +{ + Any ret; + PyRef typeName( PyObject_GetAttrString( obj,"typeName" ), SAL_NO_ACQUIRE); + PyRef value( PyObject_GetAttrString( obj, "value" ), SAL_NO_ACQUIRE); + if( !PyUnicode_Check( typeName.get() ) || ! PyUnicode_Check( value.get() ) ) + { + throw RuntimeException( + "attributes typeName and/or value of uno.Enum are not strings" ); + } + + OUString strTypeName( OUString::createFromAscii( PyUnicode_AsUTF8( typeName.get() ) ) ); + char const *stringValue = PyUnicode_AsUTF8( value.get() ); + + TypeDescription desc( strTypeName ); + if( !desc.is() ) + { + throw RuntimeException( "enum " + OUString::createFromAscii( PyUnicode_AsUTF8(typeName.get()) ) + " is unknown" ); + } + + if(desc.get()->eTypeClass != typelib_TypeClass_ENUM ) + { + throw RuntimeException( "pyuno.checkEnum: " + strTypeName + "is a " + + OUString::createFromAscii(typeClassToString( static_cast<css::uno::TypeClass>(desc.get()->eTypeClass))) + + ", expected ENUM" ); + } + + desc.makeComplete(); + + typelib_EnumTypeDescription *pEnumDesc = reinterpret_cast<typelib_EnumTypeDescription*>(desc.get()); + int i = 0; + for( i = 0; i < pEnumDesc->nEnumValues ; i ++ ) + { + if( OUString::unacquired(&pEnumDesc->ppEnumNames[i]).equalsAscii( stringValue ) ) + { + break; + } + } + if( i == pEnumDesc->nEnumValues ) + { + throw RuntimeException( "value " + OUString::createFromAscii( stringValue ) + + "is unknown in enum " + + OUString::createFromAscii( PyUnicode_AsUTF8( typeName.get() ) ) ); + } + ret = Any( &pEnumDesc->pEnumValues[i], desc.get()->pWeakRef ); + + return ret; +} + + +Type PyType2Type( PyObject * o ) +{ + PyRef pyName( PyObject_GetAttrString( o, "typeName" ), SAL_NO_ACQUIRE); + if( !PyUnicode_Check( pyName.get() ) ) + { + throw RuntimeException( + "type object does not have typeName property" ); + } + + PyRef pyTC( PyObject_GetAttrString( o, "typeClass" ), SAL_NO_ACQUIRE ); + Any enumValue = PyEnum2Enum( pyTC.get() ); + + OUString name( OUString::createFromAscii( PyUnicode_AsUTF8( pyName.get() ) ) ); + TypeDescription desc( name ); + if( ! desc.is() ) + { + throw RuntimeException( "type " + name + " is unknown" ); + } + css::uno::TypeClass tc = *o3tl::doAccess<css::uno::TypeClass>(enumValue); + if( static_cast<css::uno::TypeClass>(desc.get()->eTypeClass) != tc ) + { + throw RuntimeException( "pyuno.checkType: " + name + " is a " + + OUString::createFromAscii( typeClassToString( static_cast<TypeClass>(desc.get()->eTypeClass)) ) + + ", but type got construct with typeclass " + + OUString::createFromAscii( typeClassToString( tc ) ) ); + } + return desc.get()->pWeakRef; +} + +static PyObject* callCtor( const Runtime &r , const char * clazz, const PyRef & args ) +{ + PyRef code( PyDict_GetItemString( r.getImpl()->cargo->getUnoModule().get(), clazz ) ); + if( ! code.is() ) + { + OString buf = OStringLiteral("couldn't access uno.") + clazz; + PyErr_SetString( PyExc_RuntimeError, buf.getStr() ); + return nullptr; + } + PyRef instance( PyObject_CallObject( code.get(), args.get() ), SAL_NO_ACQUIRE); + Py_XINCREF( instance.get() ); + return instance.get(); + +} + + +PyObject *PyUNO_Enum_new( const char *enumBase, const char *enumValue, const Runtime &r ) +{ + PyRef args( PyTuple_New( 2 ), SAL_NO_ACQUIRE, NOT_NULL ); + PyTuple_SetItem( args.get() , 0 , PyUnicode_FromString( enumBase ) ); + PyTuple_SetItem( args.get() , 1 , PyUnicode_FromString( enumValue ) ); + + return callCtor( r, "Enum" , args ); +} + + +PyObject* PyUNO_Type_new (const char *typeName , TypeClass t , const Runtime &r ) +{ + // retrieve type object + PyRef args(PyTuple_New( 2 ), SAL_NO_ACQUIRE, NOT_NULL); + + PyTuple_SetItem( args.get() , 0 , PyUnicode_FromString( typeName ) ); + PyObject *typeClass = PyUNO_Enum_new( "com.sun.star.uno.TypeClass" , typeClassToString(t), r ); + if( ! typeClass ) + return nullptr; + PyTuple_SetItem( args.get() , 1 , typeClass); + + return callCtor( r, "Type" , args ); +} + +PyObject* PyUNO_char_new ( sal_Unicode val , const Runtime &r ) +{ + // retrieve type object + PyRef args( PyTuple_New( 1 ), SAL_NO_ACQUIRE, NOT_NULL ); + + Py_UNICODE u[2]; + u[0] = val; + u[1] = 0; + PyTuple_SetItem( args.get() , 0 , PyUnicode_FromUnicode( u ,1) ); + + return callCtor( r, "Char" , args ); +} + +PyObject *PyUNO_ByteSequence_new( + const css::uno::Sequence< sal_Int8 > &byteSequence, const Runtime &r ) +{ + PyRef str( + PyBytes_FromStringAndSize( reinterpret_cast<char const *>(byteSequence.getConstArray()), byteSequence.getLength()), + SAL_NO_ACQUIRE ); + PyRef args( PyTuple_New( 1 ), SAL_NO_ACQUIRE, NOT_NULL ); + PyTuple_SetItem( args.get() , 0 , str.getAcquired() ); + return callCtor( r, "ByteSequence" , args ); + +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/pyuno_util.cxx b/pyuno/source/module/pyuno_util.cxx new file mode 100644 index 000000000..77006c33a --- /dev/null +++ b/pyuno/source/module/pyuno_util.cxx @@ -0,0 +1,213 @@ +/* -*- 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 "pyuno_impl.hxx" + +#include <osl/thread.h> +#include <osl/thread.hxx> + +#include <rtl/ustrbuf.hxx> +#include <osl/time.h> + +using com::sun::star::uno::Sequence; +using com::sun::star::uno::Any; +using com::sun::star::uno::RuntimeException; + +namespace pyuno +{ +PyRef ustring2PyUnicode( const OUString & str ) +{ + PyRef ret; +#if Py_UNICODE_SIZE == 2 +#ifdef MACOSX + ret = PyRef( PyUnicode_FromUnicode( reinterpret_cast<const unsigned short *>(str.getStr()), str.getLength() ), SAL_NO_ACQUIRE ); +#else + static_assert(sizeof (wchar_t) == Py_UNICODE_SIZE, "bad assumption"); + ret = PyRef( PyUnicode_FromUnicode( reinterpret_cast<wchar_t const *>(str.getStr()), str.getLength() ), SAL_NO_ACQUIRE ); +#endif +#else + OString sUtf8(OUStringToOString(str, RTL_TEXTENCODING_UTF8)); + ret = PyRef( PyUnicode_DecodeUTF8( sUtf8.getStr(), sUtf8.getLength(), nullptr) , SAL_NO_ACQUIRE ); +#endif + return ret; +} + +PyRef ustring2PyString( const OUString &str ) +{ + OString o = OUStringToOString( str, osl_getThreadTextEncoding() ); + return PyRef( PyUnicode_FromString( o.getStr() ), SAL_NO_ACQUIRE ); +} + +OUString pyString2ustring( PyObject *pystr ) +{ + OUString ret; + if( PyUnicode_Check( pystr ) ) + { +#if Py_UNICODE_SIZE == 2 + ret = OUString( + reinterpret_cast<sal_Unicode const *>(PyUnicode_AS_UNICODE( pystr )) ); +#else + Py_ssize_t size(0); + char const *pUtf8(PyUnicode_AsUTF8AndSize(pystr, &size)); + ret = OUString(pUtf8, size, RTL_TEXTENCODING_UTF8); +#endif + } + else + { + char *name = PyBytes_AsString(pystr); // hmmm... is this a good idea? + ret = OUString( name, strlen(name), osl_getThreadTextEncoding() ); + } + return ret; +} + +PyRef getObjectFromUnoModule( const Runtime &runtime, const char * func ) +{ + PyRef object(PyDict_GetItemString( runtime.getImpl()->cargo->getUnoModule().get(), func ) ); + if( !object.is() ) + { + throw RuntimeException("couldn't find core function " + OUString::createFromAscii(func)); + } + return object; +} + + +// Logging + + +bool isLog( RuntimeCargo const * cargo, sal_Int32 loglevel ) +{ + return cargo && cargo->logFile && loglevel <= cargo->logLevel; +} + +void log( RuntimeCargo * cargo, sal_Int32 level, const OUString &logString ) +{ + log( cargo, level, OUStringToOString( logString, osl_getThreadTextEncoding() ).getStr() ); +} + +void log( RuntimeCargo * cargo, sal_Int32 level, const char *str ) +{ + if( !isLog( cargo, level ) ) + return; + + static const char *strLevel[] = { "NONE", "CALL", "ARGS" }; + + TimeValue systemTime; + TimeValue localTime; + oslDateTime localDateTime; + + osl_getSystemTime( &systemTime ); + osl_getLocalTimeFromSystemTime( &systemTime, &localTime ); + osl_getDateTimeFromTimeValue( &localTime, &localDateTime ); + + fprintf( cargo->logFile, + "%4i-%02i-%02i %02i:%02i:%02i,%03lu [%s,tid %ld]: %s\n", + localDateTime.Year, + localDateTime.Month, + localDateTime.Day, + localDateTime.Hours, + localDateTime.Minutes, + localDateTime.Seconds, + sal::static_int_cast< unsigned long >( + localDateTime.NanoSeconds/1000000), + strLevel[level], + sal::static_int_cast< long >( + static_cast<sal_Int32>(osl::Thread::getCurrentIdentifier())), + str ); +} + +namespace { + +void appendPointer(OUStringBuffer & buffer, void * pointer) { + buffer.append( + sal::static_int_cast< sal_Int64 >( + reinterpret_cast< sal_IntPtr >(pointer)), + 16); +} + +} + +void logException( RuntimeCargo *cargo, const char *intro, + void * ptr, const OUString &aFunctionName, + const void * data, const css::uno::Type & type ) +{ + if( isLog( cargo, LogLevel::CALL ) ) + { + OUStringBuffer buf( 128 ); + buf.appendAscii( intro ); + appendPointer(buf, ptr); + buf.append( "]." + aFunctionName + " = " ); + buf.append( + val2str( data, type.getTypeLibType(), VAL2STR_MODE_SHALLOW ) ); + log( cargo,LogLevel::CALL, buf.makeStringAndClear() ); + } + +} + +void logReply( + RuntimeCargo *cargo, + const char *intro, + void * ptr, + const OUString & aFunctionName, + const Any &returnValue, + const Sequence< Any > & aParams ) +{ + OUStringBuffer buf( 128 ); + buf.appendAscii( intro ); + appendPointer(buf, ptr); + buf.append( "]." + aFunctionName + "()=" ); + if( isLog( cargo, LogLevel::ARGS ) ) + { + buf.append( + val2str( returnValue.getValue(), returnValue.getValueTypeRef(), VAL2STR_MODE_SHALLOW) ); + for( const auto & p : aParams ) + { + buf.append( ", " ); + buf.append( val2str( p.getValue(), p.getValueTypeRef(), VAL2STR_MODE_SHALLOW) ); + } + } + log( cargo,LogLevel::CALL, buf.makeStringAndClear() ); + +} + +void logCall( RuntimeCargo *cargo, const char *intro, + void * ptr, const OUString & aFunctionName, + const Sequence< Any > & aParams ) +{ + OUStringBuffer buf( 128 ); + buf.appendAscii( intro ); + appendPointer(buf, ptr); + buf.append( "]." + aFunctionName + "(" ); + if( isLog( cargo, LogLevel::ARGS ) ) + { + for( int i = 0; i < aParams.getLength() ; i ++ ) + { + if( i > 0 ) + buf.append( ", " ); + buf.append( + val2str( aParams[i].getValue(), aParams[i].getValueTypeRef(), VAL2STR_MODE_SHALLOW) ); + } + } + buf.append( ")" ); + log( cargo,LogLevel::CALL, buf.makeStringAndClear() ); +} + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/source/module/uno.py b/pyuno/source/module/uno.py new file mode 100644 index 000000000..c4ca808fe --- /dev/null +++ b/pyuno/source/module/uno.py @@ -0,0 +1,550 @@ +# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-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 . +# +import pyuno +import sys +import traceback +import warnings + +# since on Windows sal3.dll no longer calls WSAStartup +import socket + +# All functions and variables starting with a underscore (_) must be +# considered private and can be changed at any time. Don't use them. +_component_context = pyuno.getComponentContext() + + +def getComponentContext(): + """Returns the UNO component context used to initialize the Python runtime.""" + + return _component_context + + +def getCurrentContext(): + """Returns the current context. + + See http://udk.openoffice.org/common/man/concept/uno_contexts.html#current_context + for an explanation on the current context concept. + """ + + return pyuno.getCurrentContext() + + +def setCurrentContext(newContext): + """Sets newContext as new UNO context. + + The newContext must implement the XCurrentContext interface. The + implementation should handle the desired properties and delegate + unknown properties to the old context. Ensure that the old one + is reset when you leave your stack, see + http://udk.openoffice.org/common/man/concept/uno_contexts.html#current_context + """ + + return pyuno.setCurrentContext(newContext) + + +def getConstantByName(constant): + """Looks up the value of an IDL constant by giving its explicit name.""" + + return pyuno.getConstantByName(constant) + + +def getTypeByName(typeName): + """Returns a `uno.Type` instance of the type given by typeName. + + If the type does not exist, a `com.sun.star.uno.RuntimeException` is raised. + """ + + return pyuno.getTypeByName(typeName) + + +def createUnoStruct(typeName, *args, **kwargs): + """Creates a UNO struct or exception given by typeName. + + Can be called with: + + 1) No additional argument. + In this case, you get a default constructed UNO structure. + (e.g. `createUnoStruct("com.sun.star.uno.Exception")`) + 2) Exactly one additional argument that is an instance of typeName. + In this case, a copy constructed instance of typeName is returned + (e.g. `createUnoStruct("com.sun.star.uno.Exception" , e)`) + 3) As many additional arguments as the number of elements within typeName + (e.g. `createUnoStruct("com.sun.star.uno.Exception", "foo error" , self)`). + 4) Keyword arguments to give values for each element of the struct by name. + 5) A mix of 3) and 4), such that each struct element is given a value exactly once, + either by a positional argument or by a keyword argument. + + The additional and/or keyword arguments must match the type of each struct element, + otherwise an exception is thrown. + """ + + return getClass(typeName)(*args, **kwargs) + + +def getClass(typeName): + """Returns the class of a concrete UNO exception, struct, or interface.""" + + return pyuno.getClass(typeName) + + +def isInterface(obj): + """Returns True, when obj is a class of a UNO interface.""" + + return pyuno.isInterface(obj) + + +def generateUuid(): + """Returns a 16 byte sequence containing a newly generated uuid or guid. + + For more information, see rtl/uuid.h. + """ + + return pyuno.generateUuid() + + +def systemPathToFileUrl(systemPath): + """Returns a file URL for the given system path.""" + + return pyuno.systemPathToFileUrl(systemPath) + + +def fileUrlToSystemPath(url): + """Returns a system path. + + This path is determined by the system that the Python interpreter is running on. + """ + + return pyuno.fileUrlToSystemPath(url) + + +def absolutize(path, relativeUrl): + """Returns an absolute file url from the given urls.""" + + return pyuno.absolutize(path, relativeUrl) + + +class Enum: + """Represents a UNO enum. + + Use an instance of this class to explicitly pass an enum to UNO. + + :param typeName: The name of the enum as a string. + :param value: The actual value of this enum as a string. + """ + + def __init__(self, typeName, value): + self.typeName = typeName + self.value = value + pyuno.checkEnum(self) + + def __repr__(self): + return "<Enum instance %s (%r)>" % (self.typeName, self.value) + + def __eq__(self, that): + if not isinstance(that, Enum): + return False + + return (self.typeName == that.typeName) and (self.value == that.value) + + def __ne__(self,other): + return not self.__eq__(other) + + +class Type: + """Represents a UNO type. + + Use an instance of this class to explicitly pass a type to UNO. + + :param typeName: Name of the UNO type + :param typeClass: Python Enum of TypeClass, see com/sun/star/uno/TypeClass.idl + """ + + def __init__(self, typeName, typeClass): + self.typeName = typeName + self.typeClass = typeClass + pyuno.checkType(self) + + def __repr__(self): + return "<Type instance %s (%r)>" % (self.typeName, self.typeClass) + + def __eq__(self, that): + if not isinstance(that, Type): + return False + + return self.typeClass == that.typeClass and self.typeName == that.typeName + + def __ne__(self,other): + return not self.__eq__(other) + + def __hash__(self): + return self.typeName.__hash__() + + +class Bool(object): + """Represents a UNO boolean. + + Use an instance of this class to explicitly pass a boolean to UNO. + + Note: This class is deprecated. Use Python's True and False directly instead. + """ + + def __new__(cls, value): + message = "The Bool class is deprecated. Use Python's True and False directly instead." + warnings.warn(message, DeprecationWarning) + + if isinstance(value, str) and value == "true": + return True + + if isinstance(value, str) and value == "false": + return False + + if value: + return True + + return False + + +class Char: + """Represents a UNO char. + + Use an instance of this class to explicitly pass a char to UNO. + + For Python 2, this class only works with unicode objects. Creating + a Char instance with a normal str object or comparing a Char instance + to a normal str object will raise an AssertionError. + + :param value: A Unicode string with length 1 + """ + + def __init__(self, value): + assert isinstance(value, str), "Expected str object, got %s instead." % type(value) + + assert len(value) == 1, "Char value must have length of 1." + + self.value = value + + def __repr__(self): + return "<Char instance %s>" % (self.value,) + + def __eq__(self, that): + if isinstance(that, str): + if len(that) > 1: + return False + + return self.value == that[0] + + if isinstance(that, Char): + return self.value == that.value + + return False + + def __ne__(self,other): + return not self.__eq__(other) + + +class ByteSequence: + """Represents a UNO ByteSequence value. + + Use an instance of this class to explicitly pass a byte sequence to UNO. + + :param value: A string or bytesequence + """ + + def __init__(self, value): + if isinstance(value, bytes): + self.value = value + + elif isinstance(value, ByteSequence): + self.value = value.value + + else: + raise TypeError("Expected bytes object or ByteSequence, got %s instead." % type(value)) + + def __repr__(self): + return "<ByteSequence instance '%s'>" % (self.value,) + + def __eq__(self, that): + if isinstance(that, bytes): + return self.value == that + + if isinstance(that, ByteSequence): + return self.value == that.value + + return False + + def __len__(self): + return len(self.value) + + def __getitem__(self, index): + return self.value[index] + + def __iter__(self): + return self.value.__iter__() + + def __add__(self, b): + if isinstance(b, bytes): + return ByteSequence(self.value + b) + + elif isinstance(b, ByteSequence): + return ByteSequence(self.value + b.value) + + else: + raise TypeError("Can't add ByteString and %s." % type(b)) + + def __hash__(self): + return self.value.hash() + + +class Any: + """Represents a UNO Any value. + + Use only in connection with uno.invoke() to pass an explicit typed Any. + """ + + def __init__(self, type, value): + if isinstance(type, Type): + self.type = type + else: + self.type = getTypeByName(type) + + self.value = value + + +def invoke(object, methodname, argTuple): + """Use this function to pass exactly typed Anys to the callee (using uno.Any).""" + + return pyuno.invoke(object, methodname, argTuple) + + +# ----------------------------------------------------------------------------- +# Don't use any functions beyond this point; private section, likely to change. +# ----------------------------------------------------------------------------- +_builtin_import = __import__ + + +def _uno_import(name, *optargs, **kwargs): + """Overrides built-in import to allow directly importing LibreOffice classes.""" + + try: + return _builtin_import(name, *optargs, **kwargs) + except ImportError as e: + # process optargs + globals, locals, fromlist = list(optargs)[:3] + [kwargs.get('globals', {}), kwargs.get('locals', {}), + kwargs.get('fromlist', [])][len(optargs):] + + # from import form only, but skip if a uno lookup has already failed + if not fromlist or hasattr(e, '_uno_import_failed'): + raise + + # hang onto exception for possible use on subsequent uno lookup failure + py_import_exc = e + + mod = None + d = sys.modules + + for module in name.split("."): + if module in d: + mod = d[module] + else: + # How to create a module ?? + mod = pyuno.__class__(module) + + d = mod.__dict__ + + RuntimeException = pyuno.getClass("com.sun.star.uno.RuntimeException") + + for class_name in fromlist: + if class_name not in d: + failed = False + + try: + # check for structs, exceptions or interfaces + d[class_name] = pyuno.getClass(name + "." + class_name) + except RuntimeException: + # check for enums + try: + d[class_name] = Enum(name, class_name) + except RuntimeException: + # check for constants + try: + d[class_name] = getConstantByName(name + "." + class_name) + except RuntimeException: + # check for constant group + try: + d[class_name] = _impl_getConstantGroupByName(name, class_name) + except ValueError: + failed = True + + if failed: + # We have an import failure, but cannot distinguish between + # uno and non-uno errors as uno lookups are attempted for all + # "from xxx import yyy" imports following a python failure. + # + # In Python 3, the original python exception traceback is reused + # to help pinpoint the actual failing location. Its original + # message, unlike Python 2, is unlikely to be helpful for uno + # failures, as it most commonly is just a top level module like + # 'com'. So our exception appends the uno lookup failure. + # This is more ambiguous, but it plus the traceback should be + # sufficient to identify a root cause for python or uno issues. + # + # Our exception is raised outside of the nested exception + # handlers above, to avoid Python 3 nested exception + # information for the RuntimeExceptions during lookups. + # + # Finally, a private attribute is used to prevent further + # processing if this failure was in a nested import. That + # keeps the exception relevant to the primary failure point, + # preventing us from re-processing our own import errors. + + uno_import_exc = ImportError("%s (or '%s.%s' is unknown)" % + (py_import_exc, name, class_name)) + + uno_import_exc = uno_import_exc.with_traceback(py_import_exc.__traceback__) + + uno_import_exc._uno_import_failed = True + raise uno_import_exc + + return mod + + +try: + import __builtin__ +except ImportError: + import builtins as __builtin__ + +# hook into the __import__ chain +__builtin__.__dict__['__import__'] = _uno_import + + +class _ConstantGroup(object): + """Represents a group of UNOIDL constants.""" + + __slots__ = ['_constants'] + + def __init__(self, constants): + self._constants = constants + + def __dir__(self): + return self._constants.keys() + + def __getattr__(self, name): + if name in self._constants: + return self._constants[name] + + raise AttributeError("The constant '%s' could not be found." % name) + + +def _impl_getConstantGroupByName(module, group): + """Gets UNOIDL constant group by name.""" + + constants = Enum('com.sun.star.uno.TypeClass', 'CONSTANTS') + one = Enum('com.sun.star.reflection.TypeDescriptionSearchDepth', 'ONE') + type_desc_mgr = _component_context.getValueByName('/singletons/com.sun.star.reflection.theTypeDescriptionManager') + type_descs = type_desc_mgr.createTypeDescriptionEnumeration(module, (constants,), one) + qualified_name = module + '.' + group + + for type_desc in type_descs: + if type_desc.Name == qualified_name: + return _ConstantGroup(dict( + (c.Name.split('.')[-1], c.ConstantValue) + for c in type_desc.Constants)) + + raise ValueError("The constant group '%s' could not be found." % qualified_name) + + +def _uno_struct__init__(self, *args, **kwargs): + """Initializes a UNO struct. + + Referenced from the pyuno shared library. + + This function can be called with either an already constructed UNO struct, which it + will then just reference without copying, or with arguments to create a new UNO struct. + """ + + # Check to see if this function was passed an existing UNO struct + if len(kwargs) == 0 and len(args) == 1 and getattr(args[0], "__class__", None) == self.__class__: + self.__dict__['value'] = args[0] + else: + struct, used = pyuno._createUnoStructHelper(self.__class__.__pyunostruct__, args, **kwargs) + + for kwarg in kwargs.keys(): + if not used.get(kwarg): + RuntimeException = pyuno.getClass("com.sun.star.uno.RuntimeException") + raise RuntimeException("_uno_struct__init__: unused keyword argument '%s'." % kwarg, None) + + self.__dict__["value"] = struct + + +def _uno_struct__getattr__(self, name): + """Gets attribute from UNO struct. + + Referenced from the pyuno shared library. + """ + + return getattr(self.__dict__["value"], name) + + +def _uno_struct__setattr__(self, name, value): + """Sets attribute on UNO struct. + + Referenced from the pyuno shared library. + """ + + return setattr(self.__dict__["value"], name, value) + + +def _uno_struct__repr__(self): + """Converts a UNO struct to a printable string. + + Referenced from the pyuno shared library. + """ + + return repr(self.__dict__["value"]) + + +def _uno_struct__str__(self): + """Converts a UNO struct to a string.""" + + return str(self.__dict__["value"]) + +def _uno_struct__ne__(self, other): + return not self.__eq__(other) + +def _uno_struct__eq__(self, that): + """Compares two UNO structs. + + Referenced from the pyuno shared library. + """ + + if hasattr(that, "value"): + return self.__dict__["value"] == that.__dict__["value"] + + return False + + +def _uno_extract_printable_stacktrace(trace): + """Extracts a printable stacktrace. + + Referenced from pyuno shared lib and pythonscript.py. + """ + + return ''.join(traceback.format_tb(trace)) + +# vim: set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/source/module/unohelper.py b/pyuno/source/module/unohelper.py new file mode 100644 index 000000000..cf6f78d63 --- /dev/null +++ b/pyuno/source/module/unohelper.py @@ -0,0 +1,297 @@ +# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-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 . +# +import uno +import pyuno +import os +import sys + +from com.sun.star.lang import XTypeProvider, XSingleComponentFactory, XServiceInfo +from com.sun.star.uno import RuntimeException, XCurrentContext +from com.sun.star.beans.MethodConcept import ALL as METHOD_CONCEPT_ALL +from com.sun.star.beans.PropertyConcept import ALL as PROPERTY_CONCEPT_ALL + +from com.sun.star.reflection.ParamMode import \ + IN as PARAM_MODE_IN, \ + OUT as PARAM_MODE_OUT, \ + INOUT as PARAM_MODE_INOUT + +from com.sun.star.beans.PropertyAttribute import \ + MAYBEVOID as PROP_ATTR_MAYBEVOID, \ + BOUND as PROP_ATTR_BOUND, \ + CONSTRAINED as PROP_ATTR_CONSTRAINED, \ + TRANSIENT as PROP_ATTR_TRANSIENT, \ + READONLY as PROP_ATTR_READONLY, \ + MAYBEAMBIGUOUS as PROP_ATTR_MAYBEAMBIGUOUS, \ + MAYBEDEFAULT as PROP_ATTR_MAYBEDEFAULT, \ + REMOVABLE as PROP_ATTR_REMOVABLE + +def _mode_to_str( mode ): + ret = "[]" + if mode == PARAM_MODE_INOUT: + ret = "[inout]" + elif mode == PARAM_MODE_OUT: + ret = "[out]" + elif mode == PARAM_MODE_IN: + ret = "[in]" + return ret + +def _propertymode_to_str( mode ): + ret = "" + if PROP_ATTR_REMOVABLE & mode: + ret = ret + "removable " + if PROP_ATTR_MAYBEDEFAULT & mode: + ret = ret + "maybedefault " + if PROP_ATTR_MAYBEAMBIGUOUS & mode: + ret = ret + "maybeambiguous " + if PROP_ATTR_READONLY & mode: + ret = ret + "readonly " + if PROP_ATTR_TRANSIENT & mode: + ret = ret + "transient " + if PROP_ATTR_CONSTRAINED & mode: + ret = ret + "constrained " + if PROP_ATTR_BOUND & mode: + ret = ret + "bound " + if PROP_ATTR_MAYBEVOID & mode: + ret = ret + "maybevoid " + return ret.rstrip() + +def inspect( obj , out ): + if isinstance( obj, uno.Type ) or \ + isinstance( obj, uno.Char ) or \ + isinstance( obj, uno.Bool ) or \ + isinstance( obj, uno.ByteSequence ) or \ + isinstance( obj, uno.Enum ) or \ + isinstance( obj, uno.Any ): + out.write( str(obj) + "\n") + return + + ctx = uno.getComponentContext() + introspection = \ + ctx.ServiceManager.createInstanceWithContext( "com.sun.star.beans.Introspection", ctx ) + + out.write( "Supported services:\n" ) + if hasattr( obj, "getSupportedServiceNames" ): + names = obj.getSupportedServiceNames() + for ii in names: + out.write( " " + ii + "\n" ) + else: + out.write( " unknown\n" ) + + out.write( "Interfaces:\n" ) + if hasattr( obj, "getTypes" ): + interfaces = obj.getTypes() + for ii in interfaces: + out.write( " " + ii.typeName + "\n" ) + else: + out.write( " unknown\n" ) + + access = introspection.inspect( obj ) + methods = access.getMethods( METHOD_CONCEPT_ALL ) + out.write( "Methods:\n" ) + for ii in methods: + out.write( " " + ii.ReturnType.Name + " " + ii.Name ) + args = ii.ParameterTypes + infos = ii.ParameterInfos + out.write( "( " ) + for i in range( 0, len( args ) ): + if i > 0: + out.write( ", " ) + out.write( _mode_to_str( infos[i].aMode ) + " " + args[i].Name + " " + infos[i].aName ) + out.write( " )\n" ) + + props = access.getProperties( PROPERTY_CONCEPT_ALL ) + out.write ("Properties:\n" ) + for ii in props: + out.write( " ("+_propertymode_to_str( ii.Attributes ) + ") "+ii.Type.typeName+" "+ii.Name+ "\n" ) + +def createSingleServiceFactory( clazz, implementationName, serviceNames ): + return _FactoryHelper_( clazz, implementationName, serviceNames ) + +class _ImplementationHelperEntry: + def __init__(self, ctor,serviceNames): + self.ctor = ctor + self.serviceNames = serviceNames + +class ImplementationHelper: + def __init__(self): + self.impls = {} + + def addImplementation( self, ctor, implementationName, serviceNames ): + self.impls[implementationName] = _ImplementationHelperEntry(ctor,serviceNames) + + def writeRegistryInfo( self, regKey, smgr ): + for i in list(self.impls.items()): + keyName = "/"+ i[0] + "/UNO/SERVICES" + key = regKey.createKey( keyName ) + for serviceName in i[1].serviceNames: + key.createKey( serviceName ) + return 1 + + def getComponentFactory( self, implementationName , regKey, smgr ): + entry = self.impls.get( implementationName, None ) + if entry is None: + raise RuntimeException( implementationName + " is unknown" , None ) + return createSingleServiceFactory( entry.ctor, implementationName, entry.serviceNames ) + + def getSupportedServiceNames( self, implementationName ): + entry = self.impls.get( implementationName, None ) + if entry is None: + raise RuntimeException( implementationName + " is unknown" , None ) + return entry.serviceNames + + def supportsService( self, implementationName, serviceName ): + entry = self.impls.get( implementationName,None ) + if entry is None: + raise RuntimeException( implementationName + " is unknown", None ) + return serviceName in entry.serviceNames + + +class ImplementationEntry: + def __init__(self, implName, supportedServices, clazz ): + self.implName = implName + self.supportedServices = supportedServices + self.clazz = clazz + +def writeRegistryInfoHelper( smgr, regKey, seqEntries ): + for entry in seqEntries: + keyName = "/"+ entry.implName + "/UNO/SERVICES" + key = regKey.createKey( keyName ) + for serviceName in entry.supportedServices: + key.createKey( serviceName ) + +def systemPathToFileUrl( systemPath ): + "returns a file-url for the given system path" + return pyuno.systemPathToFileUrl( systemPath ) + +def fileUrlToSystemPath( url ): + "returns a system path (determined by the system, the python interpreter is running on)" + return pyuno.fileUrlToSystemPath( url ) + +def absolutize( path, relativeUrl ): + "returns an absolute file url from the given urls" + return pyuno.absolutize( path, relativeUrl ) + +def getComponentFactoryHelper( implementationName, smgr, regKey, seqEntries ): + for x in seqEntries: + if x.implName == implementationName: + return createSingleServiceFactory( x.clazz, implementationName, x.supportedServices ) + +def addComponentsToContext( toBeExtendedContext, contextRuntime, componentUrls, loaderName ): + smgr = contextRuntime.ServiceManager + loader = smgr.createInstanceWithContext( loaderName, contextRuntime ) + implReg = smgr.createInstanceWithContext( "com.sun.star.registry.ImplementationRegistration",contextRuntime) + + isWin = os.name == 'nt' or os.name == 'dos' + isMac = sys.platform == 'darwin' + # create a temporary registry + for componentUrl in componentUrls: + reg = smgr.createInstanceWithContext( "com.sun.star.registry.SimpleRegistry", contextRuntime ) + reg.open( "", 0, 1 ) + if not isWin and componentUrl.endswith( ".uno" ): # still allow platform independent naming + if isMac: + componentUrl = componentUrl + ".dylib" + else: + componentUrl = componentUrl + ".so" + + implReg.registerImplementation( loaderName,componentUrl, reg ) + rootKey = reg.getRootKey() + implementationKey = rootKey.openKey( "IMPLEMENTATIONS" ) + implNames = implementationKey.getKeyNames() + extSMGR = toBeExtendedContext.ServiceManager + for x in implNames: + fac = loader.activate( max(x.split("/")),"",componentUrl,rootKey) + extSMGR.insert( fac ) + reg.close() + +# never shrinks ! +_g_typeTable = {} +def _unohelper_getHandle( self): + ret = None + if self.__class__ in _g_typeTable: + ret = _g_typeTable[self.__class__] + else: + names = {} + traverse = list(self.__class__.__bases__) + while len( traverse ) > 0: + item = traverse.pop() + bases = item.__bases__ + if uno.isInterface( item ): + names[item.__pyunointerface__] = None + elif len(bases) > 0: + # the "else if", because we only need the most derived interface + traverse = traverse + list(bases)# + + lst = list(names.keys()) + types = [] + for x in lst: + t = uno.getTypeByName( x ) + types.append( t ) + + ret = tuple(types) + _g_typeTable[self.__class__] = ret + return ret + +class Base(XTypeProvider): + def getTypes( self ): + return _unohelper_getHandle( self ) + def getImplementationId(self): + return () + +class CurrentContext(XCurrentContext, Base ): + """a current context implementation, which first does a lookup in the given + hashmap and if the key cannot be found, it delegates to the predecessor + if available + """ + def __init__( self, oldContext, hashMap ): + self.hashMap = hashMap + self.oldContext = oldContext + + def getValueByName( self, name ): + if name in self.hashMap: + return self.hashMap[name] + elif self.oldContext is not None: + return self.oldContext.getValueByName( name ) + else: + return None + +# ------------------------------------------------- +# implementation details +# ------------------------------------------------- +class _FactoryHelper_( XSingleComponentFactory, XServiceInfo, Base ): + def __init__( self, clazz, implementationName, serviceNames ): + self.clazz = clazz + self.implementationName = implementationName + self.serviceNames = serviceNames + + def getImplementationName( self ): + return self.implementationName + + def supportsService( self, ServiceName ): + return ServiceName in self.serviceNames + + def getSupportedServiceNames( self ): + return self.serviceNames + + def createInstanceWithContext( self, context ): + return self.clazz( context ) + + def createInstanceWithArgumentsAndContext( self, args, context ): + return self.clazz( context, *args ) + +# vim: set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/source/officehelper.py b/pyuno/source/officehelper.py new file mode 100644 index 000000000..53bd5943e --- /dev/null +++ b/pyuno/source/officehelper.py @@ -0,0 +1,87 @@ +# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-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 . +# + +# +# Translated to python from "Bootstrap.java" by Kim Kulak +# + +import os +import random +from sys import platform +from time import sleep + +import uno +from com.sun.star.connection import NoConnectException +from com.sun.star.uno import Exception as UnoException + + +class BootstrapException(UnoException): + pass + +def bootstrap(): + """Bootstrap OOo and PyUNO Runtime. + The soffice process is started opening a named pipe of random name, then the local context is used + to access the pipe. This function directly returns the remote component context, from whereon you can + get the ServiceManager by calling getServiceManager() on the returned object. + """ + try: + # soffice script used on *ix, Mac; soffice.exe used on Win + if "UNO_PATH" in os.environ: + sOffice = os.environ["UNO_PATH"] + else: + sOffice = "" # lets hope for the best + sOffice = os.path.join(sOffice, "soffice") + if platform.startswith("win"): + sOffice += ".exe" + + # Generate a random pipe name. + random.seed() + sPipeName = "uno" + str(random.random())[2:] + + # Start the office process, don't check for exit status since an exception is caught anyway if the office terminates unexpectedly. + cmdArray = (sOffice, "--nologo", "--nodefault", "".join(["--accept=pipe,name=", sPipeName, ";urp;"])) + os.spawnv(os.P_NOWAIT, sOffice, cmdArray) + + # --------- + + xLocalContext = uno.getComponentContext() + resolver = xLocalContext.ServiceManager.createInstanceWithContext( + "com.sun.star.bridge.UnoUrlResolver", xLocalContext) + sConnect = "".join(["uno:pipe,name=", sPipeName, ";urp;StarOffice.ComponentContext"]) + + # Wait until an office is started, but loop only nLoop times (can we do this better???) + nLoop = 20 + while True: + try: + xContext = resolver.resolve(sConnect) + break + except NoConnectException: + nLoop -= 1 + if nLoop <= 0: + raise BootstrapException("Cannot connect to soffice server.", None) + sleep(0.5) # Sleep 1/2 second. + + except BootstrapException: + raise + except Exception as e: # Any other exception + raise BootstrapException("Caught exception " + str(e), None) + + return xContext + +# vim: set shiftwidth=4 softtabstop=4 expandtab: diff --git a/pyuno/zipcore/mac.sh b/pyuno/zipcore/mac.sh new file mode 100644 index 000000000..830bcdaa1 --- /dev/null +++ b/pyuno/zipcore/mac.sh @@ -0,0 +1,14 @@ +# Set URE_BOOTSTRAP so that "uno.getComponentContext()" bootstraps a complete +# OOo UNO environment: +: ${URE_BOOTSTRAP=vnd.sun.star.pathname:$sd_prog/../Resources/fundamentalrc} +export URE_BOOTSTRAP + +PYTHONHOME=$sd_prog/../Frameworks/LibreOfficePython.framework +export PYTHONHOME + +pybasislibdir=$PYTHONHOME/Versions/%%PYVERSION%%/lib/python%%PYVERSION%% +PYTHONPATH=$sd_prog/../Resources:$sd_prog/../Frameworks:$pybasislibdir:$pybasislibdir/lib-dynload:$pybasislibdir/lib-tk:$pybasislibdir/site-packages${PYTHONPATH+:$PYTHONPATH} +export PYTHONPATH + +# execute binary +exec "$PYTHONHOME/Versions/%%PYVERSION%%/Resources/Python.app/Contents/MacOS/LibreOfficePython" "$@" diff --git a/pyuno/zipcore/nonmac.sh b/pyuno/zipcore/nonmac.sh new file mode 100644 index 000000000..5e7cca14d --- /dev/null +++ b/pyuno/zipcore/nonmac.sh @@ -0,0 +1,12 @@ +# Set URE_BOOTSTRAP so that "uno.getComponentContext()" bootstraps a complete +# OOo UNO environment: +: ${URE_BOOTSTRAP=vnd.sun.star.pathname:$sd_prog/fundamentalrc} +export URE_BOOTSTRAP + +PYTHONPATH=$sd_prog:$sd_prog/python-core-%%PYVERSION%%/lib:$sd_prog/python-core-%%PYVERSION%%/lib/lib-dynload:$sd_prog/python-core-%%PYVERSION%%/lib/lib-tk:$sd_prog/python-core-%%PYVERSION%%/lib/site-packages${PYTHONPATH+:$PYTHONPATH} +export PYTHONPATH +PYTHONHOME=$sd_prog/python-core-%%PYVERSION%% +export PYTHONHOME + +# execute binary +exec "$sd_prog/python.bin" "$@" diff --git a/pyuno/zipcore/python.cxx b/pyuno/zipcore/python.cxx new file mode 100644 index 000000000..7580e3278 --- /dev/null +++ b/pyuno/zipcore/python.cxx @@ -0,0 +1,212 @@ +/* -*- 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 <config_python.h> + +#include <cstddef> +#include <stdlib.h> +#include <wchar.h> + +#define WIN32_LEAN_AND_MEAN +#include <windows.h> + +#include <tools/pathutils.hxx> + +#define MY_LENGTH(s) (sizeof (s) / sizeof *(s) - 1) +#define MY_STRING(s) (s), MY_LENGTH(s) + +static wchar_t * encode(wchar_t * buffer, wchar_t const * text) { + *buffer++ = L'"'; + std::size_t n = 0; + for (;;) { + wchar_t c = *text++; + if (c == L'\0') { + break; + } else if (c == L'"') { + // Double any preceding backslashes as required by Windows: + for (std::size_t i = 0; i < n; ++i) { + *buffer++ = L'\\'; + } + *buffer++ = L'\\'; + *buffer++ = L'"'; + n = 0; + } else if (c == L'\\') { + *buffer++ = L'\\'; + ++n; + } else { + *buffer++ = c; + n = 0; + } + } + // The command line will continue with a double quote, so double any + // preceding backslashes as required by Windows: + for (std::size_t i = 0; i < n; ++i) { + *buffer++ = L'\\'; + } + *buffer++ = L'"'; + return buffer; +} + +int wmain(int argc, wchar_t ** argv, wchar_t **) { + wchar_t path[MAX_PATH]; + DWORD n = GetModuleFileNameW(nullptr, path, MAX_PATH); + if (n == 0 || n >= MAX_PATH) { + exit(EXIT_FAILURE); + } + wchar_t * pathEnd = tools::filename(path); + *pathEnd = L'\0'; + n = GetEnvironmentVariableW(L"UNO_PATH", nullptr, 0); + if (n == 0) { + if (GetLastError() != ERROR_ENVVAR_NOT_FOUND || + !SetEnvironmentVariableW(L"UNO_PATH", path)) + { + exit(EXIT_FAILURE); + } + } + wchar_t bootstrap[MY_LENGTH(L"vnd.sun.star.pathname:") + MAX_PATH] = + L"vnd.sun.star.pathname:"; //TODO: overflow + wchar_t * bootstrapEnd = tools::buildPath( + bootstrap + MY_LENGTH(L"vnd.sun.star.pathname:"), path, pathEnd, + MY_STRING(L"fundamental.ini")); + if (bootstrapEnd == nullptr) { + exit(EXIT_FAILURE); + } + wchar_t pythonpath2[MAX_PATH]; + wchar_t * pythonpath2End = tools::buildPath( + pythonpath2, path, pathEnd, + MY_STRING(L"\\python-core-" PYTHON_VERSION_STRING L"\\lib")); + if (pythonpath2End == nullptr) { + exit(EXIT_FAILURE); + } + wchar_t pythonpath3[MAX_PATH]; + wchar_t * pythonpath3End = tools::buildPath( + pythonpath3, path, pathEnd, + MY_STRING(L"\\python-core-" PYTHON_VERSION_STRING L"\\lib\\site-packages")); + if (pythonpath3End == nullptr) { + exit(EXIT_FAILURE); + } + wchar_t pythonhome[MAX_PATH]; + wchar_t * pythonhomeEnd = tools::buildPath( + pythonhome, path, pathEnd, MY_STRING(L"\\python-core-" PYTHON_VERSION_STRING)); + if (pythonhomeEnd == nullptr) { + exit(EXIT_FAILURE); + } + wchar_t pythonexe[MAX_PATH]; + wchar_t * pythonexeEnd = tools::buildPath( + pythonexe, path, pathEnd, + MY_STRING(L"\\python-core-" PYTHON_VERSION_STRING L"\\bin\\python.exe")); + if (pythonexeEnd == nullptr) { + exit(EXIT_FAILURE); + } + std::size_t clSize = MY_LENGTH(L"\"") + 4 * (pythonexeEnd - pythonexe) + + MY_LENGTH(L"\"\0"); //TODO: overflow + // 4 * len: each char preceded by backslash, each trailing backslash + // doubled + for (int i = 1; i < argc; ++i) { + clSize += MY_LENGTH(L" \"") + 4 * wcslen(argv[i]) + MY_LENGTH(L"\""); + //TODO: overflow + } + wchar_t * cl = new wchar_t[clSize]; + wchar_t * cp = encode(cl, pythonhome); + for (int i = 1; i < argc; ++i) { + *cp++ = L' '; + cp = encode(cp, argv[i]); + } + *cp = L'\0'; + n = GetEnvironmentVariableW(L"PATH", nullptr, 0); + wchar_t * orig; + if (n == 0) { + if (GetLastError() != ERROR_ENVVAR_NOT_FOUND) { + exit(EXIT_FAILURE); + } + orig = const_cast<wchar_t *>(L""); + } else { + orig = new wchar_t[n]; + if (GetEnvironmentVariableW(L"PATH", orig, n) != n - 1) + { + exit(EXIT_FAILURE); + } + } + std::size_t len = (pathEnd - path) + (n == 0 ? 0 : MY_LENGTH(L";") + + (n - 1)) + 1; + //TODO: overflow + wchar_t * value = new wchar_t[len]; + _snwprintf( + value, len, L"%s%s%s", path, n == 0 ? L"" : L";", orig); + if (!SetEnvironmentVariableW(L"PATH", value)) { + exit(EXIT_FAILURE); + } + if (n != 0) { + delete [] orig; + } + delete [] value; + n = GetEnvironmentVariableW(L"PYTHONPATH", nullptr, 0); + if (n == 0) { + if (GetLastError() != ERROR_ENVVAR_NOT_FOUND) { + exit(EXIT_FAILURE); + } + orig = const_cast<wchar_t *>(L""); + } else { + orig = new wchar_t[n]; + if (GetEnvironmentVariableW(L"PYTHONPATH", orig, n) != n - 1) + { + exit(EXIT_FAILURE); + } + } + len = (pathEnd - path) + MY_LENGTH(L";") + (pythonpath2End - pythonpath2) + + MY_LENGTH(L";") + (pythonpath3End - pythonpath3) + + (n == 0 ? 0 : MY_LENGTH(L";") + (n - 1)) + 1; //TODO: overflow + value = new wchar_t[len]; + _snwprintf( + value, len, L"%s;%s;%s%s%s", path, pythonpath2, pythonpath3, + n == 0 ? L"" : L";", orig); + if (!SetEnvironmentVariableW(L"PYTHONPATH", value)) { + exit(EXIT_FAILURE); + } + if (n != 0) { + delete [] orig; + } + delete [] value; + if (!SetEnvironmentVariableW(L"PYTHONHOME", pythonhome)) { + exit(EXIT_FAILURE); + } + n = GetEnvironmentVariableW(L"URE_BOOTSTRAP", nullptr, 0); + if (n == 0) { + if (GetLastError() != ERROR_ENVVAR_NOT_FOUND || + !SetEnvironmentVariableW(L"URE_BOOTSTRAP", bootstrap)) + { + exit(EXIT_FAILURE); + } + } + STARTUPINFOW startinfo; + ZeroMemory(&startinfo, sizeof (STARTUPINFOW)); + startinfo.cb = sizeof (STARTUPINFOW); + PROCESS_INFORMATION procinfo; + if (!CreateProcessW( + pythonexe, cl, nullptr, nullptr, FALSE, CREATE_UNICODE_ENVIRONMENT, nullptr, + nullptr, &startinfo, &procinfo)) { + exit(EXIT_FAILURE); + } + WaitForSingleObject(procinfo.hProcess,INFINITE); + DWORD exitStatus; + GetExitCodeProcess(procinfo.hProcess,&exitStatus); + exit(exitStatus); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/pyuno/zipcore/python.sh b/pyuno/zipcore/python.sh new file mode 100755 index 000000000..bfe6785bd --- /dev/null +++ b/pyuno/zipcore/python.sh @@ -0,0 +1,40 @@ +#!/bin/sh +# +# 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 . +# + +# resolve installation directory +sd_cwd="`pwd`" +if [ -h "$0" ] ; then + sd_basename=`basename "$0"` + sd_script=`ls -l "$0" | sed "s/.*${sd_basename} -> //g"` + cd "`dirname "$0"`" + cd "`dirname "$sd_script"`" +else + cd "`dirname "$0"`" +fi +sd_prog=`pwd` +cd "$sd_cwd" + +# Set PATH so that crash_report is found: +PATH=$sd_prog${PATH+:$PATH} +export PATH + +# Set UNO_PATH so that "officehelper.bootstrap()" can find soffice executable: +: ${UNO_PATH=$sd_prog} +export UNO_PATH + |