![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: eb4aa26)
raw | patch | inline | side by side (parent: eb4aa26)
| author | ishmal <ishmal@users.sourceforge.net> | |
| Sat, 14 Apr 2007 15:52:31 +0000 (15:52 +0000) | ||
| committer | ishmal <ishmal@users.sourceforge.net> | |
| Sat, 14 Apr 2007 15:52:31 +0000 (15:52 +0000) |
20 files changed:
index e29fcecf4ff27b2c38c7327d9a695c6b6a71a466..4658f684b16a5b11cc65ed574c1621769b92ba54 100644 (file)
+/**
+ * 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 <ishmalius@gmail.com>
+ *
+ * Copyright (C) 2004-2007 Authors
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
class DocumentImpl : public Document
{
public:
+
DocumentImpl();
virtual ~DocumentImpl();
index 6bbd82fc636584433cb7e7994867c6cf21881354..18d33f8f36b054028859d8d037b50e702b332b9b 100644 (file)
* as Python or Perl
*
* Authors:
- * Bob Jamison <rjamison@titan.com>
+ * Bob Jamison <ishmalius@gmail.com>
*
- * Copyright (C) 2004 Authors
+ * Copyright (C) 2004-2007 Authors
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
index 49e6a11a288789a8d35c499819b5ed5136b85348..f7cfe81db2d55859aac3a2d923de653e51844b06 100644 (file)
* Authors:
* Bob Jamison <rjamison@titan.com>
*
- * Copyright (C) 2004 Authors
+ * Copyright (C) 2004-2007 Authors
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
#include <stdio.h>
+#include <CXX/Extensions.hxx>
+#include <CXX/Objects.hxx>
-#include "inkscape_py.py.h"
+#include <inkscape.h>
-/*
- * 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<PyDialogManager>
{
-}
+public:
-/*
- *
- */
-InkscapePython::~InkscapePython()
+private:
+
+};
+
+
+
+class PyDesktop : public Py::PythonExtension<PyDesktop>
+{
+public:
+
+
+
+private:
+
+};
+
+
+
+class PyDocument : public Py::PythonExtension<PyDocument>
+{
+public:
+
+
+
+private:
+
+};
+
+
+
+class PyInkscape : public Py::PythonExtension<PyInkscape>
+{
+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())
index cdf9bd0f1771d3ffd383585347f7c7a246b45b8d..76739c15243d74f1d23dc408643d01a77e1c4e72 100644 (file)
* Authors:
* Bob Jamison <rjamison@titan.com>
*
- * Copyright (C) 2004 Authors
+ * Copyright (C) 2004-2007 Authors
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
#include "InkscapeInterpreter.h"
#include <glibmm.h>
-namespace Inkscape {
-namespace Extension {
-namespace Script {
+
+
+namespace Inkscape
+{
+namespace Extension
+{
+namespace Script
+{
{
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,
private:
+ /**
+ * First-time call to set things up
+ */
+ bool initialize();
+
+ bool initialized;
+
};
+
+
} // namespace Script
} // namespace Extension
} // namespace Inkscape
index 1dcb30042f1708fc2736720cd8c30f665a12b4bc..091bf0123c681579e1e961686b3b4c1e4b1508ce 100644 (file)
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
--- /dev/null
@@ -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<std::random_access_iterator_tag,itemtype,int>
+#else
+# define random_access_iterator_parent(itemtype) std::random_access_iterator<itemtype, int>
+#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 <strstream>
+# define TEMPLATE_TYPENAME class
+# else
+# define PYCXX_ISO_CPP_LIB 1
+# define STR_STREAM <sstream>
+# define TEMPLATE_TYPENAME typename
+# endif
+#elif defined( __GNUC__ )
+# if __GNUC__ >= 3
+# define PYCXX_ISO_CPP_LIB 1
+# define STR_STREAM <sstream>
+# define TEMPLATE_TYPENAME typename
+# else
+# define PYCXX_ISO_CPP_LIB 0
+# define STR_STREAM <strstream>
+# define TEMPLATE_TYPENAME class
+# endif
+#endif
+
+#if PYCXX_ISO_CPP_LIB
+# define STR_STREAM <sstream>
+# define OSTRSTREAM ostringstream
+# define EXPLICIT_TYPENAME typename
+# define EXPLICIT_CLASS class
+# define TEMPLATE_TYPENAME typename
+#else
+# define STR_STREAM <strstream>
+# 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
--- /dev/null
@@ -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 <string>
+#include <iostream>
+
+// 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
--- /dev/null
@@ -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 <vector>
+#include <map>
+
+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<PyMethodDef> 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 T>
+ 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<char *>(_name);
+ ext_meth_def.ml_meth = _handler;
+ ext_meth_def.ml_flags = METH_VARARGS;
+ ext_meth_def.ml_doc = const_cast<char *>(_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<char *>(_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<char *>(_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<TEMPLATE_TYPENAME T>
+ 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<std::string,MethodDefExt<T> *> 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<T> *method_definition = new MethodDefExt<T>
+ (
+ 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<T> *method_definition = new MethodDefExt<T>
+ (
+ 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<T> *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<T> *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<T *>(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<T> *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<T *>(this);
+
+ return (self->*meth_def->ext_varargs_function)( args );
+ }
+
+ private:
+ //
+ // prevent the compiler generating these unwanted functions
+ //
+ ExtensionModule( const ExtensionModule<T> & ); //unimplemented
+ void operator=( const ExtensionModule<T> & ); //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<TEMPLATE_TYPENAME T>
+ 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<std::string,MethodDefExt<T> *> 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<T> *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<T> *method_definition = new MethodDefExt<T>
+ (
+ 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<T> *method_definition = new MethodDefExt<T>
+ (
+ 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<T *>( self_in_cobject );
+
+ String name( self_and_name_tuple[1] );
+
+ method_map_t &mm = methods();
+ MethodDefExt<T> *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<T *>( self_in_cobject );
+
+ String name( self_and_name_tuple[1] );
+
+ method_map_t &mm = methods();
+ MethodDefExt<T> *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<T>& other );
+ void operator=( const PythonExtension<T>& rhs );
+ };
+
+ //
+ // ExtensionObject<T> is an Object that will accept only T's.
+ //
+ template<TEMPLATE_TYPENAME T>
+ class ExtensionObject: public Object
+ {
+ public:
+
+ explicit ExtensionObject ( PyObject *pyob )
+ : Object( pyob )
+ {
+ validate();
+ }
+
+ ExtensionObject( const ExtensionObject<T>& 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<T *>( 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
--- /dev/null
@@ -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 <windows.h>
+
+
+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
--- /dev/null
@@ -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
--- /dev/null
@@ -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 <iostream>
+#include STR_STREAM
+#include <string>
+#include <iterator>
+#include <utility>
+#include <typeinfo>
+
+namespace Py
+{
+ typedef int sequence_index_type; // type of an index into a sequence
+
+ // Forward declarations
+ class Object;
+ class Type;
+ template<TEMPLATE_TYPENAME T> class SeqBase;
+ class String;
+ class List;
+ template<TEMPLATE_TYPENAME T> 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<PyObject*>(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<T> or MapBase<T>.
+ // 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<T> to define an object
+ // note that it contains PythonExtension<T>::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<T>
+ 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<char*>(s.c_str())) ? true: false;
+ }
+
+ Object getAttr (const std::string& s) const
+ {
+ return Object (PyObject_GetAttrString (p, const_cast<char*>(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<char*>(s.c_str()), *value) == -1)
+ throw AttributeError ("getAttr failed.");
+ }
+
+ void delAttr (const std::string& s)
+ {
+ if(PyObject_DelAttrString (p, const_cast<char*>(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<long>(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<long long>(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<T> represents that.
+ // In basic Python T is always "Object".
+
+ // seqref<T> is what you get if you get elements from a non-const SeqBase<T>.
+ // Note: seqref<T> could probably be a nested class in SeqBase<T> 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<TEMPLATE_TYPENAME T>
+ class seqref
+ {
+ protected:
+ SeqBase<T>& s; // the sequence
+ int offset; // item number
+ T the_item; // lvalue
+ public:
+
+ seqref (SeqBase<T>& seq, sequence_index_type j)
+ : s(seq), offset(j), the_item (s.getItem(j))
+ {}
+
+ seqref (const seqref<T>& 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<T>&>(obj))
+ , offset( NULL )
+ , the_item(s.getItem(offset))
+ {}
+ ~seqref()
+ {}
+
+ operator T() const
+ { // rvalue
+ return the_item;
+ }
+
+ seqref<T>& operator=(const seqref<T>& rhs)
+ { //used as lvalue
+ the_item = rhs.the_item;
+ s.setItem(offset, the_item);
+ return *this;
+ }
+
+ seqref<T>& 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<T>
+ // ...the base class for all sequence types
+
+ template<TEMPLATE_TYPENAME T>
+ class SeqBase: public Object
+ {
+ public:
+ // STL definitions
+ typedef size_t size_type;
+ typedef seqref<T> reference;
+ typedef T const_reference;
+ typedef seqref<T>* 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<T>& c)
+ {
+ SeqBase<T> temp = c;
+ c = ptr();
+ set(temp.ptr());
+ }
+
+ virtual size_type size () const
+ {
+ return PySequence_Length (ptr());
+ }
+
+ explicit SeqBase<T> ()
+ :Object(PyTuple_New(0), true)
+ {
+ validate();
+ }
+
+ explicit SeqBase<T> (PyObject* pyob, bool owned=false)
+ : Object(pyob, owned)
+ {
+ validate();
+ }
+
+ SeqBase<T> (const Object& ob): Object(ob)
+ {
+ validate();
+ }
+
+ // Assignment acquires new ownership of pointer
+
+ SeqBase<T>& operator= (const Object& rhs)
+ {
+ return (*this = *rhs);
+ }
+
+ SeqBase<T>& 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<T> operator[](sequence_index_type index)
+ {
+ return seqref<T>(*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<T> repeat (int count) const
+ {
+ return SeqBase<T> (PySequence_Repeat (ptr(), count), true);
+ }
+
+ SeqBase<T> concat (const SeqBase<T>& other) const
+ {
+ return SeqBase<T> (PySequence_Concat(ptr(), *other), true);
+ }
+
+ // more STL compatability
+ const T front () const
+ {
+ return getItem(0);
+ }
+
+ seqref<T> front()
+ {
+ return seqref<T>(this, 0);
+ }
+
+ const T back () const
+ {
+ return getItem(size()-1);
+ }
+
+ seqref<T> back()
+ {
+ return seqref<T>(this, size()-1);
+ }
+
+ void verify_length(size_type required_size) const
+ {
+ if (size() != required_size)
+ throw IndexError ("Unexpected SeqBase<T> 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<T> length.");
+ }
+
+ class iterator
+ : public random_access_iterator_parent(seqref<T>)
+ {
+ protected:
+ friend class SeqBase<T>;
+ SeqBase<T>* seq;
+ int count;
+
+ public:
+ ~iterator ()
+ {}
+
+ iterator ()
+ : seq( 0 )
+ , count( 0 )
+ {}
+
+ iterator (SeqBase<T>* 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<T> operator*()
+ {
+ return seqref<T>(*seq, count);
+ }
+
+ seqref<T> operator[] (sequence_index_type i)
+ {
+ return seqref<T>(*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<T>::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<T>::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<T>;
+ const SeqBase<T>* seq;
+ sequence_index_type count;
+
+ public:
+ ~const_iterator ()
+ {}
+
+ const_iterator ()
+ : seq( 0 )
+ , count( 0 )
+ {}
+
+ const_iterator (const SeqBase<T>* 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<T>::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<T>::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<Object> Sequence;
+
+ template <TEMPLATE_TYPENAME T> bool operator==(const EXPLICIT_TYPENAME SeqBase<T>::iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator!=(const EXPLICIT_TYPENAME SeqBase<T>::iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator< (const EXPLICIT_TYPENAME SeqBase<T>::iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator> (const EXPLICIT_TYPENAME SeqBase<T>::iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator<=(const EXPLICIT_TYPENAME SeqBase<T>::iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator>=(const EXPLICIT_TYPENAME SeqBase<T>::iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::iterator& right);
+
+ template <TEMPLATE_TYPENAME T> bool operator==(const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator!=(const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator< (const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator> (const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator<=(const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator>=(const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::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<Py_UNICODE> 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<char*>(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<char*>(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<Py_UNICODE*>(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<Char>
+ {
+ public:
+ virtual size_type capacity() const
+ {
+ return max_size();
+ }
+
+ explicit String (PyObject *pyob, bool owned = false): SeqBase<Char>(pyob, owned)
+ {
+ validate();
+ }
+
+ String (const Object& ob): SeqBase<Char>(ob)
+ {
+ validate();
+ }
+
+ String()
+ : SeqBase<Char>( PyString_FromStringAndSize( "", 0 ), true )
+ {
+ validate();
+ }
+
+ String( const std::string& v )
+ : SeqBase<Char>( PyString_FromStringAndSize( const_cast<char*>(v.data()),
+ static_cast<int>( v.length() ) ), true )
+ {
+ validate();
+ }
+
+ String( const char *s, const char *encoding, const char *error="strict" )
+ : SeqBase<Char>( PyUnicode_Decode( s, strlen( s ), encoding, error ), true )
+ {
+ validate();
+ }
+
+ String( const char *s, int len, const char *encoding, const char *error="strict" )
+ : SeqBase<Char>( PyUnicode_Decode( s, len, encoding, error ), true )
+ {
+ validate();
+ }
+
+ String( const std::string &s, const char *encoding, const char *error="strict" )
+ : SeqBase<Char>( PyUnicode_Decode( s.c_str(), s.length(), encoding, error ), true )
+ {
+ validate();
+ }
+
+ String( const std::string& v, std::string::size_type vsize )
+ : SeqBase<Char>(PyString_FromStringAndSize( const_cast<char*>(v.data()),
+ static_cast<int>( vsize ) ), true)
+ {
+ validate();
+ }
+
+ String( const char *v, int vsize )
+ : SeqBase<Char>(PyString_FromStringAndSize( const_cast<char*>(v), vsize ), true )
+ {
+ validate();
+ }
+
+ String( const char* v )
+ : SeqBase<Char>( 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<char*>( v.data() ),
+ static_cast<int>( v.length() ) ), true );
+ return *this;
+ }
+ String& operator= (const unicodestring& v)
+ {
+ set( PyUnicode_FromUnicode( const_cast<Py_UNICODE*>( v.data() ),
+ static_cast<int>( 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<size_type>( PyUnicode_GET_SIZE (ptr()) );
+ }
+ else
+ {
+ return static_cast<size_type>( 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<size_type>( PyString_Size( ptr() ) ) );
+ }
+ }
+
+ unicodestring as_unicodestring() const
+ {
+ if( isUnicode() )
+ {
+ return unicodestring( PyUnicode_AS_UNICODE( ptr() ),
+ static_cast<size_type>( 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<TEMPLATE_TYPENAME T>
+ class mapref
+ {
+ protected:
+ MapBase<T>& s; // the map
+ Object key; // item key
+ T the_item;
+
+ public:
+ mapref<T> (MapBase<T>& map, const std::string& k)
+ : s(map), the_item()
+ {
+ key = String(k);
+ if(map.hasKey(key)) the_item = map.getItem(key);
+ }
+
+ mapref<T> (MapBase<T>& map, const Object& k)
+ : s(map), key(k), the_item()
+ {
+ if(map.hasKey(key)) the_item = map.getItem(key);
+ }
+
+ virtual ~mapref<T>()
+ {}
+
+ // MapBase<T> stuff
+ // lvalue
+ mapref<T>& operator=(const mapref<T>& other)
+ {
+ if(this == &other) return *this;
+ the_item = other.the_item;
+ s.setItem(key, other.the_item);
+ return *this;
+ }
+
+ mapref<T>& 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<T>
+ template< class T >
+ bool operator==(const mapref<T>& left, const mapref<T>& right)
+ {
+ return true; // NOT completed.
+ }
+
+ template< class T >
+ bool operator!=(const mapref<T>& left, const mapref<T>& right)
+ {
+ return true; // not completed.
+ }
+
+ template<TEMPLATE_TYPENAME T>
+ class MapBase: public Object
+ {
+ protected:
+ explicit MapBase<T>()
+ {}
+ 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<T> data_type;
+ typedef std::pair< const T, T > value_type;
+ typedef std::pair< const T, mapref<T> > reference;
+ typedef const std::pair< const T, const T > const_reference;
+ typedef std::pair< const T, mapref<T> > pointer;
+
+ // Constructor
+ explicit MapBase<T> (PyObject *pyob, bool owned = false): Object(pyob, owned)
+ {
+ validate();
+ }
+
+ // TMM: 02Jul'01 - changed MapBase<T> to Object in next line
+ MapBase<T> (const Object& ob): Object(ob)
+ {
+ validate();
+ }
+
+ // Assignment acquires new ownership of pointer
+ MapBase<T>& operator= (const Object& rhs)
+ {
+ return (*this = *rhs);
+ }
+
+ MapBase<T>& 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<T> operator[](const std::string& key)
+ {
+ return mapref<T>(*this, key);
+ }
+
+ mapref<T> operator[](const Object& key)
+ {
+ return mapref<T>(*this, key);
+ }
+
+ int length () const
+ {
+ return PyMapping_Length (ptr());
+ }
+
+ bool hasKey (const std::string& s) const
+ {
+ return PyMapping_HasKeyString (ptr(),const_cast<char*>(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<char*>(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<char*>(s), *ob) == -1)
+ {
+ throw Exception();
+ }
+ }
+
+ virtual void setItem (const std::string& s, const Object& ob)
+ {
+ if (PyMapping_SetItemString (ptr(), const_cast<char*>(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<char*>(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<T>
+ // 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<T>* rather than a MapBase<T> 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<const T,T> ) {
+ 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<T> > pointer;
+ typedef std::pair< const T, mapref<T> > reference;
+
+ friend class MapBase<T>;
+ //
+ MapBase<T>* map;
+ List keys; // for iterating over the map
+ List::iterator pos; // index into the keys
+
+ public:
+ ~iterator ()
+ {}
+
+ iterator ()
+ : map( 0 )
+ , keys()
+ , pos()
+ {}
+
+ iterator (MapBase<T>* 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<T>(*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<T>::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<T>;
+ const MapBase<T>* 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<T>* 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<T>::const_iterator
+
+ const_iterator begin () const
+ {
+ return const_iterator(this, 0);
+ }
+
+ const_iterator end () const
+ {
+ return const_iterator(this, length());
+ }
+
+ }; // end of MapBase<T>
+
+ typedef MapBase<Object> Mapping;
+
+ template <TEMPLATE_TYPENAME T> bool operator==(const EXPLICIT_TYPENAME MapBase<T>::iterator& left, const EXPLICIT_TYPENAME MapBase<T>::iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator!=(const EXPLICIT_TYPENAME MapBase<T>::iterator& left, const EXPLICIT_TYPENAME MapBase<T>::iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator==(const EXPLICIT_TYPENAME MapBase<T>::const_iterator& left, const EXPLICIT_TYPENAME MapBase<T>::const_iterator& right);
+ template <TEMPLATE_TYPENAME T> bool operator!=(const EXPLICIT_TYPENAME MapBase<T>::const_iterator& left, const EXPLICIT_TYPENAME MapBase<T>::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<char *>(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<Object,Object> 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<Object,Object>(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<TEMPLATE_TYPENAME T>
+String seqref<T>::str () const
+{
+ return the_item.str();
+}
+
+template<TEMPLATE_TYPENAME T>
+String seqref<T>::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
--- /dev/null
@@ -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
--- /dev/null
@@ -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 <sys/time.h>
+#endif
+
+// pull in python definitions
+#include <Python.h>
+
+#endif
diff --git a/src/extension/script/cxx/cxx_extensions.cxx b/src/extension/script/cxx/cxx_extensions.cxx
--- /dev/null
@@ -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 <assert.h>
+
+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<char*>( method_name );
+ m.ml_meth = f;
+ m.ml_flags = flags;
+ m.ml_doc = const_cast<char*>( 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<PyMethodDef>::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<ExtensionModuleBasePtr>
+{
+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<char *>( module_name.c_str() ), // name
+ method_table.table(), // methods
+ const_cast<char *>( 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<PyObject*>( table ) = py_object_initializer;
+ table->ob_type = _Type_Type();
+ table->ob_size = 0;
+ table->tp_name = const_cast<char *>( 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<char *>( nam );
+ return *this;
+}
+
+const char *PythonType::getName() const
+{
+ return table->tp_name;
+}
+
+PythonType & PythonType::doc( const char* d )
+{
+ table->tp_doc = const_cast<char *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<PythonExtensionBase *>( 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<ExtensionModuleBase *>( 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<ExtensionModuleBase *>( 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<char *>( 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<char *>( 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
--- /dev/null
@@ -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
--- /dev/null
@@ -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<std::string>(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<std::string>(ob.str()));
+}
+#endif
+
+} // Py
diff --git a/src/extension/script/inkscape_py.i b/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
+++ /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
+++ /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
+++ /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 T> class SwigValueWrapper {
- T *tt;
-public:
- SwigValueWrapper() : tt(0) { }
- SwigValueWrapper(const SwigValueWrapper<T>& 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<T>& rhs);
-};
-#endif
-
-
-#ifndef SWIG_TEMPLATE_DISAMBIGUATOR
-# if defined(__SUNPRO_CC)
-# define SWIG_TEMPLATE_DISAMBIGUATOR template
-# else
-# define SWIG_TEMPLATE_DISAMBIGUATOR
-# endif
-#endif
-
-
-#include <Python.h>
-
-/***********************************************************************
- * 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 <string.h>
-
-#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<int>" == "Class<int >", 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 <name1>|<name2>|...
-*/
-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("<Global variables>");
-}
-
-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);
-
-}
-