From: ishmal Date: Sat, 14 Apr 2007 15:52:31 +0000 (+0000) Subject: Change python binding mechanism X-Git-Url: https://git.tokkee.org/?a=commitdiff_plain;h=ecef952b5024bda4ead32073b37d02daaa0f38ec;p=inkscape.git Change python binding mechanism --- diff --git a/src/extension/script/InkscapeBinding.cpp b/src/extension/script/InkscapeBinding.cpp index e29fcecf4..4658f684b 100644 --- a/src/extension/script/InkscapeBinding.cpp +++ b/src/extension/script/InkscapeBinding.cpp @@ -1,3 +1,18 @@ +/** + * This file is an attempt to provide a hierarchical design + * to wrap Inkscape in an OO model. This file is parsed by Swig + * to produce scripting extension modules for such interpreters + * as Python or Perl + * + * Authors: + * Bob Jamison + * + * Copyright (C) 2004-2007 Authors + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + + #ifdef HAVE_CONFIG_H #include "config.h" #endif @@ -21,6 +36,7 @@ class DocumentImpl; class DocumentImpl : public Document { public: + DocumentImpl(); virtual ~DocumentImpl(); diff --git a/src/extension/script/InkscapeBinding.h b/src/extension/script/InkscapeBinding.h index 6bbd82fc6..18d33f8f3 100644 --- a/src/extension/script/InkscapeBinding.h +++ b/src/extension/script/InkscapeBinding.h @@ -7,9 +7,9 @@ * as Python or Perl * * Authors: - * Bob Jamison + * Bob Jamison * - * Copyright (C) 2004 Authors + * Copyright (C) 2004-2007 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ diff --git a/src/extension/script/InkscapePython.cpp b/src/extension/script/InkscapePython.cpp index 49e6a11a2..f7cfe81db 100644 --- a/src/extension/script/InkscapePython.cpp +++ b/src/extension/script/InkscapePython.cpp @@ -4,7 +4,7 @@ * Authors: * Bob Jamison * - * Copyright (C) 2004 Authors + * Copyright (C) 2004-2007 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ @@ -16,57 +16,147 @@ #include +#include +#include -#include "inkscape_py.py.h" +#include -/* - * Generated by SWIG - */ -extern "C" void init_inkscape_py(void); +namespace Inkscape +{ +namespace Extension +{ +namespace Script +{ -namespace Inkscape { -namespace Extension { -namespace Script { +//######################################################################## +//# I N K S C A P E +//######################################################################## -/* - * - */ -InkscapePython::InkscapePython() +class PyDialogManager : public Py::PythonExtension { -} +public: -/* - * - */ -InkscapePython::~InkscapePython() +private: + +}; + + + +class PyDesktop : public Py::PythonExtension +{ +public: + + + +private: + +}; + + + +class PyDocument : public Py::PythonExtension +{ +public: + + + +private: + +}; + + + +class PyInkscape : public Py::PythonExtension +{ +public: + + PyInkscape() + { + inkscape = INKSCAPE; + } + + virtual ~PyInkscape() + { + } + + + virtual Py::Object getattr(const char *name) + { + if (strcmp(name, "activeDesktop")==0) + { + } + else if (strcmp(name, "activeDocument")==0) + { + } + else if (strcmp(name, "dialogManager")==0) + { + } + return getattr_methods(name); + } + + virtual Py::Object exit(const Py::Tuple &args) + { + //exit(); + } + + static void init_type() + { + behaviors().name("inkscape"); + behaviors().doc("inkscape objects: activeDesktop activeDocument dialogManager"); + behaviors().supportRepr(); + behaviors().supportGetattr(); + + add_varargs_method("exit", &PyInkscape::exit, + "exit from the current application"); + } + +private: + + Inkscape::Application *inkscape; + +}; + + + + +//######################################################################## +//# M A I N +//######################################################################## + + +bool InkscapePython::initialize() { + if (initialized) + return true; + + Py_Initialize(); + + + + initialized = true; + return true; } -static bool initialized = false; /* * Interpret an in-memory string */ bool InkscapePython::interpretScript(const Glib::ustring &script, - Glib::ustring &output, - Glib::ustring &error) + Glib::ustring &output, Glib::ustring &error) { - if (!initialized) - { - Py_Initialize(); - init_inkscape_py(); - initialized = true; - } + if (!initialize()) + return false; + char *codeStr = (char *)script.raw().c_str(); - PyRun_SimpleString(inkscape_module_script); - PyRun_SimpleString("inkscape = _inkscape_py.getInkscape()\n"); - PyRun_SimpleString(codeStr); + //PyRun_SimpleString(inkscape_module_script); + //PyRun_SimpleString("inkscape = _inkscape_py.getInkscape()\n"); + //PyRun_SimpleString(codeStr); //## Check for errors if (PyErr_Occurred()) diff --git a/src/extension/script/InkscapePython.h b/src/extension/script/InkscapePython.h index cdf9bd0f1..76739c152 100644 --- a/src/extension/script/InkscapePython.h +++ b/src/extension/script/InkscapePython.h @@ -7,7 +7,7 @@ * Authors: * Bob Jamison * - * Copyright (C) 2004 Authors + * Copyright (C) 2004-2007 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ @@ -15,9 +15,14 @@ #include "InkscapeInterpreter.h" #include -namespace Inkscape { -namespace Extension { -namespace Script { + + +namespace Inkscape +{ +namespace Extension +{ +namespace Script +{ @@ -25,21 +30,28 @@ class InkscapePython : public InkscapeInterpreter { public: - /* - * + /** + * Constructor. Create and initialize python binding. + * Note that we will only actually start up the Python + * interpreter when there is a demand. */ - InkscapePython(); + InkscapePython() + { + initialized = false; + } - /* - * + /** + * Destructor */ - virtual ~InkscapePython(); + virtual ~InkscapePython() + { + } - /* - * + /** + * Overloaded from InkscapeInterpreter */ virtual bool interpretScript(const Glib::ustring &script, Glib::ustring &output, @@ -50,10 +62,19 @@ public: private: + /** + * First-time call to set things up + */ + bool initialize(); + + bool initialized; + }; + + } // namespace Script } // namespace Extension } // namespace Inkscape diff --git a/src/extension/script/Makefile_insert b/src/extension/script/Makefile_insert index 1dcb30042..091bf0123 100644 --- a/src/extension/script/Makefile_insert +++ b/src/extension/script/Makefile_insert @@ -19,9 +19,17 @@ if WITH_PYTHON python_sources = \ extension/script/InkscapePython.h \ extension/script/InkscapePython.cpp \ - extension/script/inkscape_py_wrap.cpp \ - extension/script/inkscape_py.py \ - extension/script/inkscape_py.py.h + extension/script/cxx/Config.hxx \ + extension/script/cxx/cxxextensions.c \ + extension/script/cxx/cxxsupport.cxx \ + extension/script/cxx/cxx_extensions.cxx \ + extension/script/cxx/Exception.hxx \ + extension/script/cxx/Extensions.hxx \ + extension/script/cxx/IndirectPythonInterface.cxx \ + extension/script/cxx/IndirectPythonInterface.hxx \ + extension/script/cxx/Objects.hxx \ + extension/script/cxx/Version.hxx \ + extension/script/cxx/WrapPython.h endif extension_script_libscript_a_SOURCES = \ diff --git a/src/extension/script/cxx/Config.hxx b/src/extension/script/cxx/Config.hxx new file mode 100644 index 000000000..b27f9ba28 --- /dev/null +++ b/src/extension/script/cxx/Config.hxx @@ -0,0 +1,118 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __PyCXX_config_hh__ +#define __PyCXX_config_hh__ + +// +// Microsoft VC++ 6.0 has no traits +// +#if defined( _MSC_VER ) + +# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 1 + +#elif defined( __GNUC__ ) +# if __GNUC__ >= 3 +# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 1 +# else +# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 0 +#endif + +// +// Assume all other compilers do +// +#else + +// Macros to deal with deficiencies in compilers +# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 1 +#endif + +#if STANDARD_LIBRARY_HAS_ITERATOR_TRAITS +# define random_access_iterator_parent(itemtype) std::iterator +#else +# define random_access_iterator_parent(itemtype) std::random_access_iterator +#endif + +// +// Which C++ standard is in use? +// +#if defined( _MSC_VER ) +# if _MSC_VER <= 1200 +// MSVC++ 6.0 +# define PYCXX_ISO_CPP_LIB 0 +# define STR_STREAM +# define TEMPLATE_TYPENAME class +# else +# define PYCXX_ISO_CPP_LIB 1 +# define STR_STREAM +# define TEMPLATE_TYPENAME typename +# endif +#elif defined( __GNUC__ ) +# if __GNUC__ >= 3 +# define PYCXX_ISO_CPP_LIB 1 +# define STR_STREAM +# define TEMPLATE_TYPENAME typename +# else +# define PYCXX_ISO_CPP_LIB 0 +# define STR_STREAM +# define TEMPLATE_TYPENAME class +# endif +#endif + +#if PYCXX_ISO_CPP_LIB +# define STR_STREAM +# define OSTRSTREAM ostringstream +# define EXPLICIT_TYPENAME typename +# define EXPLICIT_CLASS class +# define TEMPLATE_TYPENAME typename +#else +# define STR_STREAM +# define OSTRSTREAM ostrstream +# define EXPLICIT_TYPENAME +# define EXPLICIT_CLASS +# define TEMPLATE_TYPENAME class +#endif + +// before 2.5 Py_ssize_t was missing +#ifndef PY_MAJOR_VERSION +#error not defined PY_MAJOR_VERSION +#endif +#if PY_MAJOR_VERSION < 2 || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 5) +typedef int Py_ssize_t; +#endif + +#endif // __PyCXX_config_hh__ diff --git a/src/extension/script/cxx/Exception.hxx b/src/extension/script/cxx/Exception.hxx new file mode 100644 index 000000000..1ef087cac --- /dev/null +++ b/src/extension/script/cxx/Exception.hxx @@ -0,0 +1,249 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_Exception_h +#define __CXX_Exception_h + +#include "CXX/WrapPython.h" +#include "CXX/Version.hxx" +#include "CXX/Config.hxx" +#include "CXX/IndirectPythonInterface.hxx" + +#include +#include + +// This mimics the Python structure, in order to minimize confusion +namespace Py +{ + class ExtensionExceptionType; + + class Object; + + class Exception + { + public: + Exception( ExtensionExceptionType &exception, const std::string& reason ); + Exception( ExtensionExceptionType &exception, Object &reason ); + + explicit Exception () + {} + + Exception (const std::string& reason) + { + PyErr_SetString (Py::_Exc_RuntimeError(), reason.c_str()); + } + + Exception (PyObject* exception, const std::string& reason) + { + PyErr_SetString (exception, reason.c_str()); + } + + Exception (PyObject* exception, Object &reason); + + void clear() // clear the error + // technically but not philosophically const + { + PyErr_Clear(); + } + }; + + + // Abstract + class StandardError: public Exception + { + protected: + explicit StandardError() + {} + }; + + class LookupError: public StandardError + { + protected: + explicit LookupError() + {} + }; + + class ArithmeticError: public StandardError + { + protected: + explicit ArithmeticError() + {} + }; + + class EnvironmentError: public StandardError + { + protected: + explicit EnvironmentError() + {} + }; + + // Concrete + + class TypeError: public StandardError + { + public: + TypeError (const std::string& reason) + : StandardError() + { + PyErr_SetString (Py::_Exc_TypeError(),reason.c_str()); + } + }; + + class IndexError: public LookupError + { + public: + IndexError (const std::string& reason) + : LookupError() + { + PyErr_SetString (Py::_Exc_IndexError(), reason.c_str()); + } + }; + + class AttributeError: public StandardError + { + public: + AttributeError (const std::string& reason) + : StandardError() + { + PyErr_SetString (Py::_Exc_AttributeError(), reason.c_str()); + } + }; + + class NameError: public StandardError + { + public: + NameError (const std::string& reason) + : StandardError() + { + PyErr_SetString (Py::_Exc_NameError(), reason.c_str()); + } + }; + + class RuntimeError: public StandardError + { + public: + RuntimeError (const std::string& reason) + : StandardError() + { + PyErr_SetString (Py::_Exc_RuntimeError(), reason.c_str()); + } + }; + + class SystemError: public StandardError + { + public: + SystemError (const std::string& reason) + : StandardError() + { + PyErr_SetString (Py::_Exc_SystemError(),reason.c_str()); + } + }; + + class KeyError: public LookupError + { + public: + KeyError (const std::string& reason) + : LookupError() + { + PyErr_SetString (Py::_Exc_KeyError(),reason.c_str()); + } + }; + + + class ValueError: public StandardError + { + public: + ValueError (const std::string& reason) + : StandardError() + { + PyErr_SetString (Py::_Exc_ValueError(), reason.c_str()); + } + }; + + class OverflowError: public ArithmeticError + { + public: + OverflowError (const std::string& reason) + : ArithmeticError() + { + PyErr_SetString (Py::_Exc_OverflowError(), reason.c_str()); + } + }; + + class ZeroDivisionError: public ArithmeticError + { + public: + ZeroDivisionError (const std::string& reason) + : ArithmeticError() + { + PyErr_SetString (Py::_Exc_ZeroDivisionError(), reason.c_str()); + } + }; + + class FloatingPointError: public ArithmeticError + { + public: + FloatingPointError (const std::string& reason) + : ArithmeticError() + { + PyErr_SetString (Py::_Exc_FloatingPointError(), reason.c_str()); + } + }; + + class MemoryError: public StandardError + { + public: + MemoryError (const std::string& reason) + : StandardError() + { + PyErr_SetString (Py::_Exc_MemoryError(), reason.c_str()); + } + }; + + class SystemExit: public StandardError + { + public: + SystemExit (const std::string& reason) + : StandardError() + { + PyErr_SetString (Py::_Exc_SystemExit(),reason.c_str()); + } + }; + +}// Py + +#endif diff --git a/src/extension/script/cxx/Extensions.hxx b/src/extension/script/cxx/Extensions.hxx new file mode 100644 index 000000000..83738c9af --- /dev/null +++ b/src/extension/script/cxx/Extensions.hxx @@ -0,0 +1,791 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_Extensions__h +#define __CXX_Extensions__h + + +#ifdef _MSC_VER +// disable warning C4786: symbol greater than 255 character, +// okay to ignore +#pragma warning(disable: 4786) +#endif + +#include "CXX/WrapPython.h" +#include "CXX/Version.hxx" +#include "CXX/Config.hxx" +#include "CXX/Objects.hxx" + +extern "C" +{ + extern PyObject py_object_initializer; +} + +#include +#include + +namespace Py +{ + class ExtensionModuleBase; + + // Make an Exception Type for use in raising custom exceptions + class ExtensionExceptionType : public Object + { + public: + ExtensionExceptionType(); + virtual ~ExtensionExceptionType(); + + // call init to create the type + void init( ExtensionModuleBase &module, const std::string& name, ExtensionExceptionType &parent ); + void init( ExtensionModuleBase &module, const std::string& name ); + }; + + + class MethodTable + { + public: + MethodTable(); + virtual ~MethodTable(); + + void add(const char* method_name, PyCFunction f, const char* doc="", int flag=1); + PyMethodDef* table(); + + protected: + std::vector t; // accumulator of PyMethodDef's + PyMethodDef *mt; // Actual method table produced when full + + static PyMethodDef method (const char* method_name, PyCFunction f, int flags = 1, const char* doc=""); + + private: + // + // prevent the compiler generating these unwanted functions + // + MethodTable(const MethodTable& m); //unimplemented + void operator=(const MethodTable& m); //unimplemented + + }; // end class MethodTable + + extern "C" + { + typedef PyObject *(*method_varargs_call_handler_t)( PyObject *_self, PyObject *_args ); + typedef PyObject *(*method_keyword_call_handler_t)( PyObject *_self, PyObject *_args, PyObject *_dict ); + }; + + template + class MethodDefExt : public PyMethodDef + { + public: + typedef Object (T::*method_varargs_function_t)( const Tuple &args ); + typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws ); + + MethodDefExt + ( + const char *_name, + method_varargs_function_t _function, + method_varargs_call_handler_t _handler, + const char *_doc + ) + { + ext_meth_def.ml_name = const_cast(_name); + ext_meth_def.ml_meth = _handler; + ext_meth_def.ml_flags = METH_VARARGS; + ext_meth_def.ml_doc = const_cast(_doc); + + ext_varargs_function = _function; + ext_keyword_function = NULL; + } + + MethodDefExt + ( + const char *_name, + method_keyword_function_t _function, + method_keyword_call_handler_t _handler, + const char *_doc + ) + { + ext_meth_def.ml_name = const_cast(_name); + ext_meth_def.ml_meth = method_varargs_call_handler_t( _handler ); + ext_meth_def.ml_flags = METH_VARARGS|METH_KEYWORDS; + ext_meth_def.ml_doc = const_cast(_doc); + + ext_varargs_function = NULL; + ext_keyword_function = _function; + } + + ~MethodDefExt() + {} + + PyMethodDef ext_meth_def; + method_varargs_function_t ext_varargs_function; + method_keyword_function_t ext_keyword_function; + }; + + class ExtensionModuleBase + { + public: + ExtensionModuleBase( const char *name ); + virtual ~ExtensionModuleBase(); + + Module module(void) const; // only valid after initialize() has been called + Dict moduleDictionary(void) const; // only valid after initialize() has been called + + virtual Object invoke_method_keyword( const std::string &_name, const Tuple &_args, const Dict &_keywords ) = 0; + virtual Object invoke_method_varargs( const std::string &_name, const Tuple &_args ) = 0; + + const std::string &name() const; + const std::string &fullName() const; + + protected: + // Initialize the module + void initialize( const char *module_doc ); + + const std::string module_name; + const std::string full_module_name; + MethodTable method_table; + + private: + + // + // prevent the compiler generating these unwanted functions + // + ExtensionModuleBase( const ExtensionModuleBase & ); //unimplemented + void operator=( const ExtensionModuleBase & ); //unimplemented + + }; + + extern "C" PyObject *method_keyword_call_handler( PyObject *_self_and_name_tuple, PyObject *_args, PyObject *_keywords ); + extern "C" PyObject *method_varargs_call_handler( PyObject *_self_and_name_tuple, PyObject *_args ); + extern "C" void do_not_dealloc( void * ); + + + template + class ExtensionModule : public ExtensionModuleBase + { + public: + ExtensionModule( const char *name ) + : ExtensionModuleBase( name ) + {} + virtual ~ExtensionModule() + {} + + protected: + typedef Object (T::*method_varargs_function_t)( const Tuple &args ); + typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws ); + typedef std::map *> method_map_t; + + static void add_varargs_method( const char *name, method_varargs_function_t function, const char *doc="" ) + { + method_map_t &mm = methods(); + + MethodDefExt *method_definition = new MethodDefExt + ( + name, + function, + method_varargs_call_handler, + doc + ); + + mm[std::string( name )] = method_definition; + } + + static void add_keyword_method( const char *name, method_keyword_function_t function, const char *doc="" ) + { + method_map_t &mm = methods(); + + MethodDefExt *method_definition = new MethodDefExt + ( + name, + function, + method_keyword_call_handler, + doc + ); + + mm[std::string( name )] = method_definition; + } + + void initialize( const char *module_doc="" ) + { + ExtensionModuleBase::initialize( module_doc ); + Dict dict( moduleDictionary() ); + + // + // put each of the methods into the modules dictionary + // so that we get called back at the function in T. + // + method_map_t &mm = methods(); + EXPLICIT_TYPENAME method_map_t::iterator i; + + for( i=mm.begin(); i != mm.end(); ++i ) + { + MethodDefExt *method_definition = (*i).second; + + static PyObject *self = PyCObject_FromVoidPtr( this, do_not_dealloc ); + + Tuple args( 2 ); + args[0] = Object( self ); + args[1] = String( (*i).first ); + + PyObject *func = PyCFunction_New + ( + &method_definition->ext_meth_def, + new_reference_to( args ) + ); + + dict[ (*i).first ] = Object( func ); + } + } + + protected: // Tom Malcolmson reports that derived classes need access to these + + static method_map_t &methods(void) + { + static method_map_t *map_of_methods = NULL; + if( map_of_methods == NULL ) + map_of_methods = new method_map_t; + + return *map_of_methods; + } + + + // this invoke function must be called from within a try catch block + virtual Object invoke_method_keyword( const std::string &name, const Tuple &args, const Dict &keywords ) + { + method_map_t &mm = methods(); + MethodDefExt *meth_def = mm[ name ]; + if( meth_def == NULL ) + { + std::string error_msg( "CXX - cannot invoke keyword method named " ); + error_msg += name; + throw RuntimeError( error_msg ); + } + + // cast up to the derived class + T *self = static_cast(this); + + return (self->*meth_def->ext_keyword_function)( args, keywords ); + } + + // this invoke function must be called from within a try catch block + virtual Object invoke_method_varargs( const std::string &name, const Tuple &args ) + { + method_map_t &mm = methods(); + MethodDefExt *meth_def = mm[ name ]; + if( meth_def == NULL ) + { + std::string error_msg( "CXX - cannot invoke varargs method named " ); + error_msg += name; + throw RuntimeError( error_msg ); + } + + // cast up to the derived class + T *self = static_cast(this); + + return (self->*meth_def->ext_varargs_function)( args ); + } + + private: + // + // prevent the compiler generating these unwanted functions + // + ExtensionModule( const ExtensionModule & ); //unimplemented + void operator=( const ExtensionModule & ); //unimplemented + }; + + + class PythonType + { + public: + // if you define one sequence method you must define + // all of them except the assigns + + PythonType (size_t base_size, int itemsize, const char *default_name ); + virtual ~PythonType (); + + const char *getName () const; + const char *getDoc () const; + + PyTypeObject* type_object () const; + PythonType & name (const char* nam); + PythonType & doc (const char* d); + PythonType & dealloc(void (*f)(PyObject*)); + + PythonType & supportPrint(void); + PythonType & supportGetattr(void); + PythonType & supportSetattr(void); + PythonType & supportGetattro(void); + PythonType & supportSetattro(void); + PythonType & supportCompare(void); + PythonType & supportRepr(void); + PythonType & supportStr(void); + PythonType & supportHash(void); + PythonType & supportCall(void); + PythonType & supportIter(void); + + PythonType & supportSequenceType(void); + PythonType & supportMappingType(void); + PythonType & supportNumberType(void); + PythonType & supportBufferType(void); + + protected: + PyTypeObject *table; + PySequenceMethods *sequence_table; + PyMappingMethods *mapping_table; + PyNumberMethods *number_table; + PyBufferProcs *buffer_table; + + void init_sequence(); + void init_mapping(); + void init_number(); + void init_buffer(); + + private: + // + // prevent the compiler generating these unwanted functions + // + PythonType (const PythonType& tb); // unimplemented + void operator=(const PythonType& t); // unimplemented + + }; // end of PythonType + + + + // Class PythonExtension is what you inherit from to create + // a new Python extension type. You give your class itself + // as the template paramter. + + // There are two ways that extension objects can get destroyed. + // 1. Their reference count goes to zero + // 2. Someone does an explicit delete on a pointer. + // In (1) the problem is to get the destructor called + // We register a special deallocator in the Python type object + // (see behaviors()) to do this. + // In (2) there is no problem, the dtor gets called. + + // PythonExtension does not use the usual Python heap allocator, + // instead using new/delete. We do the setting of the type object + // and reference count, usually done by PyObject_New, in the + // base class ctor. + + // This special deallocator does a delete on the pointer. + + + class PythonExtensionBase : public PyObject + { + public: + PythonExtensionBase(); + virtual ~PythonExtensionBase(); + + public: + virtual int print( FILE *, int ); + virtual Object getattr( const char * ) = 0; + virtual int setattr( const char *, const Object & ); + virtual Object getattro( const Object & ); + virtual int setattro( const Object &, const Object & ); + virtual int compare( const Object & ); + virtual Object repr(); + virtual Object str(); + virtual long hash(); + virtual Object call( const Object &, const Object & ); + virtual Object iter(); + virtual PyObject* iternext(); + + // Sequence methods + virtual int sequence_length(); + virtual Object sequence_concat( const Object & ); + virtual Object sequence_repeat( Py_ssize_t ); + virtual Object sequence_item( Py_ssize_t ); + virtual Object sequence_slice( Py_ssize_t, Py_ssize_t ); + virtual int sequence_ass_item( Py_ssize_t, const Object & ); + virtual int sequence_ass_slice( Py_ssize_t, Py_ssize_t, const Object & ); + + // Mapping + virtual int mapping_length(); + virtual Object mapping_subscript( const Object & ); + virtual int mapping_ass_subscript( const Object &, const Object & ); + + // Number + virtual int number_nonzero(); + virtual Object number_negative(); + virtual Object number_positive(); + virtual Object number_absolute(); + virtual Object number_invert(); + virtual Object number_int(); + virtual Object number_float(); + virtual Object number_long(); + virtual Object number_oct(); + virtual Object number_hex(); + virtual Object number_add( const Object & ); + virtual Object number_subtract( const Object & ); + virtual Object number_multiply( const Object & ); + virtual Object number_divide( const Object & ); + virtual Object number_remainder( const Object & ); + virtual Object number_divmod( const Object & ); + virtual Object number_lshift( const Object & ); + virtual Object number_rshift( const Object & ); + virtual Object number_and( const Object & ); + virtual Object number_xor( const Object & ); + virtual Object number_or( const Object & ); + virtual Object number_power( const Object &, const Object & ); + + // Buffer + virtual Py_ssize_t buffer_getreadbuffer( Py_ssize_t, void** ); + virtual Py_ssize_t buffer_getwritebuffer( Py_ssize_t, void** ); + virtual Py_ssize_t buffer_getsegcount( Py_ssize_t* ); + + private: + void missing_method( void ); + static PyObject *method_call_handler( PyObject *self, PyObject *args ); + }; + + template + class PythonExtension: public PythonExtensionBase + { + public: + static PyTypeObject* type_object() + { + return behaviors().type_object(); + } + + static int check( PyObject *p ) + { + // is p like me? + return p->ob_type == type_object(); + } + + static int check( const Object& ob ) + { + return check( ob.ptr()); + } + + + // + // every object needs getattr implemented + // to support methods + // + virtual Object getattr( const char *name ) + { + return getattr_methods( name ); + } + + protected: + explicit PythonExtension() + : PythonExtensionBase() + { + #ifdef PyObject_INIT + (void)PyObject_INIT( this, type_object() ); + #else + ob_refcnt = 1; + ob_type = type_object(); + #endif + + // every object must support getattr + behaviors().supportGetattr(); + } + + virtual ~PythonExtension() + {} + + static PythonType &behaviors() + { + static PythonType* p; + if( p == NULL ) + { +#if defined( _CPPRTTI ) || defined(__GNUG__) + const char *default_name = (typeid ( T )).name(); +#else + const char *default_name = "unknown"; +#endif + p = new PythonType( sizeof( T ), 0, default_name ); + p->dealloc( extension_object_deallocator ); + } + + return *p; + } + + + typedef Object (T::*method_varargs_function_t)( const Tuple &args ); + typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws ); + typedef std::map *> method_map_t; + + // support the default attributes, __name__, __doc__ and methods + virtual Object getattr_default( const char *_name ) + { + std::string name( _name ); + + if( name == "__name__" && type_object()->tp_name != NULL ) + { + return Py::String( type_object()->tp_name ); + } + if( name == "__doc__" && type_object()->tp_doc != NULL ) + { + return Py::String( type_object()->tp_doc ); + } + +// trying to fake out being a class for help() +// else if( name == "__bases__" ) +// { +// return Py::Tuple(0); +// } +// else if( name == "__module__" ) +// { +// return Py::Nothing(); +// } +// else if( name == "__dict__" ) +// { +// return Py::Dict(); +// } + + return getattr_methods( _name ); + } + + // turn a name into function object + virtual Object getattr_methods( const char *_name ) + { + std::string name( _name ); + + method_map_t &mm = methods(); + + if( name == "__methods__" ) + { + List methods; + + for( EXPLICIT_TYPENAME method_map_t::iterator i = mm.begin(); i != mm.end(); ++i ) + methods.append( String( (*i).first ) ); + + return methods; + } + + // see if name exists + if( mm.find( name ) == mm.end() ) + throw AttributeError( name ); + + Tuple self( 2 ); + + self[0] = Object( this ); + self[1] = String( name ); + + MethodDefExt *method_definition = mm[ name ]; + + PyObject *func = PyCFunction_New( &method_definition->ext_meth_def, self.ptr() ); + + return Object(func, true); + } + + static void add_varargs_method( const char *name, method_varargs_function_t function, const char *doc="" ) + { + method_map_t &mm = methods(); + + MethodDefExt *method_definition = new MethodDefExt + ( + name, + function, + method_varargs_call_handler, + doc + ); + + mm[std::string( name )] = method_definition; + } + + static void add_keyword_method( const char *name, method_keyword_function_t function, const char *doc="" ) + { + method_map_t &mm = methods(); + + MethodDefExt *method_definition = new MethodDefExt + ( + name, + function, + method_keyword_call_handler, + doc + ); + + mm[std::string( name )] = method_definition; + } + + private: + static method_map_t &methods(void) + { + static method_map_t *map_of_methods = NULL; + if( map_of_methods == NULL ) + map_of_methods = new method_map_t; + + return *map_of_methods; + } + + static PyObject *method_keyword_call_handler( PyObject *_self_and_name_tuple, PyObject *_args, PyObject *_keywords ) + { + try + { + Tuple self_and_name_tuple( _self_and_name_tuple ); + + PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); + T *self = static_cast( self_in_cobject ); + + String name( self_and_name_tuple[1] ); + + method_map_t &mm = methods(); + MethodDefExt *meth_def = mm[ name ]; + if( meth_def == NULL ) + return 0; + + Tuple args( _args ); + + // _keywords may be NULL so be careful about the way the dict is created + Dict keywords; + if( _keywords != NULL ) + keywords = Dict( _keywords ); + + Object result( (self->*meth_def->ext_keyword_function)( args, keywords ) ); + + return new_reference_to( result.ptr() ); + } + catch( Exception & ) + { + return 0; + } + } + + static PyObject *method_varargs_call_handler( PyObject *_self_and_name_tuple, PyObject *_args ) + { + try + { + Tuple self_and_name_tuple( _self_and_name_tuple ); + + PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); + T *self = static_cast( self_in_cobject ); + + String name( self_and_name_tuple[1] ); + + method_map_t &mm = methods(); + MethodDefExt *meth_def = mm[ name ]; + if( meth_def == NULL ) + return 0; + + Tuple args( _args ); + + Object result; + + // TMM: 7Jun'01 - Adding try & catch in case of STL debug-mode exceptions. + #ifdef _STLP_DEBUG + try + { + result = (self->*meth_def->ext_varargs_function)( args ); + } + catch (std::__stl_debug_exception) + { + // throw cxx::RuntimeError( sErrMsg ); + throw cxx::RuntimeError( "Error message not set yet." ); + } + #else + result = (self->*meth_def->ext_varargs_function)( args ); + #endif // _STLP_DEBUG + + return new_reference_to( result.ptr() ); + } + catch( Exception & ) + { + return 0; + } + } + + static void extension_object_deallocator ( PyObject* t ) + { + delete (T *)( t ); + } + + // + // prevent the compiler generating these unwanted functions + // + explicit PythonExtension( const PythonExtension& other ); + void operator=( const PythonExtension& rhs ); + }; + + // + // ExtensionObject is an Object that will accept only T's. + // + template + class ExtensionObject: public Object + { + public: + + explicit ExtensionObject ( PyObject *pyob ) + : Object( pyob ) + { + validate(); + } + + ExtensionObject( const ExtensionObject& other ) + : Object( *other ) + { + validate(); + } + + ExtensionObject( const Object& other ) + : Object( *other ) + { + validate(); + } + + ExtensionObject& operator= ( const Object& rhs ) + { + return (*this = *rhs ); + } + + ExtensionObject& operator= ( PyObject* rhsp ) + { + if( ptr() == rhsp ) + return *this; + set( rhsp ); + return *this; + } + + virtual bool accepts ( PyObject *pyob ) const + { + return ( pyob && T::check( pyob )); + } + + // + // Obtain a pointer to the PythonExtension object + // + T *extensionObject(void) + { + return static_cast( ptr() ); + } + }; + +} // Namespace Py +// End of CXX_Extensions.h +#endif diff --git a/src/extension/script/cxx/IndirectPythonInterface.cxx b/src/extension/script/cxx/IndirectPythonInterface.cxx new file mode 100644 index 000000000..1ab83bd76 --- /dev/null +++ b/src/extension/script/cxx/IndirectPythonInterface.cxx @@ -0,0 +1,583 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#include "CXX/IndirectPythonInterface.hxx" + +namespace Py +{ +bool _Buffer_Check( PyObject *op ) { return (op)->ob_type == _Buffer_Type(); } +bool _CFunction_Check( PyObject *op ) { return (op)->ob_type == _CFunction_Type(); } +bool _Class_Check( PyObject *op ) { return (op)->ob_type == _Class_Type(); } +bool _CObject_Check( PyObject *op ) { return (op)->ob_type == _CObject_Type(); } +bool _Complex_Check( PyObject *op ) { return (op)->ob_type == _Complex_Type(); } +bool _Dict_Check( PyObject *op ) { return (op)->ob_type == _Dict_Type(); } +bool _File_Check( PyObject *op ) { return (op)->ob_type == _File_Type(); } +bool _Float_Check( PyObject *op ) { return (op)->ob_type == _Float_Type(); } +bool _Function_Check( PyObject *op ) { return (op)->ob_type == _Function_Type(); } +bool _Instance_Check( PyObject *op ) { return (op)->ob_type == _Instance_Type(); } +bool _Int_Check( PyObject *op ) { return (op)->ob_type == _Int_Type(); } +bool _List_Check( PyObject *o ) { return o->ob_type == _List_Type(); } +bool _Long_Check( PyObject *op ) { return (op)->ob_type == _Long_Type(); } +bool _Method_Check( PyObject *op ) { return (op)->ob_type == _Method_Type(); } +bool _Module_Check( PyObject *op ) { return (op)->ob_type == _Module_Type(); } +bool _Range_Check( PyObject *op ) { return (op)->ob_type == _Range_Type(); } +bool _Slice_Check( PyObject *op ) { return (op)->ob_type == _Slice_Type(); } +bool _String_Check( PyObject *o ) { return o->ob_type == _String_Type(); } +bool _TraceBack_Check( PyObject *v ) { return (v)->ob_type == _TraceBack_Type(); } +bool _Tuple_Check( PyObject *op ) { return (op)->ob_type == _Tuple_Type(); } +bool _Type_Check( PyObject *op ) { return (op)->ob_type == _Type_Type(); } + +#if PY_MAJOR_VERSION >= 2 +bool _Unicode_Check( PyObject *op ) { return (op)->ob_type == _Unicode_Type(); } +#endif + + + +#if defined(PY_WIN32_DELAYLOAD_PYTHON_DLL) + +#if defined(MS_WINDOWS) +#include + + +static HMODULE python_dll; + +static PyObject *ptr__Exc_ArithmeticError = NULL; +static PyObject *ptr__Exc_AssertionError = NULL; +static PyObject *ptr__Exc_AttributeError = NULL; +static PyObject *ptr__Exc_EnvironmentError = NULL; +static PyObject *ptr__Exc_EOFError = NULL; +static PyObject *ptr__Exc_Exception = NULL; +static PyObject *ptr__Exc_FloatingPointError = NULL; +static PyObject *ptr__Exc_ImportError = NULL; +static PyObject *ptr__Exc_IndexError = NULL; +static PyObject *ptr__Exc_IOError = NULL; +static PyObject *ptr__Exc_KeyboardInterrupt = NULL; +static PyObject *ptr__Exc_KeyError = NULL; +static PyObject *ptr__Exc_LookupError = NULL; +static PyObject *ptr__Exc_MemoryError = NULL; +static PyObject *ptr__Exc_MemoryErrorInst = NULL; +static PyObject *ptr__Exc_NameError = NULL; +static PyObject *ptr__Exc_NotImplementedError = NULL; +static PyObject *ptr__Exc_OSError = NULL; +static PyObject *ptr__Exc_OverflowError = NULL; +static PyObject *ptr__Exc_RuntimeError = NULL; +static PyObject *ptr__Exc_StandardError = NULL; +static PyObject *ptr__Exc_SyntaxError = NULL; +static PyObject *ptr__Exc_SystemError = NULL; +static PyObject *ptr__Exc_SystemExit = NULL; +static PyObject *ptr__Exc_TypeError = NULL; +static PyObject *ptr__Exc_ValueError = NULL; +static PyObject *ptr__Exc_ZeroDivisionError = NULL; + +#ifdef MS_WINDOWS +static PyObject *ptr__Exc_WindowsError = NULL; +#endif + +#if PY_MAJOR_VERSION >= 2 +static PyObject *ptr__Exc_IndentationError = NULL; +static PyObject *ptr__Exc_TabError = NULL; +static PyObject *ptr__Exc_UnboundLocalError = NULL; +static PyObject *ptr__Exc_UnicodeError = NULL; +#endif + +static PyObject *ptr__PyNone = NULL; + +static PyTypeObject *ptr__Buffer_Type = NULL; +static PyTypeObject *ptr__CFunction_Type = NULL; +static PyTypeObject *ptr__Class_Type = NULL; +static PyTypeObject *ptr__CObject_Type = NULL; +static PyTypeObject *ptr__Complex_Type = NULL; +static PyTypeObject *ptr__Dict_Type = NULL; +static PyTypeObject *ptr__File_Type = NULL; +static PyTypeObject *ptr__Float_Type = NULL; +static PyTypeObject *ptr__Function_Type = NULL; +static PyTypeObject *ptr__Instance_Type = NULL; +static PyTypeObject *ptr__Int_Type = NULL; +static PyTypeObject *ptr__List_Type = NULL; +static PyTypeObject *ptr__Long_Type = NULL; +static PyTypeObject *ptr__Method_Type = NULL; +static PyTypeObject *ptr__Module_Type = NULL; +static PyTypeObject *ptr__Range_Type = NULL; +static PyTypeObject *ptr__Slice_Type = NULL; +static PyTypeObject *ptr__String_Type = NULL; +static PyTypeObject *ptr__TraceBack_Type = NULL; +static PyTypeObject *ptr__Tuple_Type = NULL; +static PyTypeObject *ptr__Type_Type = NULL; + +#if PY_MAJOR_VERSION >= 2 +static PyTypeObject *ptr__Unicode_Type = NULL; +#endif + +static int *ptr_Py_DebugFlag = NULL; +static int *ptr_Py_InteractiveFlag = NULL; +static int *ptr_Py_OptimizeFlag = NULL; +static int *ptr_Py_NoSiteFlag = NULL; +static int *ptr_Py_TabcheckFlag = NULL; +static int *ptr_Py_VerboseFlag = NULL; + +#if PY_MAJOR_VERSION >= 2 +static int *ptr_Py_UnicodeFlag = NULL; +#endif + +static char **ptr__Py_PackageContext = NULL; + +#ifdef Py_REF_DEBUG +int *ptr_Py_RefTotal; +#endif + + +//-------------------------------------------------------------------------------- +class GetAddressException +{ +public: + GetAddressException( const char *_name ) + : name( _name ) + {} + virtual ~GetAddressException() {} + const char *name; +}; + + +//-------------------------------------------------------------------------------- +static PyObject *GetPyObjectPointer_As_PyObjectPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return *(PyObject **)addr; +} + +static PyObject *GetPyObject_As_PyObjectPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return (PyObject *)addr; +} + +static PyTypeObject *GetPyTypeObjectPointer_As_PyTypeObjectPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return *(PyTypeObject **)addr; +} + +static PyTypeObject *GetPyTypeObject_As_PyTypeObjectPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return (PyTypeObject *)addr; +} + +static int *GetInt_as_IntPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return (int *)addr; +} + +static char **GetCharPointer_as_CharPointerPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return (char **)addr; +} + + +#ifdef _DEBUG +static const char python_dll_name_format[] = "PYTHON%1.1d%1.1d_D.DLL"; +#else +static const char python_dll_name_format[] = "PYTHON%1.1d%1.1d.DLL"; +#endif + +//-------------------------------------------------------------------------------- +bool InitialisePythonIndirectInterface() +{ + char python_dll_name[sizeof(python_dll_name_format)]; + + sprintf( python_dll_name, python_dll_name_format, PY_MAJOR_VERSION, PY_MINOR_VERSION ); + + python_dll = LoadLibrary( python_dll_name ); + if( python_dll == NULL ) + return false; + + try +{ +#ifdef Py_REF_DEBUG + ptr_Py_RefTotal = GetInt_as_IntPointer( "_Py_RefTotal" ); +#endif + ptr_Py_DebugFlag = GetInt_as_IntPointer( "Py_DebugFlag" ); + ptr_Py_InteractiveFlag = GetInt_as_IntPointer( "Py_InteractiveFlag" ); + ptr_Py_OptimizeFlag = GetInt_as_IntPointer( "Py_OptimizeFlag" ); + ptr_Py_NoSiteFlag = GetInt_as_IntPointer( "Py_NoSiteFlag" ); + ptr_Py_TabcheckFlag = GetInt_as_IntPointer( "Py_TabcheckFlag" ); + ptr_Py_VerboseFlag = GetInt_as_IntPointer( "Py_VerboseFlag" ); +#if PY_MAJOR_VERSION >= 2 + ptr_Py_UnicodeFlag = GetInt_as_IntPointer( "Py_UnicodeFlag" ); +#endif + ptr__Py_PackageContext = GetCharPointer_as_CharPointerPointer( "_Py_PackageContext" ); + + ptr__Exc_ArithmeticError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ArithmeticError" ); + ptr__Exc_AssertionError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_AssertionError" ); + ptr__Exc_AttributeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_AttributeError" ); + ptr__Exc_EnvironmentError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_EnvironmentError" ); + ptr__Exc_EOFError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_EOFError" ); + ptr__Exc_Exception = GetPyObjectPointer_As_PyObjectPointer( "PyExc_Exception" ); + ptr__Exc_FloatingPointError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_FloatingPointError" ); + ptr__Exc_ImportError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ImportError" ); + ptr__Exc_IndexError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_IndexError" ); + ptr__Exc_IOError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_IOError" ); + ptr__Exc_KeyboardInterrupt = GetPyObjectPointer_As_PyObjectPointer( "PyExc_KeyboardInterrupt" ); + ptr__Exc_KeyError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_KeyError" ); + ptr__Exc_LookupError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_LookupError" ); + ptr__Exc_MemoryError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_MemoryError" ); + ptr__Exc_MemoryErrorInst = GetPyObjectPointer_As_PyObjectPointer( "PyExc_MemoryErrorInst" ); + ptr__Exc_NameError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_NameError" ); + ptr__Exc_NotImplementedError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_NotImplementedError" ); + ptr__Exc_OSError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_OSError" ); + ptr__Exc_OverflowError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_OverflowError" ); + ptr__Exc_RuntimeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_RuntimeError" ); + ptr__Exc_StandardError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_StandardError" ); + ptr__Exc_SyntaxError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_SyntaxError" ); + ptr__Exc_SystemError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_SystemError" ); + ptr__Exc_SystemExit = GetPyObjectPointer_As_PyObjectPointer( "PyExc_SystemExit" ); + ptr__Exc_TypeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_TypeError" ); + ptr__Exc_ValueError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ValueError" ); +#ifdef MS_WINDOWS + ptr__Exc_WindowsError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_WindowsError" ); +#endif + ptr__Exc_ZeroDivisionError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ZeroDivisionError" ); + +#if PY_MAJOR_VERSION >= 2 + ptr__Exc_IndentationError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_IndentationError" ); + ptr__Exc_TabError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_TabError" ); + ptr__Exc_UnboundLocalError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_UnboundLocalError" ); + ptr__Exc_UnicodeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_UnicodeError" ); +#endif + ptr__PyNone = GetPyObject_As_PyObjectPointer( "_Py_NoneStruct" ); + + ptr__Buffer_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyBuffer_Type" ); + ptr__CFunction_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyCFunction_Type" ); + ptr__Class_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyClass_Type" ); + ptr__CObject_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyCObject_Type" ); + ptr__Complex_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyComplex_Type" ); + ptr__Dict_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyDict_Type" ); + ptr__File_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyFile_Type" ); + ptr__Float_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyFloat_Type" ); + ptr__Function_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyFunction_Type" ); + ptr__Instance_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyInstance_Type" ); + ptr__Int_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyInt_Type" ); + ptr__List_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyList_Type" ); + ptr__Long_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyLong_Type" ); + ptr__Method_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyMethod_Type" ); + ptr__Module_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyModule_Type" ); + ptr__Range_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyRange_Type" ); + ptr__Slice_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PySlice_Type" ); + ptr__String_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyString_Type" ); + ptr__TraceBack_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyTraceBack_Type" ); + ptr__Tuple_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyTuple_Type" ); + ptr__Type_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyType_Type" ); + +#if PY_MAJOR_VERSION >= 2 + ptr__Unicode_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyUnicode_Type" ); +#endif +} + catch( GetAddressException &e ) + { + OutputDebugString( python_dll_name ); + OutputDebugString( " does not contain symbol "); + OutputDebugString( e.name ); + OutputDebugString( "\n" ); + + return false; + } + + return true; +} + +// +// Wrap variables as function calls +// +PyObject * _Exc_ArithmeticError(){ return ptr__Exc_ArithmeticError; } +PyObject * _Exc_AssertionError(){ return ptr__Exc_AssertionError; } +PyObject * _Exc_AttributeError(){ return ptr__Exc_AttributeError; } +PyObject * _Exc_EnvironmentError(){ return ptr__Exc_EnvironmentError; } +PyObject * _Exc_EOFError() { return ptr__Exc_EOFError; } +PyObject * _Exc_Exception() { return ptr__Exc_Exception; } +PyObject * _Exc_FloatingPointError(){ return ptr__Exc_FloatingPointError; } +PyObject * _Exc_ImportError() { return ptr__Exc_ImportError; } +PyObject * _Exc_IndexError() { return ptr__Exc_IndexError; } +PyObject * _Exc_IOError() { return ptr__Exc_IOError; } +PyObject * _Exc_KeyboardInterrupt(){ return ptr__Exc_KeyboardInterrupt; } +PyObject * _Exc_KeyError() { return ptr__Exc_KeyError; } +PyObject * _Exc_LookupError() { return ptr__Exc_LookupError; } +PyObject * _Exc_MemoryError() { return ptr__Exc_MemoryError; } +PyObject * _Exc_MemoryErrorInst(){ return ptr__Exc_MemoryErrorInst; } +PyObject * _Exc_NameError() { return ptr__Exc_NameError; } +PyObject * _Exc_NotImplementedError(){ return ptr__Exc_NotImplementedError; } +PyObject * _Exc_OSError() { return ptr__Exc_OSError; } +PyObject * _Exc_OverflowError() { return ptr__Exc_OverflowError; } +PyObject * _Exc_RuntimeError() { return ptr__Exc_RuntimeError; } +PyObject * _Exc_StandardError() { return ptr__Exc_StandardError; } +PyObject * _Exc_SyntaxError() { return ptr__Exc_SyntaxError; } +PyObject * _Exc_SystemError() { return ptr__Exc_SystemError; } +PyObject * _Exc_SystemExit() { return ptr__Exc_SystemExit; } +PyObject * _Exc_TypeError() { return ptr__Exc_TypeError; } +PyObject * _Exc_ValueError() { return ptr__Exc_ValueError; } +#ifdef MS_WINDOWS +PyObject * _Exc_WindowsError() { return ptr__Exc_WindowsError; } +#endif +PyObject * _Exc_ZeroDivisionError(){ return ptr__Exc_ZeroDivisionError; } + +#if PY_MAJOR_VERSION >= 2 +PyObject * _Exc_IndentationError(){ return ptr__Exc_IndentationError; } +PyObject * _Exc_TabError() { return ptr__Exc_TabError; } +PyObject * _Exc_UnboundLocalError(){ return ptr__Exc_UnboundLocalError; } +PyObject * _Exc_UnicodeError() { return ptr__Exc_UnicodeError; } +#endif + +// +// wrap items in Object.h +// +PyObject * _None() { return ptr__PyNone; } + + +PyTypeObject * _Buffer_Type() { return ptr__Buffer_Type; } +PyTypeObject * _CFunction_Type(){ return ptr__CFunction_Type; } +PyTypeObject * _Class_Type() { return ptr__Class_Type; } +PyTypeObject * _CObject_Type() { return ptr__CObject_Type; } +PyTypeObject * _Complex_Type() { return ptr__Complex_Type; } +PyTypeObject * _Dict_Type() { return ptr__Dict_Type; } +PyTypeObject * _File_Type() { return ptr__File_Type; } +PyTypeObject * _Float_Type() { return ptr__Float_Type; } +PyTypeObject * _Function_Type() { return ptr__Function_Type; } +PyTypeObject * _Instance_Type() { return ptr__Instance_Type; } +PyTypeObject * _Int_Type() { return ptr__Int_Type; } +PyTypeObject * _List_Type() { return ptr__List_Type; } +PyTypeObject * _Long_Type() { return ptr__Long_Type; } +PyTypeObject * _Method_Type() { return ptr__Method_Type; } +PyTypeObject * _Module_Type() { return ptr__Module_Type; } +PyTypeObject * _Range_Type() { return ptr__Range_Type; } +PyTypeObject * _Slice_Type() { return ptr__Slice_Type; } +PyTypeObject * _String_Type() { return ptr__String_Type; } +PyTypeObject * _TraceBack_Type(){ return ptr__TraceBack_Type; } +PyTypeObject * _Tuple_Type() { return ptr__Tuple_Type; } +PyTypeObject * _Type_Type() { return ptr__Type_Type; } + +#if PY_MAJOR_VERSION >= 2 +PyTypeObject * _Unicode_Type() { return ptr__Unicode_Type; } +#endif + +char *__Py_PackageContext() { return *ptr__Py_PackageContext; } + + +// +// wrap the Python Flag variables +// +int &_Py_DebugFlag() { return *ptr_Py_DebugFlag; } +int &_Py_InteractiveFlag() { return *ptr_Py_InteractiveFlag; } +int &_Py_OptimizeFlag() { return *ptr_Py_OptimizeFlag; } +int &_Py_NoSiteFlag() { return *ptr_Py_NoSiteFlag; } +int &_Py_TabcheckFlag() { return *ptr_Py_TabcheckFlag; } +int &_Py_VerboseFlag() { return *ptr_Py_VerboseFlag; } +#if PY_MAJOR_VERSION >= 2 +int &_Py_UnicodeFlag() { return *ptr_Py_UnicodeFlag; } +#endif + +void _XINCREF( PyObject *op ) +{ + // This function must match the contents of Py_XINCREF(op) + if( op == NULL ) + return; + +#ifdef Py_REF_DEBUG + (*ptr_Py_RefTotal)++; +#endif + (op)->ob_refcnt++; + +} + +void _XDECREF( PyObject *op ) +{ + // This function must match the contents of Py_XDECREF(op); + if( op == NULL ) + return; + +#ifdef Py_REF_DEBUG + (*ptr_Py_RefTotal)--; +#endif + + if (--(op)->ob_refcnt == 0) + _Py_Dealloc((PyObject *)(op)); +} + + +#else +#error "Can only delay load under Win32" +#endif + +#else + +// +// Duplicated these declarations from rangeobject.h which is missing the +// extern "C". This has been reported as a bug upto and include 2.1 +// +extern "C" DL_IMPORT(PyTypeObject) PyRange_Type; +extern "C" DL_IMPORT(PyObject *) PyRange_New(long, long, long, int); + + +//================================================================================ +// +// Map onto Macros +// +//================================================================================ + +// +// Wrap variables as function calls +// + +PyObject * _Exc_ArithmeticError() { return ::PyExc_ArithmeticError; } +PyObject * _Exc_AssertionError() { return ::PyExc_AssertionError; } +PyObject * _Exc_AttributeError() { return ::PyExc_AttributeError; } +PyObject * _Exc_EnvironmentError() { return ::PyExc_EnvironmentError; } +PyObject * _Exc_EOFError() { return ::PyExc_EOFError; } +PyObject * _Exc_Exception() { return ::PyExc_Exception; } +PyObject * _Exc_FloatingPointError() { return ::PyExc_FloatingPointError; } +PyObject * _Exc_ImportError() { return ::PyExc_ImportError; } +PyObject * _Exc_IndexError() { return ::PyExc_IndexError; } +PyObject * _Exc_IOError() { return ::PyExc_IOError; } +PyObject * _Exc_KeyboardInterrupt() { return ::PyExc_KeyboardInterrupt; } +PyObject * _Exc_KeyError() { return ::PyExc_KeyError; } +PyObject * _Exc_LookupError() { return ::PyExc_LookupError; } +PyObject * _Exc_MemoryError() { return ::PyExc_MemoryError; } +PyObject * _Exc_MemoryErrorInst() { return ::PyExc_MemoryErrorInst; } +PyObject * _Exc_NameError() { return ::PyExc_NameError; } +PyObject * _Exc_NotImplementedError() { return ::PyExc_NotImplementedError; } +PyObject * _Exc_OSError() { return ::PyExc_OSError; } +PyObject * _Exc_OverflowError() { return ::PyExc_OverflowError; } +PyObject * _Exc_RuntimeError() { return ::PyExc_RuntimeError; } +PyObject * _Exc_StandardError() { return ::PyExc_StandardError; } +PyObject * _Exc_SyntaxError() { return ::PyExc_SyntaxError; } +PyObject * _Exc_SystemError() { return ::PyExc_SystemError; } +PyObject * _Exc_SystemExit() { return ::PyExc_SystemExit; } +PyObject * _Exc_TypeError() { return ::PyExc_TypeError; } +PyObject * _Exc_ValueError() { return ::PyExc_ValueError; } +PyObject * _Exc_ZeroDivisionError() { return ::PyExc_ZeroDivisionError; } + +#ifdef MS_WINDOWS +PyObject * _Exc_WindowsError() { return ::PyExc_WindowsError; } +#endif + + +#if PY_MAJOR_VERSION >= 2 +PyObject * _Exc_IndentationError() { return ::PyExc_IndentationError; } +PyObject * _Exc_TabError() { return ::PyExc_TabError; } +PyObject * _Exc_UnboundLocalError() { return ::PyExc_UnboundLocalError; } +PyObject * _Exc_UnicodeError() { return ::PyExc_UnicodeError; } +#endif + + +// +// wrap items in Object.h +// +PyObject * _None() { return &::_Py_NoneStruct; } + +PyTypeObject * _Buffer_Type() { return &PyBuffer_Type; } +PyTypeObject * _CFunction_Type() { return &PyCFunction_Type; } +PyTypeObject * _Class_Type() { return &PyClass_Type; } +PyTypeObject * _CObject_Type() { return &PyCObject_Type; } +PyTypeObject * _Complex_Type() { return &PyComplex_Type; } +PyTypeObject * _Dict_Type() { return &PyDict_Type; } +PyTypeObject * _File_Type() { return &PyFile_Type; } +PyTypeObject * _Float_Type() { return &PyFloat_Type; } +PyTypeObject * _Function_Type() { return &PyFunction_Type; } +PyTypeObject * _Instance_Type() { return &PyInstance_Type; } +PyTypeObject * _Int_Type() { return &PyInt_Type; } +PyTypeObject * _List_Type() { return &PyList_Type; } +PyTypeObject * _Long_Type() { return &PyLong_Type; } +PyTypeObject * _Method_Type() { return &PyMethod_Type; } +PyTypeObject * _Module_Type() { return &PyModule_Type; } +PyTypeObject * _Range_Type() { return &PyRange_Type; } +PyTypeObject * _Slice_Type() { return &PySlice_Type; } +PyTypeObject * _String_Type() { return &PyString_Type; } +PyTypeObject * _TraceBack_Type() { return &PyTraceBack_Type; } +PyTypeObject * _Tuple_Type() { return &PyTuple_Type; } +PyTypeObject * _Type_Type() { return &PyType_Type; } + +#if PY_MAJOR_VERSION >= 2 +PyTypeObject * _Unicode_Type() { return &PyUnicode_Type; } +#endif + +// +// wrap flags +// +int &_Py_DebugFlag() { return Py_DebugFlag; } +int &_Py_InteractiveFlag(){ return Py_InteractiveFlag; } +int &_Py_OptimizeFlag() { return Py_OptimizeFlag; } +int &_Py_NoSiteFlag() { return Py_NoSiteFlag; } +int &_Py_TabcheckFlag() { return Py_TabcheckFlag; } +int &_Py_VerboseFlag() { return Py_VerboseFlag; } +#if PY_MAJOR_VERSION >= 2 +int &_Py_UnicodeFlag() { return Py_UnicodeFlag; } +#endif +char *__Py_PackageContext(){ return _Py_PackageContext; } + +// +// Needed to keep the abstactions for delayload interface +// +void _XINCREF( PyObject *op ) +{ + Py_XINCREF(op); +} + +void _XDECREF( PyObject *op ) +{ + Py_XDECREF(op); +} + +#endif +} diff --git a/src/extension/script/cxx/IndirectPythonInterface.hxx b/src/extension/script/cxx/IndirectPythonInterface.hxx new file mode 100644 index 000000000..e8fccf570 --- /dev/null +++ b/src/extension/script/cxx/IndirectPythonInterface.hxx @@ -0,0 +1,193 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_INDIRECT_PYTHON_INTERFACE__HXX__ +#define __CXX_INDIRECT_PYTHON_INTERFACE__HXX__ + +#include "CXX/WrapPython.h" + +namespace Py +{ +bool InitialisePythonIndirectInterface(); + +// +// Wrap Exception variables as function calls +// +PyObject * _Exc_Exception(); +PyObject * _Exc_StandardError(); +PyObject * _Exc_ArithmeticError(); +PyObject * _Exc_LookupError(); + +PyObject * _Exc_AssertionError(); +PyObject * _Exc_AttributeError(); +PyObject * _Exc_EOFError(); +PyObject * _Exc_FloatingPointError(); +PyObject * _Exc_EnvironmentError(); +PyObject * _Exc_IOError(); +PyObject * _Exc_OSError(); +PyObject * _Exc_ImportError(); +PyObject * _Exc_IndexError(); +PyObject * _Exc_KeyError(); +PyObject * _Exc_KeyboardInterrupt(); +PyObject * _Exc_MemoryError(); +PyObject * _Exc_NameError(); +PyObject * _Exc_OverflowError(); +PyObject * _Exc_RuntimeError(); +PyObject * _Exc_NotImplementedError(); +PyObject * _Exc_SyntaxError(); +PyObject * _Exc_SystemError(); +PyObject * _Exc_SystemExit(); +PyObject * _Exc_TypeError(); +PyObject * _Exc_ValueError(); +PyObject * _Exc_ZeroDivisionError(); +#ifdef MS_WINDOWS +PyObject * _Exc_WindowsError(); +#endif + +PyObject * _Exc_MemoryErrorInst(); + +#if PY_MAJOR_VERSION >= 2 +PyObject * _Exc_IndentationError(); +PyObject * _Exc_TabError(); +PyObject * _Exc_UnboundLocalError(); +PyObject * _Exc_UnicodeError(); +#endif + +// +// Wrap Object variables as function calls +// +PyObject * _None(); + + +// +// Wrap Type variables as function calls +// +PyTypeObject * _List_Type(); +bool _List_Check( PyObject *o ); + +PyTypeObject * _Buffer_Type(); +bool _Buffer_Check( PyObject *op ); + +PyTypeObject * _Class_Type(); +bool _Class_Check( PyObject *op ); + +PyTypeObject * _Instance_Type(); +bool _Instance_Check( PyObject *op ); + +PyTypeObject * _Method_Type(); +bool _Method_Check( PyObject *op ); + +PyTypeObject * _CObject_Type(); +bool _CObject_Check( PyObject *op ); + +PyTypeObject * _Complex_Type(); +bool _Complex_Check( PyObject *op ); + +PyTypeObject * _Dict_Type(); +bool _Dict_Check( PyObject *op ); + +PyTypeObject * _File_Type(); +bool _File_Check( PyObject *op ); + +PyTypeObject * _Float_Type(); +bool _Float_Check( PyObject *op ); + +PyTypeObject * _Frame_Type(); +bool _Frame_Check( PyObject *op ); + +PyTypeObject * _Function_Type(); +bool _Function_Check( PyObject *op ); + +PyTypeObject * _Int_Type(); +bool _Int_Check( PyObject *op ); + +PyTypeObject * _List_Type(); +bool _List_Check( PyObject *op ); + +PyTypeObject * _Long_Type(); +bool _Long_Check( PyObject *op ); + +PyTypeObject * _CFunction_Type(); +bool _CFunction_Check( PyObject *op ); + +PyTypeObject * _Module_Type(); +bool _Module_Check( PyObject *op ); + +PyTypeObject * _Type_Type(); +bool _Type_Check( PyObject *op ); + +PyTypeObject * _Range_Type(); +bool _Range_Check( PyObject *op ); + +PyTypeObject * _Slice_Type(); +bool _Slice_Check( PyObject *op ); + +PyTypeObject * _String_Type(); +bool _String_Check( PyObject *op ); + +PyTypeObject * _Unicode_Type(); +bool _Unicode_Check( PyObject *op ); + +PyTypeObject * _TraceBack_Type(); +bool _TraceBack_Check( PyObject *v ); + +PyTypeObject * _Tuple_Type(); +bool _Tuple_Check( PyObject *op ); + +#if PY_MAJOR_VERSION >= 2 +PyTypeObject * _Unicode_Type(); +bool _Unicode_Check( PyObject *op ); +#endif + +int &_Py_DebugFlag(); +int &_Py_InteractiveFlag(); +int &_Py_OptimizeFlag(); +int &_Py_NoSiteFlag(); +int &_Py_TabcheckFlag(); +int &_Py_VerboseFlag(); + +#if PY_MAJOR_VERSION >= 2 +int &_Py_UnicodeFlag(); +#endif + +void _XINCREF( PyObject *op ); +void _XDECREF( PyObject *op ); + +char *__Py_PackageContext(); +}; + +#endif // __CXX_INDIRECT_PYTHON_INTERFACE__HXX__ diff --git a/src/extension/script/cxx/Objects.hxx b/src/extension/script/cxx/Objects.hxx new file mode 100644 index 000000000..30dc085b8 --- /dev/null +++ b/src/extension/script/cxx/Objects.hxx @@ -0,0 +1,3019 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_Objects__h +#define __CXX_Objects__h + +#include "CXX/WrapPython.h" +#include "CXX/Version.hxx" +#include "CXX/Config.hxx" +#include "CXX/Exception.hxx" + +#include +#include STR_STREAM +#include +#include +#include +#include + +namespace Py +{ + typedef int sequence_index_type; // type of an index into a sequence + + // Forward declarations + class Object; + class Type; + template class SeqBase; + class String; + class List; + template class MapBase; + + // new_reference_to also overloaded below on Object + inline PyObject* new_reference_to(PyObject* p) + { + Py::_XINCREF(p); + return p; + } + + // returning Null() from an extension method triggers a + // Python exception + inline PyObject* Null() + { + return (static_cast(0)); + } + + //===========================================================================// + // class Object + // The purpose of this class is to serve as the most general kind of + // Python object, for the purpose of writing C++ extensions in Python + // Objects hold a PyObject* which they own. This pointer is always a + // valid pointer to a Python object. In children we must maintain this behavior. + // + // Instructions on how to make your own class MyType descended from Object: + // (0) Pick a base class, either Object or perhaps SeqBase or MapBase. + // This example assumes Object. + + // (1) Write a routine int MyType_Check (PyObject *) modeled after PyInt_Check, + // PyFloat_Check, etc. + + // (2) Add method accepts: + // virtual bool accepts (PyObject *pyob) const { + // return pyob && MyType_Check (pyob); + // } + + // (3) Include the following constructor and copy constructor + // + /* + explicit MyType (PyObject *pyob): Object(pyob) { + validate(); +} + + MyType(const Object& other): Object(other.ptr()) { + validate(); +} + */ + + // Alernate version for the constructor to allow for construction from owned pointers: + /* + explicit MyType (PyObject *pyob): Object(pyob) { + validate(); +} + */ + + // You may wish to add other constructors; see the classes below for examples. + // Each constructor must use "set" to set the pointer + // and end by validating the pointer you have created. + + // (4) Each class needs at least these two assignment operators: + /* + MyType& operator= (const Object& rhs) { + return (*this = *rhs); +} + + Mytype& operator= (PyObject* rhsp) { + if(ptr() == rhsp) return *this; + set(rhsp); + return *this; +} + */ + // Note on accepts: constructors call the base class + // version of a virtual when calling the base class constructor, + // so the test has to be done explicitly in a descendent. + + // If you are inheriting from PythonExtension to define an object + // note that it contains PythonExtension::check + // which you can use in accepts when writing a wrapper class. + // See Demo/range.h and Demo/range.cxx for an example. + + class Object + { + private: + // the pointer to the Python object + // Only Object sets this directly. + // The default constructor for Object sets it to Py_None and + // child classes must use "set" to set it + // + PyObject* p; + + protected: + + void set (PyObject* pyob, bool owned = false) + { + release(); + p = pyob; + if (!owned) + { + Py::_XINCREF (p); + } + validate(); + } + + void release () + { + Py::_XDECREF (p); + p = 0; + } + + void validate() + { + // release pointer if not the right type + if (! accepts (p)) + { + release (); + if(PyErr_Occurred()) + { // Error message already set + throw Exception(); + } + // Better error message if RTTI available +#if defined( _CPPRTTI ) || defined(__GNUG__) + std::string s("CXX : Error creating object of type "); + s += (typeid (*this)).name(); + throw TypeError (s); +#else + throw TypeError ("CXX: type error."); +#endif + } + } + + public: + // Constructor acquires new ownership of pointer unless explicitly told not to. + explicit Object (PyObject* pyob=Py::_None(), bool owned = false): p (pyob) + { + if(!owned) + { + Py::_XINCREF (p); + } + validate(); + } + + // Copy constructor acquires new ownership of pointer + Object (const Object& ob): p(ob.p) + { + Py::_XINCREF (p); + validate(); + } + + // Assignment acquires new ownership of pointer + Object& operator= (const Object& rhs) + { + set(rhs.p); + return *this; + } + + Object& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (rhsp); + return *this; + } + + // Destructor + virtual ~Object () + { + release (); + } + + // Loaning the pointer to others, retain ownership + PyObject* operator* () const + { + return p; + } + + // Explicit reference_counting changes + void increment_reference_count() + { + Py::_XINCREF(p); + } + + void decrement_reference_count() + { + // not allowed to commit suicide, however + if(reference_count() == 1) + throw RuntimeError("Object::decrement_reference_count error."); + Py::_XDECREF(p); + } + // Would like to call this pointer() but messes up STL in SeqBase + PyObject* ptr () const + { + return p; + } + + // + // Queries + // + + // Can pyob be used in this object's constructor? + virtual bool accepts (PyObject *pyob) const + { + return (pyob != 0); + } + + Py_ssize_t reference_count () const + { // the reference count + return p ? p->ob_refcnt : 0; + } + + Type type () const; // the type object associated with this one + + String str () const; // the str() representation + + std::string as_string() const; + + String repr () const; // the repr () representation + + List dir () const; // the dir() list + + bool hasAttr (const std::string& s) const + { + return PyObject_HasAttrString (p, const_cast(s.c_str())) ? true: false; + } + + Object getAttr (const std::string& s) const + { + return Object (PyObject_GetAttrString (p, const_cast(s.c_str())), true); + } + + Object getItem (const Object& key) const + { + return Object (PyObject_GetItem(p, *key), true); + } + + long hashValue () const + { + return PyObject_Hash (p); + } + + // + // int print (FILE* fp, int flags=Py_Print_RAW) + //{ + // return PyObject_Print (p, fp, flags); + //} + // + bool is(PyObject *pother) const + { // identity test + return p == pother; + } + + bool is(const Object& other) const + { // identity test + return p == other.p; + } + + bool isNone() const + { + return p == Py_None; + } + + bool isCallable () const + { + return PyCallable_Check (p) != 0; + } + + bool isInstance () const + { + return PyInstance_Check (p) != 0; + } + + bool isDict () const + { + return Py::_Dict_Check (p); + } + + bool isList () const + { + return Py::_List_Check (p); + } + + bool isMapping () const + { + return PyMapping_Check (p) != 0; + } + + bool isNumeric () const + { + return PyNumber_Check (p) != 0; + } + + bool isSequence () const + { + return PySequence_Check (p) != 0; + } + + bool isTrue () const + { + return PyObject_IsTrue (p) != 0; + } + + bool isType (const Type& t) const; + + bool isTuple() const + { + return Py::_Tuple_Check(p); + } + + bool isString() const + { + return Py::_String_Check(p) || Py::_Unicode_Check(p); + } + + bool isUnicode() const + { + return Py::_Unicode_Check(p); + } + + // Commands + void setAttr (const std::string& s, const Object& value) + { + if(PyObject_SetAttrString (p, const_cast(s.c_str()), *value) == -1) + throw AttributeError ("getAttr failed."); + } + + void delAttr (const std::string& s) + { + if(PyObject_DelAttrString (p, const_cast(s.c_str())) == -1) + throw AttributeError ("delAttr failed."); + } + + // PyObject_SetItem is too weird to be using from C++ + // so it is intentionally omitted. + + void delItem (const Object& key) + { + //if(PyObject_DelItem(p, *key) == -1) + // failed to link on Windows? + throw KeyError("delItem failed."); + } + // Equality and comparison use PyObject_Compare + + bool operator==(const Object& o2) const + { + int k = PyObject_Compare (p, *o2); + if (PyErr_Occurred()) throw Exception(); + return k == 0; + } + + bool operator!=(const Object& o2) const + { + int k = PyObject_Compare (p, *o2); + if (PyErr_Occurred()) throw Exception(); + return k != 0; + + } + + bool operator>=(const Object& o2) const + { + int k = PyObject_Compare (p, *o2); + if (PyErr_Occurred()) throw Exception(); + return k >= 0; + } + + bool operator<=(const Object& o2) const + { + int k = PyObject_Compare (p, *o2); + if (PyErr_Occurred()) throw Exception(); + return k <= 0; + } + + bool operator<(const Object& o2) const + { + int k = PyObject_Compare (p, *o2); + if (PyErr_Occurred()) throw Exception(); + return k < 0; + } + + bool operator>(const Object& o2) const + { + int k = PyObject_Compare (p, *o2); + if (PyErr_Occurred()) throw Exception(); + return k > 0; + } + }; + // End of class Object + inline PyObject* new_reference_to(const Object& g) + { + PyObject* p = g.ptr(); + Py::_XINCREF(p); + return p; + } + + // Nothing() is what an extension method returns if + // there is no other return value. + inline Object Nothing() + { + return Object(Py::_None()); + } + + // Python special None value + inline Object None() + { + return Object(Py::_None()); + } + + // TMM: 31May'01 - Added the #ifndef so I can exlude iostreams. +#ifndef CXX_NO_IOSTREAMS + std::ostream& operator<< (std::ostream& os, const Object& ob); +#endif + + // Class Type + class Type: public Object + { + public: + explicit Type (PyObject* pyob, bool owned = false): Object(pyob, owned) + { + validate(); + } + + Type (const Object& ob): Object(*ob) + { + validate(); + } + + Type(const Type& t): Object(t) + { + validate(); + } + + Type& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + Type& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (rhsp); + return *this; + } + virtual bool accepts (PyObject *pyob) const + { + return pyob && Py::_Type_Check (pyob); + } + }; + + + // + // Convert an owned Python pointer into a CXX Object + // + inline Object asObject (PyObject *p) + { + return Object(p, true); + } + + + + + // =============================================== + // class Int + class Int: public Object + { + public: + // Constructor + Int (PyObject *pyob, bool owned = false): Object (pyob, owned) + { + validate(); + } + + Int (const Int& ob): Object(*ob) + { + validate(); + } + + // create from long + Int (long v = 0L): Object(PyInt_FromLong(v), true) + { + validate(); + } + +#ifdef HAVE_LONG_LONG + // create from long long + Int (PY_LONG_LONG v): Object(PyLong_FromLongLong(v), true) + { + validate(); + } + // create from unsigned long long + Int (unsigned PY_LONG_LONG v): Object(PyLong_FromUnsignedLongLong(v), true) + { + validate(); + } +#endif + + // create from int + Int (int v) + { + long w = v; + set(PyInt_FromLong(w), true); + validate(); + } + + // create from bool + Int (bool v) + { + long w = v ? 1 : 0; + set(PyInt_FromLong(w), true); + validate(); + } + + explicit Int (const Object& ob) + { + set(PyNumber_Int(*ob), true); + validate(); + } + + // Assignment acquires new ownership of pointer + + Int& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + Int& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (PyNumber_Int(rhsp), true); + return *this; + } + + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && Py::_Int_Check (pyob); + } + + // convert to long + operator long() const + { + return PyInt_AsLong (ptr()); + } + +#ifdef HAVE_LONG_LONG + // convert to long long + PY_LONG_LONG asLongLong() const + { + return PyLong_AsLongLong (ptr()); + } + // convert to unsigned long long + unsigned PY_LONG_LONG asUnsignedLongLong() const + { + return PyLong_AsUnsignedLongLong (ptr()); + } +#endif + + // assign from an int + Int& operator= (int v) + { + set (PyInt_FromLong (long(v)), true); + return *this; + } + + // assign from long + Int& operator= (long v) + { + set (PyInt_FromLong (v), true); + return *this; + } + +#ifdef HAVE_LONG_LONG + // assign from long long + Int& operator= (PY_LONG_LONG v) + { + set (PyLong_FromLongLong (v), true); + return *this; + } + // assign from unsigned long long + Int& operator= (unsigned PY_LONG_LONG v) + { + set (PyLong_FromUnsignedLongLong (v), true); + return *this; + } +#endif + }; + + // =============================================== + // class Long + class Long: public Object + { + public: + // Constructor + explicit Long (PyObject *pyob, bool owned = false): Object (pyob, owned) + { + validate(); + } + + Long (const Long& ob): Object(ob.ptr()) + { + validate(); + } + + // create from long + explicit Long (long v = 0L) + : Object(PyLong_FromLong(v), true) + { + validate(); + } + // create from unsigned long + explicit Long (unsigned long v) + : Object(PyLong_FromUnsignedLong(v), true) + { + validate(); + } + // create from int + explicit Long (int v) + : Object(PyLong_FromLong(static_cast(v)), true) + { + validate(); + } + + // try to create from any object + Long (const Object& ob) + : Object(PyNumber_Long(*ob), true) + { + validate(); + } + + // Assignment acquires new ownership of pointer + + Long& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + Long& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (PyNumber_Long(rhsp), true); + return *this; + } + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && Py::_Long_Check (pyob); + } + // convert to long + operator long() const + { + return PyLong_AsLong (ptr()); + } + // convert to unsigned + operator unsigned long() const + { + return PyLong_AsUnsignedLong (ptr()); + } + operator double() const + { + return PyLong_AsDouble (ptr()); + } + // assign from an int + Long& operator= (int v) + { + set(PyLong_FromLong (long(v)), true); + return *this; + } + // assign from long + Long& operator= (long v) + { + set(PyLong_FromLong (v), true); + return *this; + } + // assign from unsigned long + Long& operator= (unsigned long v) + { + set(PyLong_FromUnsignedLong (v), true); + return *this; + } + }; + +#ifdef HAVE_LONG_LONG + // =============================================== + // class LongLong + class LongLong: public Object + { + public: + // Constructor + explicit LongLong (PyObject *pyob, bool owned = false): Object (pyob, owned) + { + validate(); + } + + LongLong (const LongLong& ob): Object(ob.ptr()) + { + validate(); + } + // create from long long + explicit LongLong (long long v = 0L) + : Object(PyLong_FromLongLong(v), true) + { + validate(); + } + // create from unsigned long long + explicit LongLong (unsigned long long v) + : Object(PyLong_FromUnsignedLongLong(v), true) + { + validate(); + } + // create from long + explicit LongLong (long v) + : Object(PyLong_FromLongLong(v), true) + { + validate(); + } + // create from unsigned long + explicit LongLong (unsigned long v) + : Object(PyLong_FromUnsignedLongLong(v), true) + { + validate(); + } + // create from int + explicit LongLong (int v) + : Object(PyLong_FromLongLong(static_cast(v)), true) + { + validate(); + } + + // try to create from any object + LongLong (const Object& ob) + : Object(PyNumber_Long(*ob), true) + { + validate(); + } + + // Assignment acquires new ownership of pointer + + LongLong& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + LongLong& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (PyNumber_Long(rhsp), true); + return *this; + } + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && Py::_Long_Check (pyob); + } + // convert to long long + operator long long() const + { + return PyLong_AsLongLong (ptr()); + } + // convert to unsigned long + operator unsigned long long() const + { + return PyLong_AsUnsignedLongLong (ptr()); + } + // convert to long + operator long() const + { + return PyLong_AsLong (ptr()); + } + // convert to unsigned + operator unsigned long() const + { + return PyLong_AsUnsignedLong (ptr()); + } + operator double() const + { + return PyLong_AsDouble (ptr()); + } + // assign from an int + LongLong& operator= (int v) + { + set(PyLong_FromLongLong (long(v)), true); + return *this; + } + // assign from long long + LongLong& operator= (long long v) + { + set(PyLong_FromLongLong (v), true); + return *this; + } + // assign from unsigned long long + LongLong& operator= (unsigned long long v) + { + set(PyLong_FromUnsignedLongLong (v), true); + return *this; + } + // assign from long + LongLong& operator= (long v) + { + set(PyLong_FromLongLong (v), true); + return *this; + } + // assign from unsigned long + LongLong& operator= (unsigned long v) + { + set(PyLong_FromUnsignedLongLong (v), true); + return *this; + } + }; +#endif + + // =============================================== + // class Float + // + class Float: public Object + { + public: + // Constructor + explicit Float (PyObject *pyob, bool owned = false): Object(pyob, owned) + { + validate(); + } + + Float (const Float& f): Object(f) + { + validate(); + } + + // make from double + explicit Float (double v=0.0) + : Object(PyFloat_FromDouble (v), true) + { + validate(); + } + + // try to make from any object + Float (const Object& ob) + : Object(PyNumber_Float(*ob), true) + { + validate(); + } + + Float& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + Float& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (PyNumber_Float(rhsp), true); + return *this; + } + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && Py::_Float_Check (pyob); + } + // convert to double + operator double () const + { + return PyFloat_AsDouble (ptr()); + } + // assign from a double + Float& operator= (double v) + { + set(PyFloat_FromDouble (v), true); + return *this; + } + // assign from an int + Float& operator= (int v) + { + set(PyFloat_FromDouble (double(v)), true); + return *this; + } + // assign from long + Float& operator= (long v) + { + set(PyFloat_FromDouble (double(v)), true); + return *this; + } + // assign from an Int + Float& operator= (const Int& iob) + { + set(PyFloat_FromDouble (double(long(iob))), true); + return *this; + } + }; + + // =============================================== + // class Complex + class Complex: public Object + { + public: + // Constructor + explicit Complex (PyObject *pyob, bool owned = false): Object(pyob, owned) + { + validate(); + } + + Complex (const Complex& f): Object(f) + { + validate(); + } + + // make from double + explicit Complex (double v=0.0, double w=0.0) + :Object(PyComplex_FromDoubles (v, w), true) + { + validate(); + } + + Complex& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + Complex& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (rhsp); + return *this; + } + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && Py::_Complex_Check (pyob); + } + // convert to Py_complex + operator Py_complex () const + { + return PyComplex_AsCComplex (ptr()); + } + // assign from a Py_complex + Complex& operator= (const Py_complex& v) + { + set(PyComplex_FromCComplex (v), true); + return *this; + } + // assign from a double + Complex& operator= (double v) + { + set(PyComplex_FromDoubles (v, 0.0), true); + return *this; + } + // assign from an int + Complex& operator= (int v) + { + set(PyComplex_FromDoubles (double(v), 0.0), true); + return *this; + } + // assign from long + Complex& operator= (long v) + { + set(PyComplex_FromDoubles (double(v), 0.0), true); + return *this; + } + // assign from an Int + Complex& operator= (const Int& iob) + { + set(PyComplex_FromDoubles (double(long(iob)), 0.0), true); + return *this; + } + + double real() const + { + return PyComplex_RealAsDouble(ptr()); + } + + double imag() const + { + return PyComplex_ImagAsDouble(ptr()); + } + }; + // Sequences + // Sequences are here represented as sequences of items of type T. + // The base class SeqBase represents that. + // In basic Python T is always "Object". + + // seqref is what you get if you get elements from a non-const SeqBase. + // Note: seqref could probably be a nested class in SeqBase but that might stress + // some compilers needlessly. Simlarly for mapref later. + + // While this class is not intended for enduser use, it needs some public + // constructors for the benefit of the STL. + + // See Scott Meyer's More Essential C++ for a description of proxies. + // This application is even more complicated. We are doing an unusual thing + // in having a double proxy. If we want the STL to work + // properly we have to compromise by storing the rvalue inside. The + // entire Object API is repeated so that things like s[i].isList() will + // work properly. + + // Still, once in a while a weird compiler message may occur using expressions like x[i] + // Changing them to Object(x[i]) helps the compiler to understand that the + // conversion of a seqref to an Object is wanted. + + template + class seqref + { + protected: + SeqBase& s; // the sequence + int offset; // item number + T the_item; // lvalue + public: + + seqref (SeqBase& seq, sequence_index_type j) + : s(seq), offset(j), the_item (s.getItem(j)) + {} + + seqref (const seqref& range) + : s(range.s), offset(range.offset), the_item(range.the_item) + {} + + // TMM: added this seqref ctor for use with STL algorithms + seqref (Object& obj) + : s(dynamic_cast< SeqBase&>(obj)) + , offset( NULL ) + , the_item(s.getItem(offset)) + {} + ~seqref() + {} + + operator T() const + { // rvalue + return the_item; + } + + seqref& operator=(const seqref& rhs) + { //used as lvalue + the_item = rhs.the_item; + s.setItem(offset, the_item); + return *this; + } + + seqref& operator=(const T& ob) + { // used as lvalue + the_item = ob; + s.setItem(offset, ob); + return *this; + } + + // forward everything else to the item + PyObject* ptr () const + { + return the_item.ptr(); + } + + int reference_count () const + { // the reference count + return the_item.reference_count(); + } + + Type type () const + { + return the_item.type(); + } + + String str () const; + + String repr () const; + + bool hasAttr (const std::string& attr_name) const + { + return the_item.hasAttr(attr_name); + } + + Object getAttr (const std::string& attr_name) const + { + return the_item.getAttr(attr_name); + } + + Object getItem (const Object& key) const + { + return the_item.getItem(key); + } + + long hashValue () const + { + return the_item.hashValue(); + } + + bool isCallable () const + { + return the_item.isCallable(); + } + + bool isInstance () const + { + return the_item.isInstance(); + } + + bool isDict () const + { + return the_item.isDict(); + } + + bool isList () const + { + return the_item.isList(); + } + + bool isMapping () const + { + return the_item.isMapping(); + } + + bool isNumeric () const + { + return the_item.isNumeric(); + } + + bool isSequence () const + { + return the_item.isSequence(); + } + + bool isTrue () const + { + return the_item.isTrue(); + } + + bool isType (const Type& t) const + { + return the_item.isType (t); + } + + bool isTuple() const + { + return the_item.isTuple(); + } + + bool isString() const + { + return the_item.isString(); + } + // Commands + void setAttr (const std::string& attr_name, const Object& value) + { + the_item.setAttr(attr_name, value); + } + + void delAttr (const std::string& attr_name) + { + the_item.delAttr(attr_name); + } + + void delItem (const Object& key) + { + the_item.delItem(key); + } + + bool operator==(const Object& o2) const + { + return the_item == o2; + } + + bool operator!=(const Object& o2) const + { + return the_item != o2; + } + + bool operator>=(const Object& o2) const + { + return the_item >= o2; + } + + bool operator<=(const Object& o2) const + { + return the_item <= o2; + } + + bool operator<(const Object& o2) const + { + return the_item < o2; + } + + bool operator>(const Object& o2) const + { + return the_item > o2; + } + }; // end of seqref + + + // class SeqBase + // ...the base class for all sequence types + + template + class SeqBase: public Object + { + public: + // STL definitions + typedef size_t size_type; + typedef seqref reference; + typedef T const_reference; + typedef seqref* pointer; + typedef int difference_type; + typedef T value_type; // TMM: 26Jun'01 + + virtual size_type max_size() const + { + return std::string::npos; // ? + } + + virtual size_type capacity() const + { + return size(); + } + + virtual void swap(SeqBase& c) + { + SeqBase temp = c; + c = ptr(); + set(temp.ptr()); + } + + virtual size_type size () const + { + return PySequence_Length (ptr()); + } + + explicit SeqBase () + :Object(PyTuple_New(0), true) + { + validate(); + } + + explicit SeqBase (PyObject* pyob, bool owned=false) + : Object(pyob, owned) + { + validate(); + } + + SeqBase (const Object& ob): Object(ob) + { + validate(); + } + + // Assignment acquires new ownership of pointer + + SeqBase& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + SeqBase& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (rhsp); + return *this; + } + + virtual bool accepts (PyObject *pyob) const + { + return pyob && PySequence_Check (pyob); + } + + size_type length () const + { + return PySequence_Length (ptr()); + } + + // Element access + const T operator[](sequence_index_type index) const + { + return getItem(index); + } + + seqref operator[](sequence_index_type index) + { + return seqref(*this, index); + } + + virtual T getItem (sequence_index_type i) const + { + return T(asObject(PySequence_GetItem (ptr(), i))); + } + + virtual void setItem (sequence_index_type i, const T& ob) + { + if (PySequence_SetItem (ptr(), i, *ob) == -1) + { + throw Exception(); + } + } + + SeqBase repeat (int count) const + { + return SeqBase (PySequence_Repeat (ptr(), count), true); + } + + SeqBase concat (const SeqBase& other) const + { + return SeqBase (PySequence_Concat(ptr(), *other), true); + } + + // more STL compatability + const T front () const + { + return getItem(0); + } + + seqref front() + { + return seqref(this, 0); + } + + const T back () const + { + return getItem(size()-1); + } + + seqref back() + { + return seqref(this, size()-1); + } + + void verify_length(size_type required_size) const + { + if (size() != required_size) + throw IndexError ("Unexpected SeqBase length."); + } + + void verify_length(size_type min_size, size_type max_size) const + { + size_type n = size(); + if (n < min_size || n > max_size) + throw IndexError ("Unexpected SeqBase length."); + } + + class iterator + : public random_access_iterator_parent(seqref) + { + protected: + friend class SeqBase; + SeqBase* seq; + int count; + + public: + ~iterator () + {} + + iterator () + : seq( 0 ) + , count( 0 ) + {} + + iterator (SeqBase* s, int where) + : seq( s ) + , count( where ) + {} + + iterator (const iterator& other) + : seq( other.seq ) + , count( other.count ) + {} + + bool eql (const iterator& other) const + { + return (*seq == *other.seq) && (count == other.count); + } + + bool neq (const iterator& other) const + { + return (*seq != *other.seq) || (count != other.count); + } + + bool lss (const iterator& other) const + { + return (count < other.count); + } + + bool gtr (const iterator& other) const + { + return (count > other.count); + } + + bool leq (const iterator& other) const + { + return (count <= other.count); + } + + bool geq (const iterator& other) const + { + return (count >= other.count); + } + + seqref operator*() + { + return seqref(*seq, count); + } + + seqref operator[] (sequence_index_type i) + { + return seqref(*seq, count + i); + } + + iterator& operator=(const iterator& other) + { + if (this == &other) return *this; + seq = other.seq; + count = other.count; + return *this; + } + + iterator operator+(int n) const + { + return iterator(seq, count + n); + } + + iterator operator-(int n) const + { + return iterator(seq, count - n); + } + + iterator& operator+=(int n) + { + count = count + n; + return *this; + } + + iterator& operator-=(int n) + { + count = count - n; + return *this; + } + + int operator-(const iterator& other) const + { + if (*seq != *other.seq) + throw RuntimeError ("SeqBase::iterator comparison error"); + return count - other.count; + } + + // prefix ++ + iterator& operator++ () + { count++; return *this;} + // postfix ++ + iterator operator++ (int) + { return iterator(seq, count++);} + // prefix -- + iterator& operator-- () + { count--; return *this;} + // postfix -- + iterator operator-- (int) + { return iterator(seq, count--);} + + std::string diagnose() const + { + std::OSTRSTREAM oss; + oss << "iterator diagnosis " << seq << ", " << count << std::ends; + return std::string(oss.str()); + } + }; // end of class SeqBase::iterator + + iterator begin () + { + return iterator(this, 0); + } + + iterator end () + { + return iterator(this, length()); + } + + class const_iterator + : public random_access_iterator_parent(const Object) + { + protected: + friend class SeqBase; + const SeqBase* seq; + sequence_index_type count; + + public: + ~const_iterator () + {} + + const_iterator () + : seq( 0 ) + , count( 0 ) + {} + + const_iterator (const SeqBase* s, int where) + : seq( s ) + , count( where ) + {} + + const_iterator(const const_iterator& other) + : seq( other.seq ) + , count( other.count ) + {} + + const T operator*() const + { + return seq->getItem(count); + } + + const T operator[] (sequence_index_type i) const + { + return seq->getItem(count + i); + } + + const_iterator& operator=(const const_iterator& other) + { + if (this == &other) return *this; + seq = other.seq; + count = other.count; + return *this; + } + + const_iterator operator+(int n) const + { + return const_iterator(seq, count + n); + } + + bool eql (const const_iterator& other) const + { + return (*seq == *other.seq) && (count == other.count); + } + + bool neq (const const_iterator& other) const + { + return (*seq != *other.seq) || (count != other.count); + } + + bool lss (const const_iterator& other) const + { + return (count < other.count); + } + + bool gtr (const const_iterator& other) const + { + return (count > other.count); + } + + bool leq (const const_iterator& other) const + { + return (count <= other.count); + } + + bool geq (const const_iterator& other) const + { + return (count >= other.count); + } + + const_iterator operator-(int n) + { + return const_iterator(seq, count - n); + } + + const_iterator& operator+=(int n) + { + count = count + n; + return *this; + } + + const_iterator& operator-=(int n) + { + count = count - n; + return *this; + } + + int operator-(const const_iterator& other) const + { + if (*seq != *other.seq) + throw RuntimeError ("SeqBase::const_iterator::- error"); + return count - other.count; + } + // prefix ++ + const_iterator& operator++ () + { count++; return *this;} + // postfix ++ + const_iterator operator++ (int) + { return const_iterator(seq, count++);} + // prefix -- + const_iterator& operator-- () + { count--; return *this;} + // postfix -- + const_iterator operator-- (int) + { return const_iterator(seq, count--);} + }; // end of class SeqBase::const_iterator + + const_iterator begin () const + { + return const_iterator(this, 0); + } + + const_iterator end () const + { + return const_iterator(this, length()); + } + }; + + // Here's an important typedef you might miss if reading too fast... + typedef SeqBase Sequence; + + template bool operator==(const EXPLICIT_TYPENAME SeqBase::iterator& left, const EXPLICIT_TYPENAME SeqBase::iterator& right); + template bool operator!=(const EXPLICIT_TYPENAME SeqBase::iterator& left, const EXPLICIT_TYPENAME SeqBase::iterator& right); + template bool operator< (const EXPLICIT_TYPENAME SeqBase::iterator& left, const EXPLICIT_TYPENAME SeqBase::iterator& right); + template bool operator> (const EXPLICIT_TYPENAME SeqBase::iterator& left, const EXPLICIT_TYPENAME SeqBase::iterator& right); + template bool operator<=(const EXPLICIT_TYPENAME SeqBase::iterator& left, const EXPLICIT_TYPENAME SeqBase::iterator& right); + template bool operator>=(const EXPLICIT_TYPENAME SeqBase::iterator& left, const EXPLICIT_TYPENAME SeqBase::iterator& right); + + template bool operator==(const EXPLICIT_TYPENAME SeqBase::const_iterator& left, const EXPLICIT_TYPENAME SeqBase::const_iterator& right); + template bool operator!=(const EXPLICIT_TYPENAME SeqBase::const_iterator& left, const EXPLICIT_TYPENAME SeqBase::const_iterator& right); + template bool operator< (const EXPLICIT_TYPENAME SeqBase::const_iterator& left, const EXPLICIT_TYPENAME SeqBase::const_iterator& right); + template bool operator> (const EXPLICIT_TYPENAME SeqBase::const_iterator& left, const EXPLICIT_TYPENAME SeqBase::const_iterator& right); + template bool operator<=(const EXPLICIT_TYPENAME SeqBase::const_iterator& left, const EXPLICIT_TYPENAME SeqBase::const_iterator& right); + template bool operator>=(const EXPLICIT_TYPENAME SeqBase::const_iterator& left, const EXPLICIT_TYPENAME SeqBase::const_iterator& right); + + + extern bool operator==(const Sequence::iterator& left, const Sequence::iterator& right); + extern bool operator!=(const Sequence::iterator& left, const Sequence::iterator& right); + extern bool operator< (const Sequence::iterator& left, const Sequence::iterator& right); + extern bool operator> (const Sequence::iterator& left, const Sequence::iterator& right); + extern bool operator<=(const Sequence::iterator& left, const Sequence::iterator& right); + extern bool operator>=(const Sequence::iterator& left, const Sequence::iterator& right); + + extern bool operator==(const Sequence::const_iterator& left, const Sequence::const_iterator& right); + extern bool operator!=(const Sequence::const_iterator& left, const Sequence::const_iterator& right); + extern bool operator< (const Sequence::const_iterator& left, const Sequence::const_iterator& right); + extern bool operator> (const Sequence::const_iterator& left, const Sequence::const_iterator& right); + extern bool operator<=(const Sequence::const_iterator& left, const Sequence::const_iterator& right); + extern bool operator>=(const Sequence::const_iterator& left, const Sequence::const_iterator& right); + + // ================================================== + // class Char + // Python strings return strings as individual elements. + // I'll try having a class Char which is a String of length 1 + // + typedef std::basic_string unicodestring; + extern Py_UNICODE unicode_null_string[1]; + + class Char: public Object + { + public: + explicit Char (PyObject *pyob, bool owned = false): Object(pyob, owned) + { + validate(); + } + + Char (const Object& ob): Object(ob) + { + validate(); + } + + Char (const std::string& v = "") + :Object(PyString_FromStringAndSize (const_cast(v.c_str()),1), true) + { + validate(); + } + + Char (char v) + : Object(PyString_FromStringAndSize (&v, 1), true) + { + validate(); + } + + Char (Py_UNICODE v) + : Object(PyUnicode_FromUnicode (&v, 1), true) + { + validate(); + } + // Assignment acquires new ownership of pointer + Char& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + Char& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (rhsp); + return *this; + } + + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && (Py::_String_Check(pyob) || Py::_Unicode_Check(pyob)) && PySequence_Length (pyob) == 1; + } + + // Assignment from C string + Char& operator= (const std::string& v) + { + set(PyString_FromStringAndSize (const_cast(v.c_str()),1), true); + return *this; + } + + Char& operator= (char v) + { + set(PyString_FromStringAndSize (&v, 1), true); + return *this; + } + + Char& operator= (const unicodestring& v) + { + set(PyUnicode_FromUnicode (const_cast(v.data()),1), true); + return *this; + } + + Char& operator= (Py_UNICODE v) + { + set(PyUnicode_FromUnicode (&v, 1), true); + return *this; + } + + // Conversion + operator String() const; + + operator std::string () const + { + return std::string(PyString_AsString (ptr())); + } + }; + + class String: public SeqBase + { + public: + virtual size_type capacity() const + { + return max_size(); + } + + explicit String (PyObject *pyob, bool owned = false): SeqBase(pyob, owned) + { + validate(); + } + + String (const Object& ob): SeqBase(ob) + { + validate(); + } + + String() + : SeqBase( PyString_FromStringAndSize( "", 0 ), true ) + { + validate(); + } + + String( const std::string& v ) + : SeqBase( PyString_FromStringAndSize( const_cast(v.data()), + static_cast( v.length() ) ), true ) + { + validate(); + } + + String( const char *s, const char *encoding, const char *error="strict" ) + : SeqBase( PyUnicode_Decode( s, strlen( s ), encoding, error ), true ) + { + validate(); + } + + String( const char *s, int len, const char *encoding, const char *error="strict" ) + : SeqBase( PyUnicode_Decode( s, len, encoding, error ), true ) + { + validate(); + } + + String( const std::string &s, const char *encoding, const char *error="strict" ) + : SeqBase( PyUnicode_Decode( s.c_str(), s.length(), encoding, error ), true ) + { + validate(); + } + + String( const std::string& v, std::string::size_type vsize ) + : SeqBase(PyString_FromStringAndSize( const_cast(v.data()), + static_cast( vsize ) ), true) + { + validate(); + } + + String( const char *v, int vsize ) + : SeqBase(PyString_FromStringAndSize( const_cast(v), vsize ), true ) + { + validate(); + } + + String( const char* v ) + : SeqBase( PyString_FromString( v ), true ) + { + validate(); + } + + // Assignment acquires new ownership of pointer + String& operator= ( const Object& rhs ) + { + return *this = *rhs; + } + + String& operator= (PyObject* rhsp) + { + if( ptr() == rhsp ) + return *this; + set (rhsp); + return *this; + } + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && (Py::_String_Check(pyob) || Py::_Unicode_Check(pyob)); + } + + // Assignment from C string + String& operator= (const std::string& v) + { + set( PyString_FromStringAndSize( const_cast( v.data() ), + static_cast( v.length() ) ), true ); + return *this; + } + String& operator= (const unicodestring& v) + { + set( PyUnicode_FromUnicode( const_cast( v.data() ), + static_cast( v.length() ) ), true ); + return *this; + } + + + // Encode + String encode( const char *encoding, const char *error="strict" ) + { + if( isUnicode() ) + { + return String( PyUnicode_AsEncodedString( ptr(), encoding, error ) ); + } + else + { + return String( PyString_AsEncodedObject( ptr(), encoding, error ) ); + } + } + + String decode( const char *encoding, const char *error="strict" ) + { + return Object( PyString_AsDecodedObject( ptr(), encoding, error ) ); + } + + // Queries + virtual size_type size () const + { + if( isUnicode() ) + { + return static_cast( PyUnicode_GET_SIZE (ptr()) ); + } + else + { + return static_cast( PyString_Size (ptr()) ); + } + } + + operator std::string () const + { + return as_std_string(); + } + + std::string as_std_string() const + { + if( isUnicode() ) + { + throw TypeError("cannot return std::string from Unicode object"); + } + else + { + return std::string( PyString_AsString( ptr() ), static_cast( PyString_Size( ptr() ) ) ); + } + } + + unicodestring as_unicodestring() const + { + if( isUnicode() ) + { + return unicodestring( PyUnicode_AS_UNICODE( ptr() ), + static_cast( PyUnicode_GET_SIZE( ptr() ) ) ); + } + else + { + throw TypeError("can only return unicodestring from Unicode object"); + } + } + }; + + // ================================================== + // class Tuple + class Tuple: public Sequence + { + public: + virtual void setItem (sequence_index_type offset, const Object&ob) + { + // note PyTuple_SetItem is a thief... + if(PyTuple_SetItem (ptr(), offset, new_reference_to(ob)) == -1) + { + throw Exception(); + } + } + + // Constructor + explicit Tuple (PyObject *pyob, bool owned = false): Sequence (pyob, owned) + { + validate(); + } + + Tuple (const Object& ob): Sequence(ob) + { + validate(); + } + + // New tuple of a given size + explicit Tuple (int size = 0) + { + set(PyTuple_New (size), true); + validate (); + for (sequence_index_type i=0; i < size; i++) + { + if(PyTuple_SetItem (ptr(), i, new_reference_to(Py::_None())) == -1) + { + throw Exception(); + } + } + } + // Tuple from any sequence + explicit Tuple (const Sequence& s) + { + sequence_index_type limit( sequence_index_type( s.length() ) ); + + set(PyTuple_New (limit), true); + validate(); + + for(sequence_index_type i=0; i < limit; i++) + { + if(PyTuple_SetItem (ptr(), i, new_reference_to(s[i])) == -1) + { + throw Exception(); + } + } + } + // Assignment acquires new ownership of pointer + + Tuple& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + Tuple& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (rhsp); + return *this; + } + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && Py::_Tuple_Check (pyob); + } + + Tuple getSlice (int i, int j) const + { + return Tuple (PySequence_GetSlice (ptr(), i, j), true); + } + + }; + + // ================================================== + // class List + + class List: public Sequence + { + public: + // Constructor + explicit List (PyObject *pyob, bool owned = false): Sequence(pyob, owned) + { + validate(); + } + List (const Object& ob): Sequence(ob) + { + validate(); + } + // Creation at a fixed size + List (int size = 0) + { + set(PyList_New (size), true); + validate(); + for (sequence_index_type i=0; i < size; i++) + { + if(PyList_SetItem (ptr(), i, new_reference_to(Py::_None())) == -1) + { + throw Exception(); + } + } + } + + // List from a sequence + List (const Sequence& s): Sequence() + { + int n = (int)s.length(); + set(PyList_New (n), true); + validate(); + for (sequence_index_type i=0; i < n; i++) + { + if(PyList_SetItem (ptr(), i, new_reference_to(s[i])) == -1) + { + throw Exception(); + } + } + } + + virtual size_type capacity() const + { + return max_size(); + } + // Assignment acquires new ownership of pointer + + List& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + List& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (rhsp); + return *this; + } + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && Py::_List_Check (pyob); + } + + List getSlice (int i, int j) const + { + return List (PyList_GetSlice (ptr(), i, j), true); + } + + void setSlice (int i, int j, const Object& v) + { + if(PyList_SetSlice (ptr(), i, j, *v) == -1) + { + throw Exception(); + } + } + + void append (const Object& ob) + { + if(PyList_Append (ptr(), *ob) == -1) + { + throw Exception(); + } + } + + void insert (int i, const Object& ob) + { + if(PyList_Insert (ptr(), i, *ob) == -1) + { + throw Exception(); + } + } + + void sort () + { + if(PyList_Sort(ptr()) == -1) + { + throw Exception(); + } + } + + void reverse () + { + if(PyList_Reverse(ptr()) == -1) + { + throw Exception(); + } + } + }; + + + // Mappings + // ================================================== + template + class mapref + { + protected: + MapBase& s; // the map + Object key; // item key + T the_item; + + public: + mapref (MapBase& map, const std::string& k) + : s(map), the_item() + { + key = String(k); + if(map.hasKey(key)) the_item = map.getItem(key); + } + + mapref (MapBase& map, const Object& k) + : s(map), key(k), the_item() + { + if(map.hasKey(key)) the_item = map.getItem(key); + } + + virtual ~mapref() + {} + + // MapBase stuff + // lvalue + mapref& operator=(const mapref& other) + { + if(this == &other) return *this; + the_item = other.the_item; + s.setItem(key, other.the_item); + return *this; + } + + mapref& operator= (const T& ob) + { + the_item = ob; + s.setItem (key, ob); + return *this; + } + + // rvalue + operator T() const + { + return the_item; + } + + // forward everything else to the_item + PyObject* ptr () const + { + return the_item.ptr(); + } + + int reference_count () const + { // the mapref count + return the_item.reference_count(); + } + + Type type () const + { + return the_item.type(); + } + + String str () const + { + return the_item.str(); + } + + String repr () const + { + return the_item.repr(); + } + + bool hasAttr (const std::string& attr_name) const + { + return the_item.hasAttr(attr_name); + } + + Object getAttr (const std::string& attr_name) const + { + return the_item.getAttr(attr_name); + } + + Object getItem (const Object& k) const + { + return the_item.getItem(k); + } + + long hashValue () const + { + return the_item.hashValue(); + } + + bool isCallable () const + { + return the_item.isCallable(); + } + + bool isInstance () const + { + return the_item.isInstance(); + } + + bool isList () const + { + return the_item.isList(); + } + + bool isMapping () const + { + return the_item.isMapping(); + } + + bool isNumeric () const + { + return the_item.isNumeric(); + } + + bool isSequence () const + { + return the_item.isSequence(); + } + + bool isTrue () const + { + return the_item.isTrue(); + } + + bool isType (const Type& t) const + { + return the_item.isType (t); + } + + bool isTuple() const + { + return the_item.isTuple(); + } + + bool isString() const + { + return the_item.isString(); + } + + // Commands + void setAttr (const std::string& attr_name, const Object& value) + { + the_item.setAttr(attr_name, value); + } + + void delAttr (const std::string& attr_name) + { + the_item.delAttr(attr_name); + } + + void delItem (const Object& k) + { + the_item.delItem(k); + } + }; // end of mapref + + // TMM: now for mapref + template< class T > + bool operator==(const mapref& left, const mapref& right) + { + return true; // NOT completed. + } + + template< class T > + bool operator!=(const mapref& left, const mapref& right) + { + return true; // not completed. + } + + template + class MapBase: public Object + { + protected: + explicit MapBase() + {} + public: + // reference: proxy class for implementing [] + // TMM: 26Jun'01 - the types + // If you assume that Python mapping is a hash_map... + // hash_map::value_type is not assignable, but + // (*it).second = data must be a valid expression + typedef size_t size_type; + typedef Object key_type; + typedef mapref data_type; + typedef std::pair< const T, T > value_type; + typedef std::pair< const T, mapref > reference; + typedef const std::pair< const T, const T > const_reference; + typedef std::pair< const T, mapref > pointer; + + // Constructor + explicit MapBase (PyObject *pyob, bool owned = false): Object(pyob, owned) + { + validate(); + } + + // TMM: 02Jul'01 - changed MapBase to Object in next line + MapBase (const Object& ob): Object(ob) + { + validate(); + } + + // Assignment acquires new ownership of pointer + MapBase& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + MapBase& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (rhsp); + return *this; + } + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && PyMapping_Check(pyob); + } + + // Clear -- PyMapping Clear is missing + // + + void clear () + { + List k = keys(); + for(List::iterator i = k.begin(); i != k.end(); i++) + { + delItem(*i); + } + } + + virtual size_type size() const + { + return PyMapping_Length (ptr()); + } + + // Element Access + T operator[](const std::string& key) const + { + return getItem(key); + } + + T operator[](const Object& key) const + { + return getItem(key); + } + + mapref operator[](const std::string& key) + { + return mapref(*this, key); + } + + mapref operator[](const Object& key) + { + return mapref(*this, key); + } + + int length () const + { + return PyMapping_Length (ptr()); + } + + bool hasKey (const std::string& s) const + { + return PyMapping_HasKeyString (ptr(),const_cast(s.c_str())) != 0; + } + + bool hasKey (const Object& s) const + { + return PyMapping_HasKey (ptr(), s.ptr()) != 0; + } + + T getItem (const std::string& s) const + { + return T( + asObject(PyMapping_GetItemString (ptr(),const_cast(s.c_str()))) + ); + } + + T getItem (const Object& s) const + { + return T( + asObject(PyObject_GetItem (ptr(), s.ptr())) + ); + } + + virtual void setItem (const char *s, const Object& ob) + { + if (PyMapping_SetItemString (ptr(), const_cast(s), *ob) == -1) + { + throw Exception(); + } + } + + virtual void setItem (const std::string& s, const Object& ob) + { + if (PyMapping_SetItemString (ptr(), const_cast(s.c_str()), *ob) == -1) + { + throw Exception(); + } + } + + virtual void setItem (const Object& s, const Object& ob) + { + if (PyObject_SetItem (ptr(), s.ptr(), ob.ptr()) == -1) + { + throw Exception(); + } + } + + void delItem (const std::string& s) + { + if (PyMapping_DelItemString (ptr(), const_cast(s.c_str())) == -1) + { + throw Exception(); + } + } + + void delItem (const Object& s) + { + if (PyMapping_DelItem (ptr(), *s) == -1) + { + throw Exception(); + } + } + // Queries + List keys () const + { + return List(PyMapping_Keys(ptr()), true); + } + + List values () const + { // each returned item is a (key, value) pair + return List(PyMapping_Values(ptr()), true); + } + + List items () const + { + return List(PyMapping_Items(ptr()), true); + } + + // iterators for MapBase + // Added by TMM: 2Jul'01 - NOT COMPLETED + // There is still a bug. I decided to stop, before fixing the bug, because + // this can't be halfway efficient until Python gets built-in iterators. + // My current soln is to iterate over the map by getting a copy of its keys + // and iterating over that. Not a good solution. + + // The iterator holds a MapBase* rather than a MapBase because that's + // how the sequence iterator is implemented and it works. But it does seem + // odd to me - we are iterating over the map object, not the reference. + +#if 0 // here is the test code with which I found the (still existing) bug + typedef cxx::Dict d_t; + d_t d; + cxx::String s1("blah"); + cxx::String s2("gorf"); + d[ "one" ] = s1; + d[ "two" ] = s1; + d[ "three" ] = s2; + d[ "four" ] = s2; + + d_t::iterator it; + it = d.begin(); // this (using the assignment operator) is causing + // a problem; if I just use the copy ctor it works fine. + for( ; it != d.end(); ++it ) + { + d_t::value_type vt( *it ); + cxx::String rs = vt.second.repr(); + std::string ls = rs.operator std::string(); + fprintf( stderr, "%s\n", ls ); + } +#endif // 0 + + class iterator + { + // : public forward_iterator_parent( std::pair ) { + protected: + typedef std::forward_iterator_tag iterator_category; + typedef std::pair< const T, T > value_type; + typedef int difference_type; + typedef std::pair< const T, mapref > pointer; + typedef std::pair< const T, mapref > reference; + + friend class MapBase; + // + MapBase* map; + List keys; // for iterating over the map + List::iterator pos; // index into the keys + + public: + ~iterator () + {} + + iterator () + : map( 0 ) + , keys() + , pos() + {} + + iterator (MapBase* m, bool end = false ) + : map( m ) + , keys( m->keys() ) + , pos( end ? keys.end() : keys.begin() ) + {} + + iterator (const iterator& other) + : map( other.map ) + , keys( other.keys ) + , pos( other.pos ) + {} + + reference operator*() + { + Object key = *pos; + return std::make_pair(key, mapref(*map,key)); + } + + iterator& operator=(const iterator& other) + { + if (this == &other) + return *this; + map = other.map; + keys = other.keys; + pos = other.pos; + return *this; + } + + bool eql(const iterator& right) const + { + return *map == *right.map && pos == right.pos; + } + bool neq( const iterator& right ) const + { + return *map != *right.map || pos != right.pos; + } + + // pointer operator->() { + // return ; + // } + + // prefix ++ + iterator& operator++ () + { pos++; return *this;} + // postfix ++ + iterator operator++ (int) + { return iterator(map, keys, pos++);} + // prefix -- + iterator& operator-- () + { pos--; return *this;} + // postfix -- + iterator operator-- (int) + { return iterator(map, keys, pos--);} + + std::string diagnose() const + { + std::OSTRSTREAM oss; + oss << "iterator diagnosis " << map << ", " << pos << std::ends; + return std::string(oss.str()); + } + }; // end of class MapBase::iterator + + iterator begin () + { + return iterator(this); + } + + iterator end () + { + return iterator(this, true); + } + + class const_iterator + { + protected: + typedef std::forward_iterator_tag iterator_category; + typedef const std::pair< const T, T > value_type; + typedef int difference_type; + typedef const std::pair< const T, T > pointer; + typedef const std::pair< const T, T > reference; + + friend class MapBase; + const MapBase* map; + List keys; // for iterating over the map + List::iterator pos; // index into the keys + + public: + ~const_iterator () + {} + + const_iterator () + : map( 0 ) + , keys() + , pos() + {} + + const_iterator (const MapBase* m, List k, List::iterator p ) + : map( m ) + , keys( k ) + , pos( p ) + {} + + const_iterator(const const_iterator& other) + : map( other.map ) + , keys( other.keys ) + , pos( other.pos ) + {} + + bool eql(const const_iterator& right) const + { + return *map == *right.map && pos == right.pos; + } + bool neq( const const_iterator& right ) const + { + return *map != *right.map || pos != right.pos; + } + + + // const_reference operator*() { + // Object key = *pos; + // return std::make_pair( key, map->[key] ); + // GCC < 3 barfes on this line at the '['. + // } + + const_iterator& operator=(const const_iterator& other) + { + if (this == &other) return *this; + map = other.map; + keys = other.keys; + pos = other.pos; + return *this; + } + + // prefix ++ + const_iterator& operator++ () + { pos++; return *this;} + // postfix ++ + const_iterator operator++ (int) + { return const_iterator(map, keys, pos++);} + // prefix -- + const_iterator& operator-- () + { pos--; return *this;} + // postfix -- + const_iterator operator-- (int) + { return const_iterator(map, keys, pos--);} + }; // end of class MapBase::const_iterator + + const_iterator begin () const + { + return const_iterator(this, 0); + } + + const_iterator end () const + { + return const_iterator(this, length()); + } + + }; // end of MapBase + + typedef MapBase Mapping; + + template bool operator==(const EXPLICIT_TYPENAME MapBase::iterator& left, const EXPLICIT_TYPENAME MapBase::iterator& right); + template bool operator!=(const EXPLICIT_TYPENAME MapBase::iterator& left, const EXPLICIT_TYPENAME MapBase::iterator& right); + template bool operator==(const EXPLICIT_TYPENAME MapBase::const_iterator& left, const EXPLICIT_TYPENAME MapBase::const_iterator& right); + template bool operator!=(const EXPLICIT_TYPENAME MapBase::const_iterator& left, const EXPLICIT_TYPENAME MapBase::const_iterator& right); + + extern bool operator==(const Mapping::iterator& left, const Mapping::iterator& right); + extern bool operator!=(const Mapping::iterator& left, const Mapping::iterator& right); + extern bool operator==(const Mapping::const_iterator& left, const Mapping::const_iterator& right); + extern bool operator!=(const Mapping::const_iterator& left, const Mapping::const_iterator& right); + + + // ================================================== + // class Dict + class Dict: public Mapping + { + public: + // Constructor + explicit Dict (PyObject *pyob, bool owned=false): Mapping (pyob, owned) + { + validate(); + } + Dict (const Dict& ob): Mapping(ob) + { + validate(); + } + // Creation + Dict () + { + set(PyDict_New (), true); + validate(); + } + // Assignment acquires new ownership of pointer + + Dict& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + Dict& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set(rhsp); + return *this; + } + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && Py::_Dict_Check (pyob); + } + }; + + class Callable: public Object + { + public: + // Constructor + explicit Callable (): Object() {} + explicit Callable (PyObject *pyob, bool owned = false): Object (pyob, owned) + { + validate(); + } + + Callable (const Object& ob): Object(ob) + { + validate(); + } + + // Assignment acquires new ownership of pointer + + Callable& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + Callable& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set (rhsp); + return *this; + } + + // Membership + virtual bool accepts (PyObject *pyob) const + { + return pyob && PyCallable_Check (pyob); + } + + // Call + Object apply(const Tuple& args) const + { + return asObject(PyObject_CallObject(ptr(), args.ptr())); + } + + // Call with keywords + Object apply(const Tuple& args, const Dict& kw) const + { + return asObject( PyEval_CallObjectWithKeywords( ptr(), args.ptr(), kw.ptr() ) ); + } + + Object apply(PyObject* pargs = 0) const + { + return apply (Tuple(pargs)); + } + }; + + class Module: public Object + { + public: + explicit Module (PyObject* pyob, bool owned = false): Object (pyob, owned) + { + validate(); + } + + // Construct from module name + explicit Module (const std::string&s): Object() + { + PyObject *m = PyImport_AddModule( const_cast(s.c_str()) ); + set( m, false ); + validate (); + } + + // Copy constructor acquires new ownership of pointer + Module (const Module& ob): Object(*ob) + { + validate(); + } + + Module& operator= (const Object& rhs) + { + return (*this = *rhs); + } + + Module& operator= (PyObject* rhsp) + { + if(ptr() == rhsp) return *this; + set(rhsp); + return *this; + } + + Dict getDict() + { + return Dict(PyModule_GetDict(ptr())); + // Caution -- PyModule_GetDict returns borrowed reference! + } + }; + + // Numeric interface + inline Object operator+ (const Object& a) + { + return asObject(PyNumber_Positive(*a)); + } + inline Object operator- (const Object& a) + { + return asObject(PyNumber_Negative(*a)); + } + + inline Object abs(const Object& a) + { + return asObject(PyNumber_Absolute(*a)); + } + + inline std::pair coerce(const Object& a, const Object& b) + { + PyObject *p1, *p2; + p1 = *a; + p2 = *b; + if(PyNumber_Coerce(&p1,&p2) == -1) + { + throw Exception(); + } + return std::pair(asObject(p1), asObject(p2)); + } + + inline Object operator+ (const Object& a, const Object& b) + { + return asObject(PyNumber_Add(*a, *b)); + } + inline Object operator+ (const Object& a, int j) + { + return asObject(PyNumber_Add(*a, *Int(j))); + } + inline Object operator+ (const Object& a, double v) + { + return asObject(PyNumber_Add(*a, *Float(v))); + } + inline Object operator+ (int j, const Object& b) + { + return asObject(PyNumber_Add(*Int(j), *b)); + } + inline Object operator+ (double v, const Object& b) + { + return asObject(PyNumber_Add(*Float(v), *b)); + } + + inline Object operator- (const Object& a, const Object& b) + { + return asObject(PyNumber_Subtract(*a, *b)); + } + inline Object operator- (const Object& a, int j) + { + return asObject(PyNumber_Subtract(*a, *Int(j))); + } + inline Object operator- (const Object& a, double v) + { + return asObject(PyNumber_Subtract(*a, *Float(v))); + } + inline Object operator- (int j, const Object& b) + { + return asObject(PyNumber_Subtract(*Int(j), *b)); + } + inline Object operator- (double v, const Object& b) + { + return asObject(PyNumber_Subtract(*Float(v), *b)); + } + + inline Object operator* (const Object& a, const Object& b) + { + return asObject(PyNumber_Multiply(*a, *b)); + } + inline Object operator* (const Object& a, int j) + { + return asObject(PyNumber_Multiply(*a, *Int(j))); + } + inline Object operator* (const Object& a, double v) + { + return asObject(PyNumber_Multiply(*a, *Float(v))); + } + inline Object operator* (int j, const Object& b) + { + return asObject(PyNumber_Multiply(*Int(j), *b)); + } + inline Object operator* (double v, const Object& b) + { + return asObject(PyNumber_Multiply(*Float(v), *b)); + } + + inline Object operator/ (const Object& a, const Object& b) + { + return asObject(PyNumber_Divide(*a, *b)); + } + inline Object operator/ (const Object& a, int j) + { + return asObject(PyNumber_Divide(*a, *Int(j))); + } + inline Object operator/ (const Object& a, double v) + { + return asObject(PyNumber_Divide(*a, *Float(v))); + } + inline Object operator/ (int j, const Object& b) + { + return asObject(PyNumber_Divide(*Int(j), *b)); + } + inline Object operator/ (double v, const Object& b) + { + return asObject(PyNumber_Divide(*Float(v), *b)); + } + + inline Object operator% (const Object& a, const Object& b) + { + return asObject(PyNumber_Remainder(*a, *b)); + } + inline Object operator% (const Object& a, int j) + { + return asObject(PyNumber_Remainder(*a, *Int(j))); + } + inline Object operator% (const Object& a, double v) + { + return asObject(PyNumber_Remainder(*a, *Float(v))); + } + inline Object operator% (int j, const Object& b) + { + return asObject(PyNumber_Remainder(*Int(j), *b)); + } + inline Object operator% (double v, const Object& b) + { + return asObject(PyNumber_Remainder(*Float(v), *b)); + } + + inline Object type(const Exception&) // return the type of the error + { + PyObject *ptype, *pvalue, *ptrace; + PyErr_Fetch(&ptype, &pvalue, &ptrace); + Object result; + if(ptype) result = ptype; + PyErr_Restore(ptype, pvalue, ptrace); + return result; + } + + inline Object value(const Exception&) // return the value of the error + { + PyObject *ptype, *pvalue, *ptrace; + PyErr_Fetch(&ptype, &pvalue, &ptrace); + Object result; + if(pvalue) result = pvalue; + PyErr_Restore(ptype, pvalue, ptrace); + return result; + } + + inline Object trace(const Exception&) // return the traceback of the error + { + PyObject *ptype, *pvalue, *ptrace; + PyErr_Fetch(&ptype, &pvalue, &ptrace); + Object result; + if(ptrace) result = ptrace; + PyErr_Restore(ptype, pvalue, ptrace); + return result; + } + +template +String seqref::str () const +{ + return the_item.str(); +} + +template +String seqref::repr () const +{ + return the_item.repr(); +} + +} // namespace Py +#endif // __CXX_Objects__h diff --git a/src/extension/script/cxx/Version.hxx b/src/extension/script/cxx/Version.hxx new file mode 100644 index 000000000..8286e2feb --- /dev/null +++ b/src/extension/script/cxx/Version.hxx @@ -0,0 +1,46 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __PyCXX_version_hxx__ +#define __PyCXX_version_hxx__ + +#define PYCXX_VERSION_MAJOR 5 +#define PYCXX_VERSION_MINOR 4 +#define PYCXX_VERSION_PATCH 0 +#define PYCXX_MAKEVERSION( major, minor, patch ) ((major<<16)|(minor<<8)|(patch)) +#define PYCXX_VERSION PYCXX_MAKEVERSION( PYCXX_VERSION_MAJOR, PYCXX_VERSION_MINOR, PYCXX_VERSION_PATCH ) +#endif diff --git a/src/extension/script/cxx/WrapPython.h b/src/extension/script/cxx/WrapPython.h new file mode 100644 index 000000000..51b939163 --- /dev/null +++ b/src/extension/script/cxx/WrapPython.h @@ -0,0 +1,49 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __PyCXX_wrap_python_hxx__ +#define __PyCXX_wrap_python_hxx__ + +// On some platforms we have to include time.h to get select defined +#if !defined(__WIN32__) && !defined(WIN32) && !defined(_WIN32) && !defined(_WIN64) +#include +#endif + +// pull in python definitions +#include + +#endif diff --git a/src/extension/script/cxx/cxx_extensions.cxx b/src/extension/script/cxx/cxx_extensions.cxx new file mode 100644 index 000000000..102dc26d4 --- /dev/null +++ b/src/extension/script/cxx/cxx_extensions.cxx @@ -0,0 +1,1400 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- +#include "CXX/Extensions.hxx" +#include "CXX/Exception.hxx" + +#include + +namespace Py +{ +//================================================================================ +// +// Implementation of MethodTable +// +//================================================================================ + +PyMethodDef MethodTable::method( const char* method_name, PyCFunction f, int flags, const char* doc ) +{ + PyMethodDef m; + m.ml_name = const_cast( method_name ); + m.ml_meth = f; + m.ml_flags = flags; + m.ml_doc = const_cast( doc ); + return m; +} + +MethodTable::MethodTable() +{ + t.push_back( method( 0, 0, 0, 0 ) ); + mt = 0; +} + +MethodTable::~MethodTable() +{ + delete [] mt; +} + +void MethodTable::add( const char* method_name, PyCFunction f, const char* doc, int flag ) +{ + if( !mt ) + { + t.insert( t.end()-1, method( method_name, f, flag, doc ) ); + } + else + { + throw RuntimeError( "Too late to add a module method!" ); + } +} + +PyMethodDef* MethodTable::table() +{ + if( !mt ) + { + Py_ssize_t t1size = t.size(); + mt = new PyMethodDef[t1size]; + int j = 0; + for( std::vector::iterator i = t.begin(); i != t.end(); i++ ) + { + mt[j++] = *i; + } + } + return mt; +} + +//================================================================================ +// +// Implementation of ExtensionModule +// +//================================================================================ +ExtensionModuleBase::ExtensionModuleBase( const char *name ) + : module_name( name ) + , full_module_name( __Py_PackageContext() != NULL ? std::string( __Py_PackageContext() ) : module_name ) + , method_table() +{} + +ExtensionModuleBase::~ExtensionModuleBase() +{} + +const std::string &ExtensionModuleBase::name() const +{ + return module_name; +} + +const std::string &ExtensionModuleBase::fullName() const +{ + return full_module_name; +} + +class ExtensionModuleBasePtr : public PythonExtension +{ +public: + ExtensionModuleBasePtr( ExtensionModuleBase *_module ) + : module( _module ) + {} + virtual ~ExtensionModuleBasePtr() + {} + + ExtensionModuleBase *module; +}; + + +void ExtensionModuleBase::initialize( const char *module_doc ) +{ + PyObject *module_ptr = new ExtensionModuleBasePtr( this ); + + Py_InitModule4 + ( + const_cast( module_name.c_str() ), // name + method_table.table(), // methods + const_cast( module_doc ), // docs + module_ptr, // pass to functions as "self" + PYTHON_API_VERSION // API version + ); +} + +Py::Module ExtensionModuleBase::module(void) const +{ + return Module( full_module_name ); +} + +Py::Dict ExtensionModuleBase::moduleDictionary(void) const +{ + return module().getDict(); +} + +//-------------------------------------------------------------------------------- + +//================================================================================ +// +// Implementation of PythonType +// +//================================================================================ + +extern "C" +{ + static void standard_dealloc(PyObject* p); + // + // All the following functions redirect the call from Python + // onto the matching virtual function in PythonExtensionBase + // + static int print_handler (PyObject*, FILE *, int); + static PyObject* getattr_handler (PyObject*, char*); + static int setattr_handler (PyObject*, char*, PyObject*); + static PyObject* getattro_handler (PyObject*, PyObject*); + static int setattro_handler (PyObject*, PyObject*, PyObject*); + static int compare_handler (PyObject*, PyObject*); + static PyObject* repr_handler (PyObject*); + static PyObject* str_handler (PyObject*); + static long hash_handler (PyObject*); + static PyObject* call_handler (PyObject*, PyObject*, PyObject*); + static PyObject* iter_handler (PyObject*); + static PyObject* iternext_handler (PyObject*); + + // Sequence methods + static Py_ssize_t sequence_length_handler(PyObject*); + static PyObject* sequence_concat_handler(PyObject*,PyObject*); + static PyObject* sequence_repeat_handler(PyObject*, Py_ssize_t); + static PyObject* sequence_item_handler(PyObject*, Py_ssize_t); + static PyObject* sequence_slice_handler(PyObject*, Py_ssize_t, Py_ssize_t); + static int sequence_ass_item_handler(PyObject*, Py_ssize_t, PyObject*); + static int sequence_ass_slice_handler(PyObject*, Py_ssize_t, Py_ssize_t, PyObject*); + // Mapping + static Py_ssize_t mapping_length_handler(PyObject*); + static PyObject* mapping_subscript_handler(PyObject*, PyObject*); + static int mapping_ass_subscript_handler(PyObject*, PyObject*, PyObject*); + + // Numeric methods + static int number_nonzero_handler (PyObject*); + static PyObject* number_negative_handler (PyObject*); + static PyObject* number_positive_handler (PyObject*); + static PyObject* number_absolute_handler (PyObject*); + static PyObject* number_invert_handler (PyObject*); + static PyObject* number_int_handler (PyObject*); + static PyObject* number_float_handler (PyObject*); + static PyObject* number_long_handler (PyObject*); + static PyObject* number_oct_handler (PyObject*); + static PyObject* number_hex_handler (PyObject*); + static PyObject* number_add_handler (PyObject*, PyObject*); + static PyObject* number_subtract_handler (PyObject*, PyObject*); + static PyObject* number_multiply_handler (PyObject*, PyObject*); + static PyObject* number_divide_handler (PyObject*, PyObject*); + static PyObject* number_remainder_handler (PyObject*, PyObject*); + static PyObject* number_divmod_handler (PyObject*, PyObject*); + static PyObject* number_lshift_handler (PyObject*, PyObject*); + static PyObject* number_rshift_handler (PyObject*, PyObject*); + static PyObject* number_and_handler (PyObject*, PyObject*); + static PyObject* number_xor_handler (PyObject*, PyObject*); + static PyObject* number_or_handler (PyObject*, PyObject*); + static PyObject* number_power_handler(PyObject*, PyObject*, PyObject*); + + // Buffer + static Py_ssize_t buffer_getreadbuffer_handler (PyObject*, Py_ssize_t, void**); + static Py_ssize_t buffer_getwritebuffer_handler (PyObject*, Py_ssize_t, void**); + static Py_ssize_t buffer_getsegcount_handler (PyObject*, Py_ssize_t*); +} + + +extern "C" void standard_dealloc( PyObject* p ) +{ + PyMem_DEL( p ); +} + +PythonType & PythonType::supportSequenceType() +{ + if( !sequence_table ) + { + sequence_table = new PySequenceMethods; + memset( sequence_table, 0, sizeof( PySequenceMethods ) ); // ensure new fields are 0 + table->tp_as_sequence = sequence_table; + sequence_table->sq_length = sequence_length_handler; + sequence_table->sq_concat = sequence_concat_handler; + sequence_table->sq_repeat = sequence_repeat_handler; + sequence_table->sq_item = sequence_item_handler; + sequence_table->sq_slice = sequence_slice_handler; + + sequence_table->sq_ass_item = sequence_ass_item_handler; // BAS setup seperately? + sequence_table->sq_ass_slice = sequence_ass_slice_handler; // BAS setup seperately? + } + return *this; +} + +PythonType & PythonType::supportMappingType() +{ + if( !mapping_table ) + { + mapping_table = new PyMappingMethods; + memset( mapping_table, 0, sizeof( PyMappingMethods ) ); // ensure new fields are 0 + table->tp_as_mapping = mapping_table; + mapping_table->mp_length = mapping_length_handler; + mapping_table->mp_subscript = mapping_subscript_handler; + mapping_table->mp_ass_subscript = mapping_ass_subscript_handler; // BAS setup seperately? + } + return *this; +} + +PythonType & PythonType::supportNumberType() +{ + if( !number_table ) + { + number_table = new PyNumberMethods; + memset( number_table, 0, sizeof( PyNumberMethods ) ); // ensure new fields are 0 + table->tp_as_number = number_table; + number_table->nb_add = number_add_handler; + number_table->nb_subtract = number_subtract_handler; + number_table->nb_multiply = number_multiply_handler; + number_table->nb_divide = number_divide_handler; + number_table->nb_remainder = number_remainder_handler; + number_table->nb_divmod = number_divmod_handler; + number_table->nb_power = number_power_handler; + number_table->nb_negative = number_negative_handler; + number_table->nb_positive = number_positive_handler; + number_table->nb_absolute = number_absolute_handler; + number_table->nb_nonzero = number_nonzero_handler; + number_table->nb_invert = number_invert_handler; + number_table->nb_lshift = number_lshift_handler; + number_table->nb_rshift = number_rshift_handler; + number_table->nb_and = number_and_handler; + number_table->nb_xor = number_xor_handler; + number_table->nb_or = number_or_handler; + number_table->nb_coerce = 0; + number_table->nb_int = number_int_handler; + number_table->nb_long = number_long_handler; + number_table->nb_float = number_float_handler; + number_table->nb_oct = number_oct_handler; + number_table->nb_hex = number_hex_handler; + } + return *this; +} + +PythonType & PythonType::supportBufferType() +{ + if( !buffer_table ) + { + buffer_table = new PyBufferProcs; + memset( buffer_table, 0, sizeof( PyBufferProcs ) ); // ensure new fields are 0 + table->tp_as_buffer = buffer_table; + buffer_table->bf_getreadbuffer = buffer_getreadbuffer_handler; + buffer_table->bf_getwritebuffer = buffer_getwritebuffer_handler; + buffer_table->bf_getsegcount = buffer_getsegcount_handler; + } + return *this; +} + +// if you define one sequence method you must define +// all of them except the assigns + +PythonType::PythonType( size_t basic_size, int itemsize, const char *default_name ) + : table( new PyTypeObject ) + , sequence_table( NULL ) + , mapping_table( NULL ) + , number_table( NULL ) + , buffer_table( NULL ) +{ + memset( table, 0, sizeof( PyTypeObject ) ); // ensure new fields are 0 + *reinterpret_cast( table ) = py_object_initializer; + table->ob_type = _Type_Type(); + table->ob_size = 0; + table->tp_name = const_cast( default_name ); + table->tp_basicsize = basic_size; + table->tp_itemsize = itemsize; + table->tp_dealloc = ( destructor ) standard_dealloc; + table->tp_print = 0; + table->tp_getattr = 0; + table->tp_setattr = 0; + table->tp_compare = 0; + table->tp_repr = 0; + table->tp_as_number = 0; + table->tp_as_sequence = 0; + table->tp_as_mapping = 0; + table->tp_hash = 0; + table->tp_call = 0; + table->tp_str = 0; + table->tp_getattro = 0; + table->tp_setattro = 0; + table->tp_as_buffer = 0; + table->tp_flags = Py_TPFLAGS_DEFAULT; + table->tp_doc = 0; +#if PY_MAJOR_VERSION > 2 || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION >= 0) + // first use in 2.0 + table->tp_traverse = 0L; + table->tp_clear = 0L; +#else + table->tp_xxx5 = 0L; + table->tp_xxx6 = 0L; +#endif +#if PY_MAJOR_VERSION > 2 || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION >= 1) + // first defined in 2.1 + table->tp_richcompare = 0L; + table->tp_weaklistoffset = 0L; +#else + table->tp_xxx7 = 0L; + table->tp_xxx8 = 0L; +#endif + +#if PY_MAJOR_VERSION > 2 || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION >= 2) + // first defined in 2.3 + table->tp_iter = 0L; + table->tp_iternext = 0L; +#endif + +#ifdef COUNT_ALLOCS + table->tp_alloc = 0; + table->tp_free = 0; + table->tp_maxalloc = 0; + table->tp_next = 0; +#endif +} + +PythonType::~PythonType( ) +{ + delete table; + delete sequence_table; + delete mapping_table; + delete number_table; + delete buffer_table; +} + +PyTypeObject* PythonType::type_object( ) const +{return table;} + +PythonType & PythonType::name( const char* nam ) +{ + table->tp_name = const_cast( nam ); + return *this; +} + +const char *PythonType::getName() const +{ + return table->tp_name; +} + +PythonType & PythonType::doc( const char* d ) +{ + table->tp_doc = const_cast( d ); + return *this; +} + +const char *PythonType::getDoc() const +{ + return table->tp_doc; +} + +PythonType & PythonType::dealloc( void( *f )( PyObject* )) +{ + table->tp_dealloc = f; + return *this; +} + +PythonType & PythonType::supportPrint() +{ + table->tp_print = print_handler; + return *this; +} + +PythonType & PythonType::supportGetattr() +{ + table->tp_getattr = getattr_handler; + return *this; +} + +PythonType & PythonType::supportSetattr() +{ + table->tp_setattr = setattr_handler; + return *this; +} + +PythonType & PythonType::supportGetattro() +{ + table->tp_getattro = getattro_handler; + return *this; +} + +PythonType & PythonType::supportSetattro() +{ + table->tp_setattro = setattro_handler; + return *this; +} + +PythonType & PythonType::supportCompare() +{ + table->tp_compare = compare_handler; + return *this; +} + +PythonType & PythonType::supportRepr() +{ + table->tp_repr = repr_handler; + return *this; +} + +PythonType & PythonType::supportStr() +{ + table->tp_str = str_handler; + return *this; +} + +PythonType & PythonType::supportHash() +{ + table->tp_hash = hash_handler; + return *this; +} + +PythonType & PythonType::supportCall() +{ + table->tp_call = call_handler; + return *this; +} + +PythonType & PythonType::supportIter() +{ + table->tp_iter = iter_handler; + table->tp_iternext = iternext_handler; + return *this; +} + +//-------------------------------------------------------------------------------- +// +// Handlers +// +//-------------------------------------------------------------------------------- +extern "C" int print_handler( PyObject *self, FILE *fp, int flags ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->print( fp, flags ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject* getattr_handler( PyObject *self, char *name ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->getattr( name ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" int setattr_handler( PyObject *self, char *name, PyObject *value ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->setattr( name, Py::Object( value ) ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject* getattro_handler( PyObject *self, PyObject *name ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->getattro( Py::Object( name ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" int setattro_handler( PyObject *self, PyObject *name, PyObject *value ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->setattro( Py::Object( name ), Py::Object( value ) ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" int compare_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->compare( Py::Object( other ) ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject* repr_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->repr() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* str_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->str() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" long hash_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->hash(); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject* call_handler( PyObject *self, PyObject *args, PyObject *kw ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + if( kw != NULL ) + return new_reference_to( p->call( Py::Object( args ), Py::Object( kw ) ) ); + else + return new_reference_to( p->call( Py::Object( args ), Py::Object() ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* iter_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->iter() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* iternext_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->iternext(); // might be a NULL ptr on end of iteration + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + + +// Sequence methods +extern "C" Py_ssize_t sequence_length_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->sequence_length(); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject* sequence_concat_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->sequence_concat( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* sequence_repeat_handler( PyObject *self, Py_ssize_t count ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->sequence_repeat( count ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* sequence_item_handler( PyObject *self, Py_ssize_t index ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->sequence_item( index ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* sequence_slice_handler( PyObject *self, Py_ssize_t first, Py_ssize_t last ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->sequence_slice( first, last ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" int sequence_ass_item_handler( PyObject *self, Py_ssize_t index, PyObject *value ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->sequence_ass_item( index, Py::Object( value ) ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" int sequence_ass_slice_handler( PyObject *self, Py_ssize_t first, Py_ssize_t last, PyObject *value ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->sequence_ass_slice( first, last, Py::Object( value ) ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +// Mapping +extern "C" Py_ssize_t mapping_length_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->mapping_length(); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject* mapping_subscript_handler( PyObject *self, PyObject *key ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->mapping_subscript( Py::Object( key ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" int mapping_ass_subscript_handler( PyObject *self, PyObject *key, PyObject *value ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->mapping_ass_subscript( Py::Object( key ), Py::Object( value ) ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +// Number +extern "C" int number_nonzero_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->number_nonzero(); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject* number_negative_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_negative() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_positive_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_positive() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_absolute_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_absolute() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_invert_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_invert() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_int_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_int() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_float_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_float() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_long_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_long() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_oct_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_oct() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_hex_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_hex() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_add_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_add( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_subtract_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_subtract( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_multiply_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_multiply( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_divide_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_divide( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_remainder_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_remainder( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_divmod_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_divmod( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_lshift_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_lshift( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_rshift_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_rshift( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_and_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_and( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_xor_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_xor( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_or_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_or( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject* number_power_handler( PyObject *self, PyObject *x1, PyObject *x2 ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return new_reference_to( p->number_power( Py::Object( x1 ), Py::Object( x2 ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +// Buffer +extern "C" Py_ssize_t buffer_getreadbuffer_handler( PyObject *self, Py_ssize_t index, void **pp ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->buffer_getreadbuffer( index, pp ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" Py_ssize_t buffer_getwritebuffer_handler( PyObject *self, Py_ssize_t index, void **pp ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->buffer_getwritebuffer( index, pp ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" Py_ssize_t buffer_getsegcount_handler( PyObject *self, Py_ssize_t *count ) +{ + try + { + PythonExtensionBase *p = static_cast( self ); + return p->buffer_getsegcount( count ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + + +//================================================================================ +// +// Implementation of PythonExtensionBase +// +//================================================================================ +#define missing_method( method ) \ +throw RuntimeError( "Extension object does not support method " #method ); + +PythonExtensionBase::PythonExtensionBase() +{ +} + +PythonExtensionBase::~PythonExtensionBase() +{ + assert( ob_refcnt == 0 ); +} + +int PythonExtensionBase::print( FILE *, int ) +{ missing_method( print ); return -1; } + +int PythonExtensionBase::setattr( const char*, const Py::Object & ) +{ missing_method( setattr ); return -1; } + +Py::Object PythonExtensionBase::getattro( const Py::Object & ) +{ missing_method( getattro ); return Py::Nothing(); } + +int PythonExtensionBase::setattro( const Py::Object &, const Py::Object & ) +{ missing_method( setattro ); return -1; } + +int PythonExtensionBase::compare( const Py::Object & ) +{ missing_method( compare ); return -1; } + +Py::Object PythonExtensionBase::repr() +{ missing_method( repr ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::str() +{ missing_method( str ); return Py::Nothing(); } + +long PythonExtensionBase::hash() +{ missing_method( hash ); return -1; } + +Py::Object PythonExtensionBase::call( const Py::Object &, const Py::Object & ) +{ missing_method( call ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::iter() +{ missing_method( iter ); return Py::Nothing(); } + +PyObject* PythonExtensionBase::iternext() +{ missing_method( iternext ); return NULL; } + + +// Sequence methods +int PythonExtensionBase::sequence_length() +{ missing_method( sequence_length ); return -1; } + +Py::Object PythonExtensionBase::sequence_concat( const Py::Object & ) +{ missing_method( sequence_concat ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::sequence_repeat( Py_ssize_t ) +{ missing_method( sequence_repeat ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::sequence_item( Py_ssize_t ) +{ missing_method( sequence_item ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::sequence_slice( Py_ssize_t, Py_ssize_t ) +{ missing_method( sequence_slice ); return Py::Nothing(); } + +int PythonExtensionBase::sequence_ass_item( Py_ssize_t, const Py::Object & ) +{ missing_method( sequence_ass_item ); return -1; } + +int PythonExtensionBase::sequence_ass_slice( Py_ssize_t, Py_ssize_t, const Py::Object & ) +{ missing_method( sequence_ass_slice ); return -1; } + + +// Mapping +int PythonExtensionBase::mapping_length() +{ missing_method( mapping_length ); return -1; } + +Py::Object PythonExtensionBase::mapping_subscript( const Py::Object & ) +{ missing_method( mapping_subscript ); return Py::Nothing(); } + +int PythonExtensionBase::mapping_ass_subscript( const Py::Object &, const Py::Object & ) +{ missing_method( mapping_ass_subscript ); return -1; } + + +// Number +int PythonExtensionBase::number_nonzero() +{ missing_method( number_nonzero ); return -1; } + +Py::Object PythonExtensionBase::number_negative() +{ missing_method( number_negative ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_positive() +{ missing_method( number_positive ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_absolute() +{ missing_method( number_absolute ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_invert() +{ missing_method( number_invert ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_int() +{ missing_method( number_int ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_float() +{ missing_method( number_float ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_long() +{ missing_method( number_long ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_oct() +{ missing_method( number_oct ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_hex() +{ missing_method( number_hex ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_add( const Py::Object & ) +{ missing_method( number_add ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_subtract( const Py::Object & ) +{ missing_method( number_subtract ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_multiply( const Py::Object & ) +{ missing_method( number_multiply ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_divide( const Py::Object & ) +{ missing_method( number_divide ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_remainder( const Py::Object & ) +{ missing_method( number_remainder ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_divmod( const Py::Object & ) +{ missing_method( number_divmod ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_lshift( const Py::Object & ) +{ missing_method( number_lshift ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_rshift( const Py::Object & ) +{ missing_method( number_rshift ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_and( const Py::Object & ) +{ missing_method( number_and ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_xor( const Py::Object & ) +{ missing_method( number_xor ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_or( const Py::Object & ) +{ missing_method( number_or ); return Py::Nothing(); } + +Py::Object PythonExtensionBase::number_power( const Py::Object &, const Py::Object & ) +{ missing_method( number_power ); return Py::Nothing(); } + + +// Buffer +Py_ssize_t PythonExtensionBase::buffer_getreadbuffer( Py_ssize_t, void** ) +{ missing_method( buffer_getreadbuffer ); return -1; } + +Py_ssize_t PythonExtensionBase::buffer_getwritebuffer( Py_ssize_t, void** ) +{ missing_method( buffer_getwritebuffer ); return -1; } + +Py_ssize_t PythonExtensionBase::buffer_getsegcount( Py_ssize_t* ) +{ missing_method( buffer_getsegcount ); return -1; } + +//-------------------------------------------------------------------------------- +// +// Method call handlers for +// PythonExtensionBase +// ExtensionModuleBase +// +//-------------------------------------------------------------------------------- + +extern "C" PyObject *method_keyword_call_handler( PyObject *_self_and_name_tuple, PyObject *_args, PyObject *_keywords ) +{ + try + { + Tuple self_and_name_tuple( _self_and_name_tuple ); + + PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); + void *self_as_void = PyCObject_AsVoidPtr( self_in_cobject ); + if( self_as_void == NULL ) + return NULL; + + ExtensionModuleBase *self = static_cast( self_as_void ); + + String py_name( self_and_name_tuple[1] ); + std::string name( py_name.as_std_string() ); + + Tuple args( _args ); + if( _keywords == NULL ) + { + Dict keywords; // pass an empty dict + + Object result( self->invoke_method_keyword( name, args, keywords ) ); + return new_reference_to( result.ptr() ); + } + + Dict keywords( _keywords ); + + Object result( self->invoke_method_keyword( name, args, keywords ) ); + return new_reference_to( result.ptr() ); + } + catch( Exception & ) + { + return 0; + } +} + +extern "C" PyObject *method_varargs_call_handler( PyObject *_self_and_name_tuple, PyObject *_args ) +{ + try + { + Tuple self_and_name_tuple( _self_and_name_tuple ); + + PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); + void *self_as_void = PyCObject_AsVoidPtr( self_in_cobject ); + if( self_as_void == NULL ) + return NULL; + + ExtensionModuleBase *self = static_cast( self_as_void ); + + String py_name( self_and_name_tuple[1] ); + std::string name( py_name.as_std_string() ); + + Tuple args( _args ); + + Object result( self->invoke_method_varargs( name, args ) ); + + return new_reference_to( result.ptr() ); + } + catch( Exception & ) + { + return 0; + } +} + +extern "C" void do_not_dealloc( void * ) +{} + + +//-------------------------------------------------------------------------------- +// +// ExtensionExceptionType +// +//-------------------------------------------------------------------------------- +ExtensionExceptionType::ExtensionExceptionType() + : Py::Object() +{ +} + +void ExtensionExceptionType::init( ExtensionModuleBase &module, const std::string& name ) +{ + std::string module_name( module.fullName() ); + module_name += "."; + module_name += name; + + set( PyErr_NewException( const_cast( module_name.c_str() ), NULL, NULL ), true ); +} + +void ExtensionExceptionType::init( ExtensionModuleBase &module, const std::string& name, ExtensionExceptionType &parent) + { + std::string module_name( module.fullName() ); + module_name += "."; + module_name += name; + + set( PyErr_NewException( const_cast( module_name.c_str() ), parent.ptr(), NULL ), true ); +} + +ExtensionExceptionType::~ExtensionExceptionType() +{ +} + +Exception::Exception( ExtensionExceptionType &exception, const std::string& reason ) +{ + PyErr_SetString (exception.ptr(), reason.c_str()); +} + +Exception::Exception( ExtensionExceptionType &exception, Object &reason ) +{ + PyErr_SetObject (exception.ptr(), reason.ptr()); +} + +Exception::Exception( PyObject* exception, Object &reason ) +{ + PyErr_SetObject (exception, reason.ptr()); +} + +} // end of namespace Py diff --git a/src/extension/script/cxx/cxxextensions.c b/src/extension/script/cxx/cxxextensions.c new file mode 100644 index 000000000..edae3be6b --- /dev/null +++ b/src/extension/script/cxx/cxxextensions.c @@ -0,0 +1,49 @@ +/*---------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//---------------------------------------------------------------------------*/ + +#include "CXX/WrapPython.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + +PyObject py_object_initializer = {PyObject_HEAD_INIT(0)}; + +#ifdef __cplusplus +} +#endif diff --git a/src/extension/script/cxx/cxxsupport.cxx b/src/extension/script/cxx/cxxsupport.cxx new file mode 100644 index 000000000..1dfba5a19 --- /dev/null +++ b/src/extension/script/cxx/cxxsupport.cxx @@ -0,0 +1,174 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#include "CXX/Objects.hxx" +namespace Py { + +Py_UNICODE unicode_null_string[1] = { 0 }; + +Type Object::type () const +{ + return Type (PyObject_Type (p), true); +} + +String Object::str () const +{ + return String (PyObject_Str (p), true); +} + +String Object::repr () const +{ + return String (PyObject_Repr (p), true); +} + +std::string Object::as_string() const +{ + return static_cast(str()); +} + +List Object::dir () const + { + return List (PyObject_Dir (p), true); + } + +bool Object::isType (const Type& t) const +{ + return type ().ptr() == t.ptr(); +} + +Char::operator String() const +{ + return String(ptr()); +} + +// TMM: non-member operaters for iterators - see above +// I've also made a bug fix in respect to the cxx code +// (dereffed the left.seq and right.seq comparison) +bool operator==(const Sequence::iterator& left, const Sequence::iterator& right) +{ + return left.eql( right ); +} + +bool operator!=(const Sequence::iterator& left, const Sequence::iterator& right) +{ + return left.neq( right ); +} + +bool operator< (const Sequence::iterator& left, const Sequence::iterator& right) +{ + return left.lss( right ); +} + +bool operator> (const Sequence::iterator& left, const Sequence::iterator& right) +{ + return left.gtr( right ); +} + +bool operator<=(const Sequence::iterator& left, const Sequence::iterator& right) +{ + return left.leq( right ); +} + +bool operator>=(const Sequence::iterator& left, const Sequence::iterator& right) +{ + return left.geq( right ); +} + +// now for const_iterator +bool operator==(const Sequence::const_iterator& left, const Sequence::const_iterator& right) +{ + return left.eql( right ); +} + +bool operator!=(const Sequence::const_iterator& left, const Sequence::const_iterator& right) +{ + return left.neq( right ); +} + +bool operator< (const Sequence::const_iterator& left, const Sequence::const_iterator& right) +{ + return left.lss( right ); +} + +bool operator> (const Sequence::const_iterator& left, const Sequence::const_iterator& right) +{ + return left.gtr( right ); +} + +bool operator<=(const Sequence::const_iterator& left, const Sequence::const_iterator& right) +{ + return left.leq( right ); +} + +bool operator>=(const Sequence::const_iterator& left, const Sequence::const_iterator& right) +{ + return left.geq( right ); +} + +// For mappings: +bool operator==(const Mapping::iterator& left, const Mapping::iterator& right) +{ + return left.eql( right ); +} + +bool operator!=(const Mapping::iterator& left, const Mapping::iterator& right) +{ + return left.neq( right ); +} + +// now for const_iterator +bool operator==(const Mapping::const_iterator& left, const Mapping::const_iterator& right) +{ + return left.eql( right ); +} + +bool operator!=(const Mapping::const_iterator& left, const Mapping::const_iterator& right) +{ + return left.neq( right ); +} + +// TMM: 31May'01 - Added the #ifndef so I can exclude iostreams. +#ifndef CXX_NO_IOSTREAMS +// output + +std::ostream& operator<< (std::ostream& os, const Object& ob) +{ + return (os << static_cast(ob.str())); +} +#endif + +} // Py diff --git a/src/extension/script/inkscape_py.i b/src/extension/script/inkscape_py.i deleted file mode 100644 index 32f3199a9..000000000 --- a/src/extension/script/inkscape_py.i +++ /dev/null @@ -1,6 +0,0 @@ -%module inkscape_py -%{ -#include "InkscapeBinding.h" -%} - -%include "InkscapeBinding.h" diff --git a/src/extension/script/inkscape_py.py b/src/extension/script/inkscape_py.py deleted file mode 100644 index 81eabccbf..000000000 --- a/src/extension/script/inkscape_py.py +++ /dev/null @@ -1,130 +0,0 @@ -# This file was created automatically by SWIG. -# Don't modify this file, modify the SWIG interface instead. -# This file is compatible with both classic and new-style classes. - -import _inkscape_py - -def _swig_setattr_nondynamic(self,class_type,name,value,static=1): - if (name == "this"): - if isinstance(value, class_type): - self.__dict__[name] = value.this - if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown - del value.thisown - return - method = class_type.__swig_setmethods__.get(name,None) - if method: return method(self,value) - if (not static) or hasattr(self,name) or (name == "thisown"): - self.__dict__[name] = value - else: - raise AttributeError("You cannot add attributes to %s" % self) - -def _swig_setattr(self,class_type,name,value): - return _swig_setattr_nondynamic(self,class_type,name,value,0) - -def _swig_getattr(self,class_type,name): - method = class_type.__swig_getmethods__.get(name,None) - if method: return method(self) - raise AttributeError,name - -import types -try: - _object = types.ObjectType - _newclass = 1 -except AttributeError: - class _object : pass - _newclass = 0 -del types - - - -getInkscape = _inkscape_py.getInkscape -class Inkscape(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, Inkscape, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, Inkscape, name) - def __init__(self): raise RuntimeError, "No constructor defined" - def __repr__(self): - return "<%s.%s; proxy of C++ Inkscape::Extension::Script::Inkscape instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) - def __del__(self, destroy=_inkscape_py.delete_Inkscape): - try: - if self.thisown: destroy(self) - except: pass - - def getDesktop(*args): return _inkscape_py.Inkscape_getDesktop(*args) - def getDialogManager(*args): return _inkscape_py.Inkscape_getDialogManager(*args) - -class InkscapePtr(Inkscape): - def __init__(self, this): - _swig_setattr(self, Inkscape, 'this', this) - if not hasattr(self,"thisown"): _swig_setattr(self, Inkscape, 'thisown', 0) - _swig_setattr(self, Inkscape,self.__class__,Inkscape) -_inkscape_py.Inkscape_swigregister(InkscapePtr) - -class DialogManager(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, DialogManager, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, DialogManager, name) - def __init__(self): raise RuntimeError, "No constructor defined" - def __repr__(self): - return "<%s.%s; proxy of C++ Inkscape::Extension::Script::DialogManager instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) - def __del__(self, destroy=_inkscape_py.delete_DialogManager): - try: - if self.thisown: destroy(self) - except: pass - - def showAbout(*args): return _inkscape_py.DialogManager_showAbout(*args) - -class DialogManagerPtr(DialogManager): - def __init__(self, this): - _swig_setattr(self, DialogManager, 'this', this) - if not hasattr(self,"thisown"): _swig_setattr(self, DialogManager, 'thisown', 0) - _swig_setattr(self, DialogManager,self.__class__,DialogManager) -_inkscape_py.DialogManager_swigregister(DialogManagerPtr) - -class Desktop(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, Desktop, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, Desktop, name) - def __init__(self): raise RuntimeError, "No constructor defined" - def __repr__(self): - return "<%s.%s; proxy of C++ Inkscape::Extension::Script::Desktop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) - def __del__(self, destroy=_inkscape_py.delete_Desktop): - try: - if self.thisown: destroy(self) - except: pass - - def getDocument(*args): return _inkscape_py.Desktop_getDocument(*args) - -class DesktopPtr(Desktop): - def __init__(self, this): - _swig_setattr(self, Desktop, 'this', this) - if not hasattr(self,"thisown"): _swig_setattr(self, Desktop, 'thisown', 0) - _swig_setattr(self, Desktop,self.__class__,Desktop) -_inkscape_py.Desktop_swigregister(DesktopPtr) - -class Document(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, Document, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, Document, name) - def __init__(self): raise RuntimeError, "No constructor defined" - def __repr__(self): - return "<%s.%s; proxy of C++ Inkscape::Extension::Script::Document instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) - def __del__(self, destroy=_inkscape_py.delete_Document): - try: - if self.thisown: destroy(self) - except: pass - - def hello(*args): return _inkscape_py.Document_hello(*args) - -class DocumentPtr(Document): - def __init__(self, this): - _swig_setattr(self, Document, 'this', this) - if not hasattr(self,"thisown"): _swig_setattr(self, Document, 'thisown', 0) - _swig_setattr(self, Document,self.__class__,Document) -_inkscape_py.Document_swigregister(DocumentPtr) - - diff --git a/src/extension/script/inkscape_py.py.h b/src/extension/script/inkscape_py.py.h deleted file mode 100644 index 50d432a1b..000000000 --- a/src/extension/script/inkscape_py.py.h +++ /dev/null @@ -1,139 +0,0 @@ - -/* ################################################### -## This file generated by quotefile.pl from -## inkscape_py.py on Thu Dec 16 15:35:46 2004 -## DO NOT EDIT -################################################### */ - -static char *inkscape_module_script = -"# This file was created automatically by SWIG.\n" -"# Don't modify this file, modify the SWIG interface instead.\n" -"# This file is compatible with both classic and new-style classes.\n" -"\n" -"import _inkscape_py\n" -"\n" -"def _swig_setattr_nondynamic(self,class_type,name,value,static=1):\n" -" if (name == \"this\"):\n" -" if isinstance(value, class_type):\n" -" self.__dict__[name] = value.this\n" -" if hasattr(value,\"thisown\"): self.__dict__[\"thisown\"] = value.thisown\n" -" del value.thisown\n" -" return\n" -" method = class_type.__swig_setmethods__.get(name,None)\n" -" if method: return method(self,value)\n" -" if (not static) or hasattr(self,name) or (name == \"thisown\"):\n" -" self.__dict__[name] = value\n" -" else:\n" -" raise AttributeError(\"You cannot add attributes to %s\" % self)\n" -"\n" -"def _swig_setattr(self,class_type,name,value):\n" -" return _swig_setattr_nondynamic(self,class_type,name,value,0)\n" -"\n" -"def _swig_getattr(self,class_type,name):\n" -" method = class_type.__swig_getmethods__.get(name,None)\n" -" if method: return method(self)\n" -" raise AttributeError,name\n" -"\n" -"import types\n" -"try:\n" -" _object = types.ObjectType\n" -" _newclass = 1\n" -"except AttributeError:\n" -" class _object : pass\n" -" _newclass = 0\n" -"del types\n" -"\n" -"\n" -"\n" -"getInkscape = _inkscape_py.getInkscape\n" -"class Inkscape(_object):\n" -" __swig_setmethods__ = {}\n" -" __setattr__ = lambda self, name, value: _swig_setattr(self, Inkscape, name, value)\n" -" __swig_getmethods__ = {}\n" -" __getattr__ = lambda self, name: _swig_getattr(self, Inkscape, name)\n" -" def __init__(self): raise RuntimeError, \"No constructor defined\"\n" -" def __repr__(self):\n" -" return \"<%s.%s; proxy of C++ Inkscape::Extension::Script::Inkscape instance at %s>\" % (self.__class__.__module__, self.__class__.__name__, self.this,)\n" -" def __del__(self, destroy=_inkscape_py.delete_Inkscape):\n" -" try:\n" -" if self.thisown: destroy(self)\n" -" except: pass\n" -"\n" -" def getDesktop(*args): return _inkscape_py.Inkscape_getDesktop(*args)\n" -" def getDialogManager(*args): return _inkscape_py.Inkscape_getDialogManager(*args)\n" -"\n" -"class InkscapePtr(Inkscape):\n" -" def __init__(self, this):\n" -" _swig_setattr(self, Inkscape, 'this', this)\n" -" if not hasattr(self,\"thisown\"): _swig_setattr(self, Inkscape, 'thisown', 0)\n" -" _swig_setattr(self, Inkscape,self.__class__,Inkscape)\n" -"_inkscape_py.Inkscape_swigregister(InkscapePtr)\n" -"\n" -"class DialogManager(_object):\n" -" __swig_setmethods__ = {}\n" -" __setattr__ = lambda self, name, value: _swig_setattr(self, DialogManager, name, value)\n" -" __swig_getmethods__ = {}\n" -" __getattr__ = lambda self, name: _swig_getattr(self, DialogManager, name)\n" -" def __init__(self): raise RuntimeError, \"No constructor defined\"\n" -" def __repr__(self):\n" -" return \"<%s.%s; proxy of C++ Inkscape::Extension::Script::DialogManager instance at %s>\" % (self.__class__.__module__, self.__class__.__name__, self.this,)\n" -" def __del__(self, destroy=_inkscape_py.delete_DialogManager):\n" -" try:\n" -" if self.thisown: destroy(self)\n" -" except: pass\n" -"\n" -" def showAbout(*args): return _inkscape_py.DialogManager_showAbout(*args)\n" -"\n" -"class DialogManagerPtr(DialogManager):\n" -" def __init__(self, this):\n" -" _swig_setattr(self, DialogManager, 'this', this)\n" -" if not hasattr(self,\"thisown\"): _swig_setattr(self, DialogManager, 'thisown', 0)\n" -" _swig_setattr(self, DialogManager,self.__class__,DialogManager)\n" -"_inkscape_py.DialogManager_swigregister(DialogManagerPtr)\n" -"\n" -"class Desktop(_object):\n" -" __swig_setmethods__ = {}\n" -" __setattr__ = lambda self, name, value: _swig_setattr(self, Desktop, name, value)\n" -" __swig_getmethods__ = {}\n" -" __getattr__ = lambda self, name: _swig_getattr(self, Desktop, name)\n" -" def __init__(self): raise RuntimeError, \"No constructor defined\"\n" -" def __repr__(self):\n" -" return \"<%s.%s; proxy of C++ Inkscape::Extension::Script::Desktop instance at %s>\" % (self.__class__.__module__, self.__class__.__name__, self.this,)\n" -" def __del__(self, destroy=_inkscape_py.delete_Desktop):\n" -" try:\n" -" if self.thisown: destroy(self)\n" -" except: pass\n" -"\n" -" def getDocument(*args): return _inkscape_py.Desktop_getDocument(*args)\n" -"\n" -"class DesktopPtr(Desktop):\n" -" def __init__(self, this):\n" -" _swig_setattr(self, Desktop, 'this', this)\n" -" if not hasattr(self,\"thisown\"): _swig_setattr(self, Desktop, 'thisown', 0)\n" -" _swig_setattr(self, Desktop,self.__class__,Desktop)\n" -"_inkscape_py.Desktop_swigregister(DesktopPtr)\n" -"\n" -"class Document(_object):\n" -" __swig_setmethods__ = {}\n" -" __setattr__ = lambda self, name, value: _swig_setattr(self, Document, name, value)\n" -" __swig_getmethods__ = {}\n" -" __getattr__ = lambda self, name: _swig_getattr(self, Document, name)\n" -" def __init__(self): raise RuntimeError, \"No constructor defined\"\n" -" def __repr__(self):\n" -" return \"<%s.%s; proxy of C++ Inkscape::Extension::Script::Document instance at %s>\" % (self.__class__.__module__, self.__class__.__name__, self.this,)\n" -" def __del__(self, destroy=_inkscape_py.delete_Document):\n" -" try:\n" -" if self.thisown: destroy(self)\n" -" except: pass\n" -"\n" -" def hello(*args): return _inkscape_py.Document_hello(*args)\n" -"\n" -"class DocumentPtr(Document):\n" -" def __init__(self, this):\n" -" _swig_setattr(self, Document, 'this', this)\n" -" if not hasattr(self,\"thisown\"): _swig_setattr(self, Document, 'thisown', 0)\n" -" _swig_setattr(self, Document,self.__class__,Document)\n" -"_inkscape_py.Document_swigregister(DocumentPtr)\n" -"\n" -"\n" -""; diff --git a/src/extension/script/inkscape_py_wrap.cpp b/src/extension/script/inkscape_py_wrap.cpp deleted file mode 100644 index 49afe508c..000000000 --- a/src/extension/script/inkscape_py_wrap.cpp +++ /dev/null @@ -1,1408 +0,0 @@ -/* ---------------------------------------------------------------------------- - * This file was automatically generated by SWIG (http://www.swig.org). - * Version 1.3.23 - * - * This file is not intended to be easily readable and contains a number of - * coding conventions designed to improve portability and efficiency. Do not make - * changes to this file unless you know what you are doing--modify the SWIG - * interface file instead. - * ----------------------------------------------------------------------------- */ - -#define SWIGPYTHON - -#ifdef __cplusplus -template class SwigValueWrapper { - T *tt; -public: - SwigValueWrapper() : tt(0) { } - SwigValueWrapper(const SwigValueWrapper& rhs) : tt(new T(*rhs.tt)) { } - SwigValueWrapper(const T& t) : tt(new T(t)) { } - ~SwigValueWrapper() { delete tt; } - SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; } - operator T&() const { return *tt; } - T *operator&() { return tt; } -private: - SwigValueWrapper& operator=(const SwigValueWrapper& rhs); -}; -#endif - - -#ifndef SWIG_TEMPLATE_DISAMBIGUATOR -# if defined(__SUNPRO_CC) -# define SWIG_TEMPLATE_DISAMBIGUATOR template -# else -# define SWIG_TEMPLATE_DISAMBIGUATOR -# endif -#endif - - -#include - -/*********************************************************************** - * common.swg - * - * This file contains generic SWIG runtime support for pointer - * type checking as well as a few commonly used macros to control - * external linkage. - * - * Author : David Beazley (beazley@cs.uchicago.edu) - * - * Copyright (c) 1999-2000, The University of Chicago - * - * This file may be freely redistributed without license or fee provided - * this copyright message remains intact. - ************************************************************************/ - -#include - -#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# if !defined(STATIC_LINKED) -# define SWIGEXPORT(a) __declspec(dllexport) a -# else -# define SWIGEXPORT(a) a -# endif -#else -# define SWIGEXPORT(a) a -#endif - -#define SWIGRUNTIME(x) static x - -#ifndef SWIGINLINE -#if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) -# define SWIGINLINE inline -#else -# define SWIGINLINE -#endif -#endif - - -/* This should only be incremented when either the layout of swig_type_info changes, - or for whatever reason, the runtime changes incompatibly */ -#define SWIG_RUNTIME_VERSION "1" - -/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ -#ifdef SWIG_TYPE_TABLE -#define SWIG_QUOTE_STRING(x) #x -#define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) -#define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) -#else -#define SWIG_TYPE_TABLE_NAME -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void *(*swig_converter_func)(void *); -typedef struct swig_type_info *(*swig_dycast_func)(void **); - -typedef struct swig_type_info { - const char *name; - swig_converter_func converter; - const char *str; - void *clientdata; - swig_dycast_func dcast; - struct swig_type_info *next; - struct swig_type_info *prev; -} swig_type_info; - -static swig_type_info *swig_type_list = 0; -static swig_type_info **swig_type_list_handle = &swig_type_list; - -/* - Compare two type names skipping the space characters, therefore - "char*" == "char *" and "Class" == "Class", etc. - - Return 0 when the two name types are equivalent, as in - strncmp, but skipping ' '. -*/ -static int -SWIG_TypeNameComp(const char *f1, const char *l1, - const char *f2, const char *l2) { - for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { - while ((*f1 == ' ') && (f1 != l1)) ++f1; - while ((*f2 == ' ') && (f2 != l2)) ++f2; - if (*f1 != *f2) return *f1 - *f2; - } - return (l1 - f1) - (l2 - f2); -} - -/* - Check type equivalence in a name list like ||... -*/ -static int -SWIG_TypeEquiv(const char *nb, const char *tb) { - int equiv = 0; - const char* te = tb + strlen(tb); - const char* ne = nb; - while (!equiv && *ne) { - for (nb = ne; *ne; ++ne) { - if (*ne == '|') break; - } - equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0; - if (*ne) ++ne; - } - return equiv; -} - - -/* Register a type mapping with the type-checking */ -static swig_type_info * -SWIG_TypeRegister(swig_type_info *ti) { - swig_type_info *tc, *head, *ret, *next; - /* Check to see if this type has already been registered */ - tc = *swig_type_list_handle; - while (tc) { - /* check simple type equivalence */ - int typeequiv = (strcmp(tc->name, ti->name) == 0); - /* check full type equivalence, resolving typedefs */ - if (!typeequiv) { - /* only if tc is not a typedef (no '|' on it) */ - if (tc->str && ti->str && !strstr(tc->str,"|")) { - typeequiv = SWIG_TypeEquiv(ti->str,tc->str); - } - } - if (typeequiv) { - /* Already exists in the table. Just add additional types to the list */ - if (ti->clientdata) tc->clientdata = ti->clientdata; - head = tc; - next = tc->next; - goto l1; - } - tc = tc->prev; - } - head = ti; - next = 0; - - /* Place in list */ - ti->prev = *swig_type_list_handle; - *swig_type_list_handle = ti; - - /* Build linked lists */ - l1: - ret = head; - tc = ti + 1; - /* Patch up the rest of the links */ - while (tc->name) { - head->next = tc; - tc->prev = head; - head = tc; - tc++; - } - if (next) next->prev = head; - head->next = next; - - return ret; -} - -/* Check the typename */ -static swig_type_info * -SWIG_TypeCheck(char *c, swig_type_info *ty) { - swig_type_info *s; - if (!ty) return 0; /* Void pointer */ - s = ty->next; /* First element always just a name */ - do { - if (strcmp(s->name,c) == 0) { - if (s == ty->next) return s; - /* Move s to the top of the linked list */ - s->prev->next = s->next; - if (s->next) { - s->next->prev = s->prev; - } - /* Insert s as second element in the list */ - s->next = ty->next; - if (ty->next) ty->next->prev = s; - ty->next = s; - s->prev = ty; - return s; - } - s = s->next; - } while (s && (s != ty->next)); - return 0; -} - -/* Cast a pointer up an inheritance hierarchy */ -static SWIGINLINE void * -SWIG_TypeCast(swig_type_info *ty, void *ptr) { - if ((!ty) || (!ty->converter)) return ptr; - return (*ty->converter)(ptr); -} - -/* Dynamic pointer casting. Down an inheritance hierarchy */ -static swig_type_info * -SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { - swig_type_info *lastty = ty; - if (!ty || !ty->dcast) return ty; - while (ty && (ty->dcast)) { - ty = (*ty->dcast)(ptr); - if (ty) lastty = ty; - } - return lastty; -} - -/* Return the name associated with this type */ -static SWIGINLINE const char * -SWIG_TypeName(const swig_type_info *ty) { - return ty->name; -} - -/* Return the pretty name associated with this type, - that is an unmangled type name in a form presentable to the user. -*/ -static const char * -SWIG_TypePrettyName(const swig_type_info *type) { - /* The "str" field contains the equivalent pretty names of the - type, separated by vertical-bar characters. We choose - to print the last name, as it is often (?) the most - specific. */ - if (type->str != NULL) { - const char *last_name = type->str; - const char *s; - for (s = type->str; *s; s++) - if (*s == '|') last_name = s+1; - return last_name; - } - else - return type->name; -} - -/* Search for a swig_type_info structure */ -static swig_type_info * -SWIG_TypeQuery(const char *name) { - swig_type_info *ty = *swig_type_list_handle; - while (ty) { - if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty; - if (ty->name && (strcmp(name,ty->name) == 0)) return ty; - ty = ty->prev; - } - return 0; -} - -/* Set the clientdata field for a type */ -static void -SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { - swig_type_info *tc, *equiv; - if (ti->clientdata) return; - /* if (ti->clientdata == clientdata) return; */ - ti->clientdata = clientdata; - equiv = ti->next; - while (equiv) { - if (!equiv->converter) { - tc = *swig_type_list_handle; - while (tc) { - if ((strcmp(tc->name, equiv->name) == 0)) - SWIG_TypeClientData(tc,clientdata); - tc = tc->prev; - } - } - equiv = equiv->next; - } -} - -/* Pack binary data into a string */ -static char * -SWIG_PackData(char *c, void *ptr, size_t sz) { - static char hex[17] = "0123456789abcdef"; - unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - register unsigned char uu; - for (; u != eu; ++u) { - uu = *u; - *(c++) = hex[(uu & 0xf0) >> 4]; - *(c++) = hex[uu & 0xf]; - } - return c; -} - -/* Unpack binary data from a string */ -static char * -SWIG_UnpackData(char *c, void *ptr, size_t sz) { - register unsigned char uu = 0; - register int d; - unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - d = *(c++); - if ((d >= '0') && (d <= '9')) - uu = ((d - '0') << 4); - else if ((d >= 'a') && (d <= 'f')) - uu = ((d - ('a'-10)) << 4); - d = *(c++); - if ((d >= '0') && (d <= '9')) - uu |= (d - '0'); - else if ((d >= 'a') && (d <= 'f')) - uu |= (d - ('a'-10)); - *u = uu; - } - return c; -} - -/* This function will propagate the clientdata field of type to -* any new swig_type_info structures that have been added into the list -* of equivalent types. It is like calling -* SWIG_TypeClientData(type, clientdata) a second time. -*/ -static void -SWIG_PropagateClientData(swig_type_info *type) { - swig_type_info *equiv = type->next; - swig_type_info *tc; - if (!type->clientdata) return; - while (equiv) { - if (!equiv->converter) { - tc = *swig_type_list_handle; - while (tc) { - if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata) - SWIG_TypeClientData(tc, type->clientdata); - tc = tc->prev; - } - } - equiv = equiv->next; - } -} - -#ifdef __cplusplus -} -#endif - -/* ----------------------------------------------------------------------------- - * SWIG API. Portion that goes into the runtime - * ----------------------------------------------------------------------------- */ - -#ifdef __cplusplus -extern "C" { -#endif - -/* ----------------------------------------------------------------------------- - * for internal method declarations - * ----------------------------------------------------------------------------- */ - -#ifndef SWIGINTERN -#define SWIGINTERN static -#endif - -#ifndef SWIGINTERNSHORT -#ifdef __cplusplus -#define SWIGINTERNSHORT static inline -#else /* C case */ -#define SWIGINTERNSHORT static -#endif /* __cplusplus */ -#endif - - -/* Common SWIG API */ -#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags) -#define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags) -#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) - -/* Python-specific SWIG API */ -#define SWIG_newvarlink() SWIG_Python_newvarlink() -#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) -#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags) -#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) -#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) - -/* - Exception handling in wrappers -*/ -#define SWIG_fail goto fail -#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) -#define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0) -#define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1) -#define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj) -#define SWIG_null_ref(type) SWIG_Python_NullRef(type) - -/* - Contract support -*/ -#define SWIG_contract_assert(expr, msg) \ - if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else - -/* ----------------------------------------------------------------------------- - * Constant declarations - * ----------------------------------------------------------------------------- */ - -/* Constant Types */ -#define SWIG_PY_INT 1 -#define SWIG_PY_FLOAT 2 -#define SWIG_PY_STRING 3 -#define SWIG_PY_POINTER 4 -#define SWIG_PY_BINARY 5 - -/* Constant information structure */ -typedef struct swig_const_info { - int type; - char *name; - long lvalue; - double dvalue; - void *pvalue; - swig_type_info **ptype; -} swig_const_info; - -/* ----------------------------------------------------------------------------- - * Pointer declarations - * ----------------------------------------------------------------------------- */ -/* - Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent - C/C++ pointers in the python side. Very useful for debugging, but - not always safe. -*/ -#if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES) -# define SWIG_COBJECT_TYPES -#endif - -/* Flags for pointer conversion */ -#define SWIG_POINTER_EXCEPTION 0x1 -#define SWIG_POINTER_DISOWN 0x2 - -/* ----------------------------------------------------------------------------- - * Alloc. memory flags - * ----------------------------------------------------------------------------- */ -#define SWIG_OLDOBJ 1 -#define SWIG_NEWOBJ SWIG_OLDOBJ + 1 -#define SWIG_PYSTR SWIG_NEWOBJ + 1 - -#ifdef __cplusplus -} -#endif - - -/*********************************************************************** - * pyrun.swg - * - * This file contains the runtime support for Python modules - * and includes code for managing global variables and pointer - * type checking. - * - * Author : David Beazley (beazley@cs.uchicago.edu) - ************************************************************************/ - -#ifdef __cplusplus -extern "C" { -#endif - -/* ----------------------------------------------------------------------------- - * global variable support code. - * ----------------------------------------------------------------------------- */ - -typedef struct swig_globalvar { - char *name; /* Name of global variable */ - PyObject *(*get_attr)(); /* Return the current value */ - int (*set_attr)(PyObject *); /* Set the value */ - struct swig_globalvar *next; -} swig_globalvar; - -typedef struct swig_varlinkobject { - PyObject_HEAD - swig_globalvar *vars; -} swig_varlinkobject; - -static PyObject * -swig_varlink_repr(swig_varlinkobject *v) { - v = v; - return PyString_FromString(""); -} - -static int -swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) { - swig_globalvar *var; - flags = flags; - fprintf(fp,"Global variables { "); - for (var = v->vars; var; var=var->next) { - fprintf(fp,"%s", var->name); - if (var->next) fprintf(fp,", "); - } - fprintf(fp," }\n"); - return 0; -} - -static PyObject * -swig_varlink_getattr(swig_varlinkobject *v, char *n) { - swig_globalvar *var = v->vars; - while (var) { - if (strcmp(var->name,n) == 0) { - return (*var->get_attr)(); - } - var = var->next; - } - PyErr_SetString(PyExc_NameError,"Unknown C global variable"); - return NULL; -} - -static int -swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { - swig_globalvar *var = v->vars; - while (var) { - if (strcmp(var->name,n) == 0) { - return (*var->set_attr)(p); - } - var = var->next; - } - PyErr_SetString(PyExc_NameError,"Unknown C global variable"); - return 1; -} - -static PyTypeObject varlinktype = { - PyObject_HEAD_INIT(0) - 0, /* Number of items in variable part (ob_size) */ - (char *)"swigvarlink", /* Type name (tp_name) */ - sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */ - 0, /* Itemsize (tp_itemsize) */ - 0, /* Deallocator (tp_dealloc) */ - (printfunc) swig_varlink_print, /* Print (tp_print) */ - (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */ - (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */ - 0, /* tp_compare */ - (reprfunc) swig_varlink_repr, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - 0, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - 0, /* tp_flags */ - 0, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ -#if PY_VERSION_HEX >= 0x02020000 - 0, /* tp_iter */ - 0, /* tp_iternext */ - 0, /* tp_methods */ - 0, /* tp_members */ - 0, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - 0, /* tp_init */ - 0, /* tp_alloc */ - 0, /* tp_new */ - 0, /* tp_free */ - 0, /* tp_is_gc */ - 0, /* tp_bases */ - 0, /* tp_mro */ - 0, /* tp_cache */ - 0, /* tp_subclasses */ - 0, /* tp_weaklist */ -#endif -#if PY_VERSION_HEX >= 0x02030000 - 0, /* tp_del */ -#endif -#ifdef COUNT_ALLOCS - /* these must be last */ - 0, /* tp_alloc */ - 0, /* tp_free */ - 0, /* tp_maxalloc */ - 0, /* tp_next */ -#endif -}; - -/* Create a variable linking object for use later */ -static PyObject * -SWIG_Python_newvarlink(void) { - swig_varlinkobject *result = 0; - result = PyMem_NEW(swig_varlinkobject,1); - varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */ - result->ob_type = &varlinktype; - result->vars = 0; - result->ob_refcnt = 0; - Py_XINCREF((PyObject *) result); - return ((PyObject*) result); -} - -static void -SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { - swig_varlinkobject *v; - swig_globalvar *gv; - v= (swig_varlinkobject *) p; - gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); - gv->name = (char *) malloc(strlen(name)+1); - strcpy(gv->name,name); - gv->get_attr = get_attr; - gv->set_attr = set_attr; - gv->next = v->vars; - v->vars = gv; -} - -/* ----------------------------------------------------------------------------- - * errors manipulation - * ----------------------------------------------------------------------------- */ - -static void -SWIG_Python_TypeError(const char *type, PyObject *obj) -{ - if (type) { - if (!PyCObject_Check(obj)) { - const char *otype = (obj ? obj->ob_type->tp_name : 0); - if (otype) { - PyObject *str = PyObject_Str(obj); - const char *cstr = str ? PyString_AsString(str) : 0; - if (cstr) { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", - type, otype, cstr); - } else { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", - type, otype); - } - Py_DECREF(str); - return; - } - } else { - const char *otype = (char *) PyCObject_GetDesc(obj); - if (otype) { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PyCObject(%s)' is received", - type, otype); - return; - } - } - PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); - - } else { - PyErr_Format(PyExc_TypeError, "unexpected type is received"); - } -} - -static SWIGINLINE void -SWIG_Python_NullRef(const char *type) -{ - if (type) { - PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type); - } else { - PyErr_Format(PyExc_TypeError, "null reference was received"); - } -} - -static int -SWIG_Python_AddErrMesg(const char* mesg, int infront) -{ - if (PyErr_Occurred()) { - PyObject *type = 0; - PyObject *value = 0; - PyObject *traceback = 0; - PyErr_Fetch(&type, &value, &traceback); - if (value) { - PyObject *old_str = PyObject_Str(value); - Py_XINCREF(type); - PyErr_Clear(); - if (infront) { - PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str)); - } else { - PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); - } - Py_DECREF(old_str); - } - return 1; - } else { - return 0; - } -} - -static int -SWIG_Python_ArgFail(int argnum) -{ - if (PyErr_Occurred()) { - /* add information about failing argument */ - char mesg[256]; - sprintf(mesg, "argument number %d:", argnum); - return SWIG_Python_AddErrMesg(mesg, 1); - } else { - return 0; - } -} - - -/* ----------------------------------------------------------------------------- - * pointers/data manipulation - * ----------------------------------------------------------------------------- */ - -/* Convert a pointer value */ -static int -SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) { - swig_type_info *tc; - char *c = 0; - static PyObject *SWIG_this = 0; - int newref = 0; - PyObject *pyobj = 0; - void *vptr; - - if (!obj) return 0; - if (obj == Py_None) { - *ptr = 0; - return 0; - } - -#ifdef SWIG_COBJECT_TYPES - if (!(PyCObject_Check(obj))) { - if (!SWIG_this) - SWIG_this = PyString_FromString("this"); - pyobj = obj; - obj = PyObject_GetAttr(obj,SWIG_this); - newref = 1; - if (!obj) goto type_error; - if (!PyCObject_Check(obj)) { - Py_DECREF(obj); - goto type_error; - } - } - vptr = PyCObject_AsVoidPtr(obj); - c = (char *) PyCObject_GetDesc(obj); - if (newref) Py_DECREF(obj); - goto type_check; -#else - if (!(PyString_Check(obj))) { - if (!SWIG_this) - SWIG_this = PyString_FromString("this"); - pyobj = obj; - obj = PyObject_GetAttr(obj,SWIG_this); - newref = 1; - if (!obj) goto type_error; - if (!PyString_Check(obj)) { - Py_DECREF(obj); - goto type_error; - } - } - c = PyString_AS_STRING(obj); - /* Pointer values must start with leading underscore */ - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - if (newref) { Py_DECREF(obj); } - *ptr = (void *) 0; - return 0; - } else { - if (newref) { Py_DECREF(obj); } - goto type_error; - } - } - c++; - c = SWIG_UnpackData(c,&vptr,sizeof(void *)); - if (newref) { Py_DECREF(obj); } -#endif - -type_check: - - if (ty) { - tc = SWIG_TypeCheck(c,ty); - if (!tc) goto type_error; - *ptr = SWIG_TypeCast(tc,vptr); - } - - if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) { - PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False); - } - return 0; - -type_error: - PyErr_Clear(); - if (pyobj && !obj) { - obj = pyobj; - if (PyCFunction_Check(obj)) { - /* here we get the method pointer for callbacks */ - char *doc = (char *) (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); - c = doc ? strstr(doc, "swig_ptr: ") : 0; - if (c) { - c += 10; - if (*c == '_') { - c++; - c = SWIG_UnpackData(c,&vptr,sizeof(void *)); - goto type_check; - } - } - } - } - if (flags & SWIG_POINTER_EXCEPTION) { - if (ty) { - SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); - } else { - SWIG_Python_TypeError("C/C++ pointer", obj); - } - } - return -1; -} - -/* Convert a pointer value, signal an exception on a type mismatch */ -static void * -SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) { - void *result; - if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { - PyErr_Clear(); - if (flags & SWIG_POINTER_EXCEPTION) { - SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); - SWIG_Python_ArgFail(argnum); - } - } - return result; -} - -/* Convert a packed value value */ -static int -SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) { - swig_type_info *tc; - char *c = 0; - - if ((!obj) || (!PyString_Check(obj))) goto type_error; - c = PyString_AS_STRING(obj); - /* Pointer values must start with leading underscore */ - if (*c != '_') goto type_error; - c++; - c = SWIG_UnpackData(c,ptr,sz); - if (ty) { - tc = SWIG_TypeCheck(c,ty); - if (!tc) goto type_error; - } - return 0; - -type_error: - PyErr_Clear(); - if (flags & SWIG_POINTER_EXCEPTION) { - if (ty) { - SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); - } else { - SWIG_Python_TypeError("C/C++ packed data", obj); - } - } - return -1; -} - -/* Create a new pointer string */ -static char * -SWIG_Python_PointerStr(char *buff, void *ptr, const char *name, size_t bsz) { - char *r = buff; - if ((2*sizeof(void *) + 2) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,&ptr,sizeof(void *)); - if (strlen(name) + 1 > (bsz - (r - buff))) return 0; - strcpy(r,name); - return buff; -} - - -/* Create a new pointer object */ -static PyObject * -SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) { - PyObject *robj; - if (!ptr) { - Py_INCREF(Py_None); - return Py_None; - } -#ifdef SWIG_COBJECT_TYPES - robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL); -#else - { - char result[1024]; - SWIG_Python_PointerStr(result, ptr, type->name, 1024); - robj = PyString_FromString(result); - } -#endif - if (!robj || (robj == Py_None)) return robj; - if (type->clientdata) { - PyObject *inst; - PyObject *args = Py_BuildValue((char*)"(O)", robj); - Py_DECREF(robj); - inst = PyObject_CallObject((PyObject *) type->clientdata, args); - Py_DECREF(args); - if (inst) { - if (own) { - PyObject_SetAttrString(inst,(char*)"thisown",Py_True); - } - robj = inst; - } - } - return robj; -} - -static PyObject * -SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { - char result[1024]; - char *r = result; - if ((2*sz + 2 + strlen(type->name)) > 1024) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,ptr,sz); - strcpy(r,type->name); - return PyString_FromString(result); -} - - -/* ----------------------------------------------------------------------------- - * constants/methods manipulation - * ----------------------------------------------------------------------------- */ - -/* Install Constants */ -static void -SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { - int i; - PyObject *obj; - for (i = 0; constants[i].type; i++) { - switch(constants[i].type) { - case SWIG_PY_INT: - obj = PyInt_FromLong(constants[i].lvalue); - break; - case SWIG_PY_FLOAT: - obj = PyFloat_FromDouble(constants[i].dvalue); - break; - case SWIG_PY_STRING: - if (constants[i].pvalue) { - obj = PyString_FromString((char *) constants[i].pvalue); - } else { - Py_INCREF(Py_None); - obj = Py_None; - } - break; - case SWIG_PY_POINTER: - obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); - break; - case SWIG_PY_BINARY: - obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); - break; - default: - obj = 0; - break; - } - if (obj) { - PyDict_SetItemString(d,constants[i].name,obj); - Py_DECREF(obj); - } - } -} - -/* Fix SwigMethods to carry the callback ptrs when needed */ -static void -SWIG_Python_FixMethods(PyMethodDef *methods, - swig_const_info *const_table, - swig_type_info **types, - swig_type_info **types_initial) { - int i; - for (i = 0; methods[i].ml_name; ++i) { - char *c = (char *) methods[i].ml_doc; - if (c && (c = strstr(c, "swig_ptr: "))) { - int j; - swig_const_info *ci = 0; - char *name = c + 10; - for (j = 0; const_table[j].type; j++) { - if (strncmp(const_table[j].name, name, - strlen(const_table[j].name)) == 0) { - ci = &(const_table[j]); - break; - } - } - if (ci) { - size_t shift = (ci->ptype) - types; - swig_type_info *ty = types_initial[shift]; - size_t ldoc = (c - methods[i].ml_doc); - size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; - char *ndoc = (char*)malloc(ldoc + lptr + 10); - char *buff = ndoc; - void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue); - strncpy(buff, methods[i].ml_doc, ldoc); - buff += ldoc; - strncpy(buff, "swig_ptr: ", 10); - buff += 10; - SWIG_Python_PointerStr(buff, ptr, ty->name, lptr); - methods[i].ml_doc = ndoc; - } - } - } -} - - -/* ----------------------------------------------------------------------------- - * Lookup type pointer - * ----------------------------------------------------------------------------- */ -#if PY_MAJOR_VERSION < 2 -/* PyModule_AddObject function was introduced in Python 2.0. The following function -is copied out of Python/modsupport.c in python version 2.3.4 */ -static int -PyModule_AddObject(PyObject *m, char *name, PyObject *o) -{ - PyObject *dict; - if (!PyModule_Check(m)) { - PyErr_SetString(PyExc_TypeError, - "PyModule_AddObject() needs module as first arg"); - return -1; - } - if (!o) { - PyErr_SetString(PyExc_TypeError, - "PyModule_AddObject() needs non-NULL value"); - return -1; - } - - dict = PyModule_GetDict(m); - if (dict == NULL) { - /* Internal error -- modules must have a dict! */ - PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", - PyModule_GetName(m)); - return -1; - } - if (PyDict_SetItemString(dict, name, o)) - return -1; - Py_DECREF(o); - return 0; -} -#endif -static PyMethodDef swig_empty_runtime_method_table[] = { - {NULL, NULL, 0, NULL} /* Sentinel */ -}; - -static void -SWIG_Python_LookupTypePointer(swig_type_info ***type_list_handle) { - PyObject *module, *pointer; - void *type_pointer; - - /* first check if module already created */ - type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); - if (type_pointer) { - *type_list_handle = (swig_type_info **) type_pointer; - } else { - PyErr_Clear(); - /* create a new module and variable */ - module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); - pointer = PyCObject_FromVoidPtr((void *) (*type_list_handle), NULL); - if (pointer && module) { - PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); - } - } -} - -#ifdef __cplusplus -} -#endif - - -/* -------- TYPES TABLE (BEGIN) -------- */ - -#define SWIGTYPE_p_Inkscape__Extension__Script__Desktop swig_types[0] -#define SWIGTYPE_p_Inkscape__Extension__Script__Inkscape swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_Inkscape__Extension__Script__DialogManager swig_types[3] -#define SWIGTYPE_size_t swig_types[4] -#define SWIGTYPE_std__size_t swig_types[5] -#define SWIGTYPE_p_Inkscape__Extension__Script__Document swig_types[6] -#define SWIGTYPE_ptrdiff_t swig_types[7] -#define SWIGTYPE_std__ptrdiff_t swig_types[8] -static swig_type_info *swig_types[10]; - -/* -------- TYPES TABLE (END) -------- */ - - -/*----------------------------------------------- - @(target):= _inkscape_py.so - ------------------------------------------------*/ -#define SWIG_init init_inkscape_py - -#define SWIG_name "_inkscape_py" - -#include "InkscapeBinding.h" - -#ifdef __cplusplus -extern "C" { -#endif -static PyObject *_wrap_getInkscape(PyObject *, PyObject *args) { - PyObject *resultobj; - Inkscape::Extension::Script::Inkscape *result; - - if(!PyArg_ParseTuple(args,(char *)":getInkscape")) goto fail; - result = (Inkscape::Extension::Script::Inkscape *)Inkscape::Extension::Script::getInkscape(); - - resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_Inkscape__Extension__Script__Inkscape, 0); - return resultobj; - fail: - return NULL; -} - - -static PyObject *_wrap_delete_Inkscape(PyObject *, PyObject *args) { - PyObject *resultobj; - Inkscape::Extension::Script::Inkscape *arg1 = (Inkscape::Extension::Script::Inkscape *) 0 ; - PyObject * obj0 = 0 ; - - if(!PyArg_ParseTuple(args,(char *)"O:delete_Inkscape",&obj0)) goto fail; - SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Inkscape__Extension__Script__Inkscape, SWIG_POINTER_EXCEPTION | 0); - if (SWIG_arg_fail(1)) SWIG_fail; - delete arg1; - - Py_INCREF(Py_None); resultobj = Py_None; - return resultobj; - fail: - return NULL; -} - - -static PyObject *_wrap_Inkscape_getDesktop(PyObject *, PyObject *args) { - PyObject *resultobj; - Inkscape::Extension::Script::Inkscape *arg1 = (Inkscape::Extension::Script::Inkscape *) 0 ; - Inkscape::Extension::Script::Desktop *result; - PyObject * obj0 = 0 ; - - if(!PyArg_ParseTuple(args,(char *)"O:Inkscape_getDesktop",&obj0)) goto fail; - SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Inkscape__Extension__Script__Inkscape, SWIG_POINTER_EXCEPTION | 0); - if (SWIG_arg_fail(1)) SWIG_fail; - result = (Inkscape::Extension::Script::Desktop *)(arg1)->getDesktop(); - - resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_Inkscape__Extension__Script__Desktop, 0); - return resultobj; - fail: - return NULL; -} - - -static PyObject *_wrap_Inkscape_getDialogManager(PyObject *, PyObject *args) { - PyObject *resultobj; - Inkscape::Extension::Script::Inkscape *arg1 = (Inkscape::Extension::Script::Inkscape *) 0 ; - Inkscape::Extension::Script::DialogManager *result; - PyObject * obj0 = 0 ; - - if(!PyArg_ParseTuple(args,(char *)"O:Inkscape_getDialogManager",&obj0)) goto fail; - SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Inkscape__Extension__Script__Inkscape, SWIG_POINTER_EXCEPTION | 0); - if (SWIG_arg_fail(1)) SWIG_fail; - result = (Inkscape::Extension::Script::DialogManager *)(arg1)->getDialogManager(); - - resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_Inkscape__Extension__Script__DialogManager, 0); - return resultobj; - fail: - return NULL; -} - - -static PyObject * Inkscape_swigregister(PyObject *, PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL; - SWIG_TypeClientData(SWIGTYPE_p_Inkscape__Extension__Script__Inkscape, obj); - Py_INCREF(obj); - return Py_BuildValue((char *)""); -} -static PyObject *_wrap_delete_DialogManager(PyObject *, PyObject *args) { - PyObject *resultobj; - Inkscape::Extension::Script::DialogManager *arg1 = (Inkscape::Extension::Script::DialogManager *) 0 ; - PyObject * obj0 = 0 ; - - if(!PyArg_ParseTuple(args,(char *)"O:delete_DialogManager",&obj0)) goto fail; - SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Inkscape__Extension__Script__DialogManager, SWIG_POINTER_EXCEPTION | 0); - if (SWIG_arg_fail(1)) SWIG_fail; - delete arg1; - - Py_INCREF(Py_None); resultobj = Py_None; - return resultobj; - fail: - return NULL; -} - - -static PyObject *_wrap_DialogManager_showAbout(PyObject *, PyObject *args) { - PyObject *resultobj; - Inkscape::Extension::Script::DialogManager *arg1 = (Inkscape::Extension::Script::DialogManager *) 0 ; - PyObject * obj0 = 0 ; - - if(!PyArg_ParseTuple(args,(char *)"O:DialogManager_showAbout",&obj0)) goto fail; - SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Inkscape__Extension__Script__DialogManager, SWIG_POINTER_EXCEPTION | 0); - if (SWIG_arg_fail(1)) SWIG_fail; - (arg1)->showAbout(); - - Py_INCREF(Py_None); resultobj = Py_None; - return resultobj; - fail: - return NULL; -} - - -static PyObject * DialogManager_swigregister(PyObject *, PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL; - SWIG_TypeClientData(SWIGTYPE_p_Inkscape__Extension__Script__DialogManager, obj); - Py_INCREF(obj); - return Py_BuildValue((char *)""); -} -static PyObject *_wrap_delete_Desktop(PyObject *, PyObject *args) { - PyObject *resultobj; - Inkscape::Extension::Script::Desktop *arg1 = (Inkscape::Extension::Script::Desktop *) 0 ; - PyObject * obj0 = 0 ; - - if(!PyArg_ParseTuple(args,(char *)"O:delete_Desktop",&obj0)) goto fail; - SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Inkscape__Extension__Script__Desktop, SWIG_POINTER_EXCEPTION | 0); - if (SWIG_arg_fail(1)) SWIG_fail; - delete arg1; - - Py_INCREF(Py_None); resultobj = Py_None; - return resultobj; - fail: - return NULL; -} - - -static PyObject *_wrap_Desktop_getDocument(PyObject *, PyObject *args) { - PyObject *resultobj; - Inkscape::Extension::Script::Desktop *arg1 = (Inkscape::Extension::Script::Desktop *) 0 ; - Inkscape::Extension::Script::Document *result; - PyObject * obj0 = 0 ; - - if(!PyArg_ParseTuple(args,(char *)"O:Desktop_getDocument",&obj0)) goto fail; - SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Inkscape__Extension__Script__Desktop, SWIG_POINTER_EXCEPTION | 0); - if (SWIG_arg_fail(1)) SWIG_fail; - result = (Inkscape::Extension::Script::Document *)(arg1)->getDocument(); - - resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_Inkscape__Extension__Script__Document, 0); - return resultobj; - fail: - return NULL; -} - - -static PyObject * Desktop_swigregister(PyObject *, PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL; - SWIG_TypeClientData(SWIGTYPE_p_Inkscape__Extension__Script__Desktop, obj); - Py_INCREF(obj); - return Py_BuildValue((char *)""); -} -static PyObject *_wrap_delete_Document(PyObject *, PyObject *args) { - PyObject *resultobj; - Inkscape::Extension::Script::Document *arg1 = (Inkscape::Extension::Script::Document *) 0 ; - PyObject * obj0 = 0 ; - - if(!PyArg_ParseTuple(args,(char *)"O:delete_Document",&obj0)) goto fail; - SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Inkscape__Extension__Script__Document, SWIG_POINTER_EXCEPTION | 0); - if (SWIG_arg_fail(1)) SWIG_fail; - delete arg1; - - Py_INCREF(Py_None); resultobj = Py_None; - return resultobj; - fail: - return NULL; -} - - -static PyObject *_wrap_Document_hello(PyObject *, PyObject *args) { - PyObject *resultobj; - Inkscape::Extension::Script::Document *arg1 = (Inkscape::Extension::Script::Document *) 0 ; - PyObject * obj0 = 0 ; - - if(!PyArg_ParseTuple(args,(char *)"O:Document_hello",&obj0)) goto fail; - SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Inkscape__Extension__Script__Document, SWIG_POINTER_EXCEPTION | 0); - if (SWIG_arg_fail(1)) SWIG_fail; - (arg1)->hello(); - - Py_INCREF(Py_None); resultobj = Py_None; - return resultobj; - fail: - return NULL; -} - - -static PyObject * Document_swigregister(PyObject *, PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL; - SWIG_TypeClientData(SWIGTYPE_p_Inkscape__Extension__Script__Document, obj); - Py_INCREF(obj); - return Py_BuildValue((char *)""); -} -static PyMethodDef SwigMethods[] = { - { (char *)"getInkscape", _wrap_getInkscape, METH_VARARGS, NULL}, - { (char *)"delete_Inkscape", _wrap_delete_Inkscape, METH_VARARGS, NULL}, - { (char *)"Inkscape_getDesktop", _wrap_Inkscape_getDesktop, METH_VARARGS, NULL}, - { (char *)"Inkscape_getDialogManager", _wrap_Inkscape_getDialogManager, METH_VARARGS, NULL}, - { (char *)"Inkscape_swigregister", Inkscape_swigregister, METH_VARARGS, NULL}, - { (char *)"delete_DialogManager", _wrap_delete_DialogManager, METH_VARARGS, NULL}, - { (char *)"DialogManager_showAbout", _wrap_DialogManager_showAbout, METH_VARARGS, NULL}, - { (char *)"DialogManager_swigregister", DialogManager_swigregister, METH_VARARGS, NULL}, - { (char *)"delete_Desktop", _wrap_delete_Desktop, METH_VARARGS, NULL}, - { (char *)"Desktop_getDocument", _wrap_Desktop_getDocument, METH_VARARGS, NULL}, - { (char *)"Desktop_swigregister", Desktop_swigregister, METH_VARARGS, NULL}, - { (char *)"delete_Document", _wrap_delete_Document, METH_VARARGS, NULL}, - { (char *)"Document_hello", _wrap_Document_hello, METH_VARARGS, NULL}, - { (char *)"Document_swigregister", Document_swigregister, METH_VARARGS, NULL}, - { NULL, NULL, 0, NULL } -}; - - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ - -static swig_type_info _swigt__p_Inkscape__Extension__Script__Desktop[] = {{"_p_Inkscape__Extension__Script__Desktop", 0, "Inkscape::Extension::Script::Desktop *", 0, 0, 0, 0},{"_p_Inkscape__Extension__Script__Desktop", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; -static swig_type_info _swigt__p_Inkscape__Extension__Script__Inkscape[] = {{"_p_Inkscape__Extension__Script__Inkscape", 0, "Inkscape::Extension::Script::Inkscape *", 0, 0, 0, 0},{"_p_Inkscape__Extension__Script__Inkscape", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; -static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; -static swig_type_info _swigt__p_Inkscape__Extension__Script__DialogManager[] = {{"_p_Inkscape__Extension__Script__DialogManager", 0, "Inkscape::Extension::Script::DialogManager *", 0, 0, 0, 0},{"_p_Inkscape__Extension__Script__DialogManager", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; -static swig_type_info _swigt__size_t[] = {{"_size_t", 0, "size_t", 0, 0, 0, 0},{"_size_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; -static swig_type_info _swigt__std__size_t[] = {{"_std__size_t", 0, "std::size_t", 0, 0, 0, 0},{"_std__size_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; -static swig_type_info _swigt__p_Inkscape__Extension__Script__Document[] = {{"_p_Inkscape__Extension__Script__Document", 0, "Inkscape::Extension::Script::Document *", 0, 0, 0, 0},{"_p_Inkscape__Extension__Script__Document", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; -static swig_type_info _swigt__ptrdiff_t[] = {{"_ptrdiff_t", 0, "ptrdiff_t", 0, 0, 0, 0},{"_ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; -static swig_type_info _swigt__std__ptrdiff_t[] = {{"_std__ptrdiff_t", 0, "std::ptrdiff_t", 0, 0, 0, 0},{"_std__ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; - -static swig_type_info *swig_types_initial[] = { -_swigt__p_Inkscape__Extension__Script__Desktop, -_swigt__p_Inkscape__Extension__Script__Inkscape, -_swigt__p_char, -_swigt__p_Inkscape__Extension__Script__DialogManager, -_swigt__size_t, -_swigt__std__size_t, -_swigt__p_Inkscape__Extension__Script__Document, -_swigt__ptrdiff_t, -_swigt__std__ptrdiff_t, -0 -}; - - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ - -static swig_const_info swig_const_table[] = { -{0, 0, 0, 0.0, 0, 0}}; - -#ifdef __cplusplus -} -#endif - - -#ifdef SWIG_LINK_RUNTIME -#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# if defined(_MSC_VER) || defined(__GNUC__) -# define SWIGIMPORT(a) extern a -# else -# if defined(__BORLANDC__) -# define SWIGIMPORT(a) a _export -# else -# define SWIGIMPORT(a) a -# endif -# endif -#else -# define SWIGIMPORT(a) a -#endif -#ifdef __cplusplus -extern "C" -#endif -SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *); -#endif - -#ifdef __cplusplus -extern "C" -#endif -SWIGEXPORT(void) SWIG_init(void) { - static PyObject *SWIG_globals = 0; - static int typeinit = 0; - PyObject *m, *d; - int i; - if (!SWIG_globals) SWIG_globals = SWIG_newvarlink(); - - /* Fix SwigMethods to carry the callback ptrs when needed */ - SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial); - - m = Py_InitModule((char *) SWIG_name, SwigMethods); - d = PyModule_GetDict(m); - - if (!typeinit) { -#ifdef SWIG_LINK_RUNTIME - swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle); -#else -# ifndef SWIG_STATIC_RUNTIME - SWIG_Python_LookupTypePointer(&swig_type_list_handle); -# endif -#endif - for (i = 0; swig_types_initial[i]; i++) { - swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]); - } - typeinit = 1; - } - SWIG_InstallConstants(d,swig_const_table); - -} -