summaryrefslogtreecommitdiffstats
path: root/lib/kross/python
diff options
context:
space:
mode:
authortpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2010-01-20 01:29:50 +0000
committertpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2010-01-20 01:29:50 +0000
commit8362bf63dea22bbf6736609b0f49c152f975eb63 (patch)
tree0eea3928e39e50fae91d4e68b21b1e6cbae25604 /lib/kross/python
downloadkoffice-8362bf63dea22bbf6736609b0f49c152f975eb63.tar.gz
koffice-8362bf63dea22bbf6736609b0f49c152f975eb63.zip
Added old abandoned KDE3 version of koffice
git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1077364 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'lib/kross/python')
-rw-r--r--lib/kross/python/Makefile.am33
-rw-r--r--lib/kross/python/cxx/Config.hxx74
-rw-r--r--lib/kross/python/cxx/Exception.hxx212
-rw-r--r--lib/kross/python/cxx/Extensions.hxx756
-rw-r--r--lib/kross/python/cxx/IndirectPythonInterface.cxx550
-rw-r--r--lib/kross/python/cxx/IndirectPythonInterface.hxx156
-rwxr-xr-xlib/kross/python/cxx/Legal.html40
-rw-r--r--lib/kross/python/cxx/Makefile.am19
-rw-r--r--lib/kross/python/cxx/Objects.hxx2804
-rw-r--r--lib/kross/python/cxx/PyCXX.html2131
-rw-r--r--lib/kross/python/cxx/README.html436
-rw-r--r--lib/kross/python/cxx/Readme.Kross.txt16
-rw-r--r--lib/kross/python/cxx/Version.txt1
-rw-r--r--lib/kross/python/cxx/cxx_extensions.cxx1287
-rw-r--r--lib/kross/python/cxx/cxxextensions.c19
-rw-r--r--lib/kross/python/cxx/cxxsupport.cxx142
-rw-r--r--lib/kross/python/pythonconfig.h105
-rw-r--r--lib/kross/python/pythonextension.cpp445
-rw-r--r--lib/kross/python/pythonextension.h221
-rw-r--r--lib/kross/python/pythoninterpreter.cpp255
-rw-r--r--lib/kross/python/pythoninterpreter.h90
-rw-r--r--lib/kross/python/pythonmodule.cpp100
-rw-r--r--lib/kross/python/pythonmodule.h76
-rw-r--r--lib/kross/python/pythonobject.cpp94
-rw-r--r--lib/kross/python/pythonobject.h95
-rw-r--r--lib/kross/python/pythonscript.cpp460
-rw-r--r--lib/kross/python/pythonscript.h98
-rw-r--r--lib/kross/python/pythonsecurity.cpp181
-rw-r--r--lib/kross/python/pythonsecurity.h109
-rw-r--r--lib/kross/python/scripts/Makefile.am4
-rw-r--r--lib/kross/python/scripts/RestrictedPython/Eval.py118
-rw-r--r--lib/kross/python/scripts/RestrictedPython/Guards.py136
-rw-r--r--lib/kross/python/scripts/RestrictedPython/Limits.py46
-rw-r--r--lib/kross/python/scripts/RestrictedPython/Makefile.am4
-rw-r--r--lib/kross/python/scripts/RestrictedPython/MutatingWalker.py74
-rw-r--r--lib/kross/python/scripts/RestrictedPython/PrintCollector.py23
-rw-r--r--lib/kross/python/scripts/RestrictedPython/RCompile.py235
-rw-r--r--lib/kross/python/scripts/RestrictedPython/RestrictionMutator.py372
-rw-r--r--lib/kross/python/scripts/RestrictedPython/SelectCompiler.py28
-rw-r--r--lib/kross/python/scripts/RestrictedPython/Utilities.py77
-rw-r--r--lib/kross/python/scripts/RestrictedPython/__init__.py19
-rwxr-xr-xlib/kross/python/scripts/gui.py396
42 files changed, 12537 insertions, 0 deletions
diff --git a/lib/kross/python/Makefile.am b/lib/kross/python/Makefile.am
new file mode 100644
index 00000000..5eff2abe
--- /dev/null
+++ b/lib/kross/python/Makefile.am
@@ -0,0 +1,33 @@
+include $(top_srcdir)/lib/kross/Makefile.global
+
+kde_module_LTLIBRARIES = krosspython.la
+
+krosspython_la_LDFLAGS = $(KDE_PLUGIN) $(all_libraries) $(LIBPYTHON) $(PYTHONLIB) -module $(VER_INFO)
+
+noinst_HEADERS = \
+ pythonextension.h \
+ pythonmodule.h \
+ pythonobject.h \
+ pythonscript.h \
+ pythonsecurity.h \
+ pythoninterpreter.h \
+ pythonconfig.h
+
+krosspython_la_SOURCES = \
+ pythonextension.cpp \
+ pythonmodule.cpp \
+ pythonobject.cpp \
+ pythonscript.cpp \
+ pythonsecurity.cpp \
+ pythoninterpreter.cpp
+
+krosspython_la_LIBADD = \
+ $(LIB_QT) \
+ $(LIB_KDECORE) \
+ cxx/libkrosspythoncxx.la \
+ ../api/libkrossapi.la \
+ ../main/libkrossmain.la
+
+INCLUDES = $(KROSS_INCLUDES) $(PYTHONINC) $(all_includes)
+METASOURCES = AUTO
+SUBDIRS = cxx scripts .
diff --git a/lib/kross/python/cxx/Config.hxx b/lib/kross/python/cxx/Config.hxx
new file mode 100644
index 00000000..65bbc2d3
--- /dev/null
+++ b/lib/kross/python/cxx/Config.hxx
@@ -0,0 +1,74 @@
+#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
+
+
+#endif // __PyCXX_config_hh__
diff --git a/lib/kross/python/cxx/Exception.hxx b/lib/kross/python/cxx/Exception.hxx
new file mode 100644
index 00000000..afcff489
--- /dev/null
+++ b/lib/kross/python/cxx/Exception.hxx
@@ -0,0 +1,212 @@
+//----------------------------------*-C++-*----------------------------------//
+// Copyright 1998 The Regents of the University of California.
+// All rights reserved. See LEGAL.LLNL for full text and disclaimer.
+//---------------------------------------------------------------------------//
+
+#ifndef __CXX_Exception_h
+#define __CXX_Exception_h
+
+#include "Python.h"
+#include "Config.hxx"
+#include "IndirectPythonInterface.hxx"
+
+#include <string>
+#include <iostream>
+
+// This mimics the Python structure, in order to minimize confusion
+namespace Py
+ {
+ class ExtensionExceptionType;
+
+ class Exception
+ {
+ public:
+ Exception( ExtensionExceptionType &exception, const std::string& 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());
+ }
+
+
+ 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/lib/kross/python/cxx/Extensions.hxx b/lib/kross/python/cxx/Extensions.hxx
new file mode 100644
index 00000000..69ce9a14
--- /dev/null
+++ b/lib/kross/python/cxx/Extensions.hxx
@@ -0,0 +1,756 @@
+//----------------------------------*-C++-*----------------------------------//
+// Copyright 1998 The Regents of the University of California.
+// All rights reserved. See LEGAL.LLNL for full text and disclaimer.
+//---------------------------------------------------------------------------//
+
+#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 "Config.hxx"
+#include "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 );
+ };
+
+
+ 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;
+ void name (const char* nam);
+ void doc (const char* d);
+ void dealloc(void (*f)(PyObject*));
+
+ void supportPrint(void);
+ void supportGetattr(void);
+ void supportSetattr(void);
+ void supportGetattro(void);
+ void supportSetattro(void);
+ void supportCompare(void);
+ void supportRepr(void);
+ void supportStr(void);
+ void supportHash(void);
+ void supportCall(void);
+
+ void supportSequenceType(void);
+ void supportMappingType(void);
+ void supportNumberType(void);
+ void 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 & );
+
+ // Sequence methods
+ virtual int sequence_length();
+ virtual Object sequence_concat( const Object & );
+ virtual Object sequence_repeat( int );
+ virtual Object sequence_item( int );
+ virtual Object sequence_slice( int, int );
+ virtual int sequence_ass_item( int, const Object & );
+ virtual int sequence_ass_slice( int, int, 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 int buffer_getreadbuffer( int, void** );
+ virtual int buffer_getwritebuffer( int, void** );
+ virtual int buffer_getsegcount( int* );
+
+ 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 )
+ 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 );
+ }
+ else 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();
+// }
+ else
+ {
+ 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( "method '" + name + "' does not exist." );
+
+ 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/lib/kross/python/cxx/IndirectPythonInterface.cxx b/lib/kross/python/cxx/IndirectPythonInterface.cxx
new file mode 100644
index 00000000..caaa0913
--- /dev/null
+++ b/lib/kross/python/cxx/IndirectPythonInterface.cxx
@@ -0,0 +1,550 @@
+//
+// IndirectPythonInterface.cxx
+//
+#undef _XOPEN_SOURCE
+#include "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/lib/kross/python/cxx/IndirectPythonInterface.hxx b/lib/kross/python/cxx/IndirectPythonInterface.hxx
new file mode 100644
index 00000000..8f2d275d
--- /dev/null
+++ b/lib/kross/python/cxx/IndirectPythonInterface.hxx
@@ -0,0 +1,156 @@
+#ifndef __CXX_INDIRECT_PYTHON_INTERFACE__HXX__
+#define __CXX_INDIRECT_PYTHON_INTERFACE__HXX__
+
+#include <Python.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/lib/kross/python/cxx/Legal.html b/lib/kross/python/cxx/Legal.html
new file mode 100755
index 00000000..cf6a530f
--- /dev/null
+++ b/lib/kross/python/cxx/Legal.html
@@ -0,0 +1,40 @@
+<html>
+
+<head>
+<title>Legal Notice</title>
+<meta name="GENERATOR" content="Microsoft FrontPage 3.0">
+</head>
+
+<body>
+
+<h1>Legal Notice</h1>
+
+<p>*** Legal Notice for all LLNL-contributed files *** </p>
+
+<p>Copyright (c) 1996. The Regents of the University of California. All rights reserved. </p>
+
+<p>Permission to use, copy, modify, and distribute this software for any purpose without
+fee is hereby granted, provided that this entire notice is included in all copies of any
+software which is or includes a copy or modification of this software and in all copies of
+the supporting documentation for such software. </p>
+
+<p>This work was produced at the University of California, Lawrence Livermore National
+Laboratory under contract no. W-7405-ENG-48 between the U.S. Department of Energy and The
+Regents of the University of California for the operation of UC LLNL. </p>
+
+<h2>DISCLAIMER </h2>
+
+<p>This software was prepared as an account of work sponsored by an agency of the United
+States Government. Neither the United States Government nor the University of California
+nor any of their employees, makes any warranty, express or implied, or assumes any
+liability or responsibility for the accuracy, completeness, or usefulness of any
+information, apparatus, product, or process disclosed, or represents that its use would
+not infringe privately-owned rights. Reference herein to any specific commercial products,
+process, or service by trade name, trademark, manufacturer, or otherwise, does not
+necessarily constitute or imply its endorsement, recommendation, or favoring by the United
+States Government or the University of California. The views and opinions of authors
+expressed herein do not necessarily state or reflect those of the United States Government
+or the University of California, and shall not be used for advertising or product
+endorsement purposes.</p>
+</body>
+</html>
diff --git a/lib/kross/python/cxx/Makefile.am b/lib/kross/python/cxx/Makefile.am
new file mode 100644
index 00000000..d1c72c87
--- /dev/null
+++ b/lib/kross/python/cxx/Makefile.am
@@ -0,0 +1,19 @@
+include $(top_srcdir)/lib/kross/Makefile.global
+
+noinst_LTLIBRARIES = libkrosspythoncxx.la
+
+libkrosspythoncxx_la_SOURCES = \
+ cxxsupport.cxx \
+ cxx_extensions.cxx \
+ cxxextensions.c \
+ IndirectPythonInterface.cxx
+
+libkrosspythoncxx_la_LDFLAGS = $(LIBPYTHON) $(all_libraries) -Wnounresolved
+
+METASOURCES = AUTO
+INCLUDES = $(KROSS_INCLUDES) $(PYTHONINC) $(all_includes)
+SUBDIRS = .
+
+clean:
+ @rm -f *.o 2> /dev/null
+ @rm -f $(BIN) 2> /dev/null
diff --git a/lib/kross/python/cxx/Objects.hxx b/lib/kross/python/cxx/Objects.hxx
new file mode 100644
index 00000000..41648320
--- /dev/null
+++ b/lib/kross/python/cxx/Objects.hxx
@@ -0,0 +1,2804 @@
+//----------------------------------*-C++-*----------------------------------//
+// Copyright 1998 The Regents of the University of California.
+// All rights reserved. See LEGAL.LLNL for full text and disclaimer.
+//---------------------------------------------------------------------------//
+
+#ifndef __CXX_Objects__h
+#define __CXX_Objects__h
+
+// Prevent warnings
+#if defined(_XOPEN_SOURCE)
+#undef _XOPEN_SOURCE
+#endif
+
+#include "Python.h"
+#include "Config.hxx"
+#include "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 )
+ std::string s("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);
+ }
+
+ int 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 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
+ explicit Int (PyObject *pyob, bool owned = false): Object (pyob, owned)
+ {
+ validate();
+ }
+
+ Int (const Int& ob): Object(*ob)
+ {
+ validate();
+ }
+
+ // create from long
+ explicit Int (long v = 0L): Object(PyInt_FromLong(v), true)
+ {
+ validate();
+ }
+
+ // create from int
+ explicit Int (int v)
+ {
+ long w = v;
+ set(PyInt_FromLong(w), true);
+ validate();
+ }
+
+ 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());
+ }
+ // 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;
+ }
+ };
+
+ // ===============================================
+ // 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 int
+ explicit Long (int v)
+ : Object(PyLong_FromLong(static_cast<long>(v)), true)
+ {
+ validate();
+ }
+
+ // create from unsigned long
+ explicit Long (unsigned long v)
+ : Object(PyLong_FromUnsignedLong(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());
+ }
+ operator double() const
+ {
+ return PyLong_AsDouble (ptr());
+ }
+ operator unsigned long() const
+ {
+ return PyLong_AsUnsignedLong (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;
+ }
+ };
+
+ // ===============================================
+ // 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 = 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);
+ };
+
+ ~mapref()
+ {}
+
+ // 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 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
+ {
+ protected:
+ explicit Callable (): Object()
+ {}
+ public:
+ // Constructor
+ 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(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/lib/kross/python/cxx/PyCXX.html b/lib/kross/python/cxx/PyCXX.html
new file mode 100644
index 00000000..566974c1
--- /dev/null
+++ b/lib/kross/python/cxx/PyCXX.html
@@ -0,0 +1,2131 @@
+<html>
+
+<head>
+<meta HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252">
+<title>Writing Python Extensions in C++</title>
+<style>
+H1, H2, H3, H4 {color: #000099;
+ background-color: lightskyblue}
+h3 {position: relative; left: 20px}
+
+p {position: relative; left: 20px; margin-right: 20px}
+pre {color: #0000cc; background-color: #eeeeee; position: relative; left: 40px; margin-right: 80px;
+ border-style: solid; border-color: black; border-width: thin}
+kbd {color: #990000}
+p cite, ol cite, ul cite {font-family: monospace; font-style: normal; font-size: normal}
+li var, pre var, p var, kbd var {color: #009900; font-style: italic}
+li samp, pre samp, p samp, kbd samp {color: #009900; font-weight: bold}
+li p {position: relative; left: 0}
+table { position: relative; left: 20px; border: solid #888888 1px; background-color: #eeeeee}
+table th {border: solid #888888 1px; background-color: #88dd88; color: black}
+table td {border: solid #888888 1px}
+table td.code {border: solid #888888 1px;font-family: monospace; font-style: normal; font-size: normal}
+p.param {background-color: #eeeeee; border-top: lightskyblue solid 4}
+</style>
+
+</head>
+
+<body bgcolor="#FFFFFF">
+
+<h1 ALIGN="center">Writing Python Extensions in C++</h1>
+
+<p ALIGN="CENTER">Barry Scott<br>
+Reading, Berkshire, England<br>
+<a href="mailto:barry@barrys-emacs.org">barry@barrys-emacs.org</a><br>
+</p>
+
+<p ALIGN="CENTER">Paul F. Dubois, <a href="mailto:dubois1@llnl.gov">dubois1@llnl.gov</a><br>
+Lawrence Livermore National Laboratory<br>
+Livermore, California, U.S.A.</p>
+
+
+<p>PyCXX is designed to make it easier to extend Python with C++</p>
+
+
+<p>PyCXX is a set of C++ facilities to make it easier to write Python extensions.
+The chief way in which PyCXX makes it easier to write Python extensions is that it greatly
+increases the probability that your program will not make a reference-counting error and
+will not have to continually check error returns from the Python C API. PyCXX
+integrates Python with C++ in these ways: </p>
+
+<ul>
+ <li>C++ exception handling is relied on to detect errors and clean up. In a complicated
+ function this is often a tremendous problem when writing in C. With PyCXX, we let the
+ compiler keep track of what objects need to be dereferenced when an error occurs.
+ <li>The Standard Template Library (STL) and its many algorithms plug and play with Python
+ containers such as lists and tuples.
+ <li>The optional CXX_Extensions facility allows you to replace the clumsy C tables with
+ objects and method calls that define your modules and extension objects.
+</ul>
+
+<h3>Download and Installation</h3>
+
+<p>Download PyCXX from <a href="http://sourceforge.net/projects/cxx/">http://sourceforge.net/projects/cxx/</a>.</p>
+
+<p>The distribution layout is:</p>
+<table>
+<tr><th>Directory</th><th>Description</th></tr>
+<tr><td class=code>.</td><td>Makefile for Unix and Windows, Release documentation</td>
+<tr><td class=code>./CXX</td><td>Header files</td>
+<tr><td class=code>./Src</td><td>Source files</td>
+<tr><td class=code>./Doc</td><td>Documentation</td>
+<tr><td class=code>./Demo</td><td>Testing and Demonstartion files</td>
+</table>
+
+<p>To use PyCXX you use its include files and add its source routines to your module.</p>
+
+<p>Installation:</p>
+<ul>
+<li>Install the PyCXX files into a directory of your choice. For example:<br>
+Windows: <cite>C:\PyCXX</cite><br>
+Unix: <cite>/usr/local/PyCXX</cite>
+<li>Tell your compiler where the PyCXX header files are:<br>
+Windows: <cite>cl /I=C:\PyCXX ...</cite><br>
+Unix: <cite>g++ -I/usr/local/PyCXX ...</cite>
+<li>Include PyCXX headers files in your code using the CXX prefix:<br>
+<cite>#include &quot;CXX/Object.hxx&quot;</cite>
+</ul>
+
+<p>The header file CXX/config.h may need to be adjusted for the
+compiler you use. As of this writing, only a fairly obscure reference to part of the
+standard library needs this adjustment. Unlike prior releases, PyCXX now assumes namespace
+support and a standard C++ library. </p>
+
+<h3>Use of namespaces</h3>
+
+<p>All PyCXX assets are in namespace &quot;Py&quot;. You need to include
+the Py:: prefix when referring to them, or include the statement:</p>
+
+<p>using namespace Py;</p>
+
+<h2>Wrappers for standard objects: CXX_Objects.h</h2>
+
+<p>Header file CXX_Objects.h requires adding file Src/cxxsupport.cxx to
+your module sources. CXX_Objects provides a set of wrapper classes that allow you access
+to most of the Python C API using a C++ notation that closely resembles Python. For
+example, this Python:</p>
+
+<pre>d = {}
+d["a"] = 1
+d["b"] = 2
+alist = d.keys()
+print alist</pre>
+
+<p>Can be written in C++:</p>
+
+<pre>Dict d;
+List alist;
+d["a"] = Int(1);
+d["b"] = Int(2);
+alist = d.keys();
+std::cout &lt;&lt; alist &lt;&lt; std::endl;
+</pre>
+
+<p>You can optionally use the CXX/Extensions.hxx facility described later
+to define Python extension modules and extension objects.</p>
+
+<h3>We avoid programming with Python object pointers</h3>
+
+<p>The essential idea is that we avoid, as much as possible, programming with pointers to
+Python objects, that is, variables of type <cite>PyObject*</cite>. Instead,
+we use instances of a family of C++ classes that represent the
+usual Python objects. This family is easily extendible to include new kinds of Python
+objects.</p>
+
+<p>For example, consider the case in which we wish to write a method, taking a single
+integer argument, that will create a Python <cite>dict</cite>
+ and insert into it that the integer plus one under the key <cite>value</cite>.
+ In C we might do that as follows:</p>
+
+<pre>static PyObject* mymodule_addvalue (PyObject* self, PyObject* args)
+ {
+ PyObject *d;
+ PyObject* f;
+ int k;
+ PyArgs_ParseTuple(args, &quot;i&quot;, &amp;k);
+ d = PyDict_New();
+ if (!d)
+ return NULL;
+
+ f = PyInt_NEW(k+1);
+ if(!f)
+ {
+ Py_DECREF(d); /* have to get rid of d first */
+ return NULL;
+ }
+ if(PyDict_SetItemString(d, &quot;value&quot;, f) == -1)
+ {
+ Py_DECREF(f);
+ Py_DECREF(d);
+ return NULL;
+ }
+
+ return d;
+ }</pre>
+
+<p>If you have written a significant Python extension, this tedium looks all too familiar.
+The vast bulk of the coding is error checking and cleanup. Now compare the same thing
+written in C++ using CXX/Objects.hxx. The things with Python-like names (Int, Dict, Tuple) are
+from CXX/Objects.hxx.</p>
+
+<pre>static PyObject* mymodule_addvalue (PyObject* self, PyObject* pargs)
+ {
+ try {
+ Tuple args(pargs);
+ args.verify_length(1);
+
+ Dict d;
+ Int k = args[0];
+ d[&quot;value&quot;] = k + 1;
+
+ return new_reference_to(d);
+ }
+ catch (const PyException&amp;)
+ {
+ return NULL;
+ }
+ }</pre>
+
+<p>If there are not the right number of arguments or the argument is not an
+integer, an exception is thrown. In this case we choose to catch it and convert it into a
+Python exception. The C++ exception handling mechanism takes care all the cleanup.</p>
+
+<p>Note that the creation of the <cite>Int k</cite> got the first argument <em>and</em> verified
+that it is an <cite>Int</cite>.</p>
+
+<p>Just to peek ahead, if you wrote this method in an
+ExtensionModule-derived module of your own, it would be a method and it could be written
+even more simply:</p>
+
+<pre>
+Object addvalue (Object &amp; self, const Tuple &amp; args)
+ {
+ args.verify_length(1);
+ Dict d;
+ Int k = args[0];
+ d["value"] = k + 1;
+ return d;
+ }
+</pre>
+
+<h2>The basic concept is to wrap Python pointers</h2>
+
+
+<p>The basic concept of CXX/Objects.hxx is to create a wrapper around
+each <cite>PyObject *</cite> so that the reference counting can be
+done automatically, thus eliminating the most frequent source of errors. In addition, we
+can then add methods and operators so that Python objects can be manipulated in C++
+much like you would in Python.</p>
+
+<p>Each <cite>Object</cite> contains a <cite>PyObject *</cite>
+to which it owns a reference. When an <cite>Object</cite> is destroyed, it releases its ownership on
+the pointer. Since C++ calls the destructors on objects that are about to go out of scope,
+we are guaranteed that we will keep the reference counts right even if we unexpectedly
+leave a routine with an exception.</p>
+
+<p>As a matter of philosophy, CXX/Objects.hxx prevents the creation of instances of its
+classes unless the instance will be a valid instance of its class. When an attempt is made
+to create an object that will not be valid, an exception is thrown.</p>
+
+<p>Class <cite>Object</cite> represents the most general kind of Python object. The rest of the classes
+that represent Python objects inherit from it.</p>
+
+<pre>Object
+ Type
+ Int
+ Float
+ Long
+ Complex
+ Char
+ Sequence -&gt; SeqBase&lt;T&gt;
+ String
+ Tuple
+ List
+ Mapping -&gt; MapBase&lt;T&gt;
+ Dict
+ Callable
+ Module</pre>
+
+<p>There are several constructors for each of these classes. For example, you can create
+an <cite>Int</cite> from an integer as in</p>
+
+<pre>Int s(3)</pre>
+
+<p>However, you can also create an instance of one of these classes using any <cite>PyObject*</cite> or
+another <cite>Object</cite>. If the corresponding Python object does not actually have the type
+desired, an exception is thrown. This is accomplished as follows. Class <cite>Object</cite> defines a
+virtual function <cite>accepts</cite>:</p>
+
+<pre>virtual bool accepts(PyObject* p)</pre>
+
+<p>The base class version of <cite>accepts</cite> returns true for any pointer p except 0. This means
+we can create an Object using any <cite>PyObject *</cite>, or from any other
+<cite>Object</cite>. However, if we attempt to create an <cite>Int</cite> from a <cite>PyObject *</cite>,
+the overridding version
+of <cite>accepts</cite> in class <cite>Int</cite> will only accept pointers that correspond to Python ints.
+Therefore if we have a <cite>Tuple t</cite> and we wish to get the first element and be sure it is an
+<cite>Int</cite>, we do</p>
+
+<pre>Int first_element = t[0]</pre>
+
+<p>This will not only accomplish the goal of extracting the first element of the <cite>Tuple t</cite>,
+but it will ensure that the result is an <cite>Int</cite>. If not, an exception is thrown. The
+exception mechanism is discussed later.</p>
+
+<h2>Class Object</h2>
+
+<p>Class <cite>Object</cite> serves as the base class for the other classes. Its default constructor
+constructs a <cite>Py_None</cite>, the unique object of Python type <cite>None</cite>. The interface to <cite>Object</cite>
+consists of a large number of methods corresponding to the operations that are defined for
+every Python object. In each case, the methods throw an exception if anything goes
+wrong.</p>
+
+<p>There is no method corresponding to <cite>PyObject_SetItem</cite> with an arbitrary Python object
+as a key. Instead, create an instance of a more specific child of <cite>Object</cite> and use the
+appropriate facilities.</p>
+
+<p>The comparison operators use the Python comparison function to compare values. The
+method <cite>is</cite> is available to test for absolute identity.</p>
+
+<p>A conversion to standard library string type <cite>std::string</cite> is supplied using method
+<cite>as_string</cite>. Stream output of PyCXX <cite>Object</cite> instances uses this conversion,
+which in turn uses the Python object's str() representation.</p>
+
+<p>All the numeric operators are defined on all possible combinations of <cite>Object</cite>,
+<cite>long</cite>, and <cite>double</cite>. These use the corresponding Python operators,
+and should the operation fail for some reason, an exception is thrown.</p>
+
+<h3>Dealing with pointers returned by the Python C API</h3>
+
+<p>Often, <cite>PyObject *</cite> pointers are acquired from some function,
+particularly functions in the Python C API. If you wish to make an object from the pointer
+returned by such a function, you need to know if the function returns you an <i>owned</i>
+or <i>unowned</i> reference. Unowned references are unusual but there are some cases where
+unowned references are returned.</p>
+
+<p>Usually, <cite>Object</cite> and its children acquire a new reference when constructed from a
+<cite>PyObject *</cite>. This is usually not the right behavior if the reference comes from one
+of the Python C API calls.</p>
+
+<p>If p is an owned reference, you can add the boolean <cite>true</cite> as an extra
+argument in the creation routine, <cite>Object(p, true)</cite>, or use the function <cite>asObject(p)</cite> which
+returns an <cite>Object</cite> created using the owned reference. For example, the routine
+<cite>PyString_FromString</cite> returns an owned reference to a Python string object. You could write:</p>
+
+<pre>Object w = asObject( PyString_FromString("my string") );</pre>
+
+<p>or using the constructor,</p>
+
+<pre>Object w( PyString_FromString("my string"), true );</pre>
+
+<p>In fact, you would never do this, since PyCXX has a class String and you can just say: </p>
+
+<pre>String w( "my string" );</pre>
+
+<p>Indeed, since most of the Python C API is similarly embodied in <cite>Object</cite>
+and its descendents, you probably will not use asObject all that often.</p>
+<h3>Table 1: Class Object</h3>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Returns</th>
+ <th>Name(signature)</th>
+ <th>Comment</th>
+ </tr>
+ <tr>
+ <td colspan="3"><p align="center"><strong>Basic Methods</strong></td>
+ </tr>
+ <tr>
+ <td class=code>explicit </td>
+ <td class=code>Object (PyObject* pyob=Py_None, bool owned=false) </td>
+ <td>Construct from pointer. </td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Object (const Object&amp; ob)</td>
+ <td>Copycons; acquires an owned reference.</td>
+ </tr>
+ <tr>
+ <td class=code>Object&amp;</td>
+ <td class=code>operator= (const Object&amp; rhs) </td>
+ <td>Acquires an owned reference.</td>
+ </tr>
+ <tr>
+ <td class=code>Object&amp;</td>
+ <td class=code>operator= (PyObject* rhsp) </td>
+ <td>Acquires an owned reference.</td>
+ </tr>
+ <tr>
+ <td class=code>virtual</td>
+ <td class=code>~Object () </td>
+ <td>Releases the reference.</td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>increment_reference_count() </td>
+ <td>Explicitly increment the count</td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>decrement_reference_count()</td>
+ <td>Explicitly decrement count but not to zero</td>
+ </tr>
+ <tr>
+ <td class=code>PyObject*</td>
+ <td class=code>operator* () const</td>
+ <td>Lends the pointer</td>
+ </tr>
+ <tr>
+ <td class=code>PyObject*</td>
+ <td class=code>ptr () const</td>
+ <td>Lends the pointer</td>
+ </tr>
+ <tr>
+ <td class=code>virtual bool</td>
+ <td class=code>accepts (PyObject *pyob) const</td>
+ <td>Would assignment of pyob to this object succeed?</td>
+ </tr>
+ <tr>
+ <td class=code>std::string</td>
+ <td class=code>as_string() const</td>
+ <td>str() representation</td>
+ </tr>
+ <tr>
+ <td colspan="3" align="center"><strong>Python API Interface</strong></td>
+ </tr>
+ <tr>
+ <td class=code>int</td>
+ <td class=code>reference_count () const </td>
+ <td>reference count</td>
+ </tr>
+ <tr>
+ <td class=code>Type</td>
+ <td class=code>type () const</td>
+ <td>associated type object</td>
+ </tr>
+ <tr>
+ <td class=code>String</td>
+ <td class=code>str () const</td>
+ <td>str() representation</td>
+ </tr>
+ <tr>
+ <td class=code>String</td>
+ <td class=code>repr () const</td>
+ <td>repr () representation</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>hasAttr (const std::string&amp; s) const</td>
+ <td>hasattr(this, s)</td>
+ </tr>
+ <tr>
+ <td class=code>Object</td>
+ <td class=code>getAttr (const std::string&amp; s) const</td>
+ <td>getattr(this, s)</td>
+ </tr>
+ <tr>
+ <td class=code>Object</td>
+ <td class=code>getItem (const Object&amp; key) const</td>
+ <td>getitem(this, key)</td>
+ </tr>
+ <tr>
+ <td class=code>long</td>
+ <td class=code>hashValue () const</td>
+ <td>hash(this)</td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>setAttr (const std::string&amp; s,<br>const Object&amp; value)</td>
+ <td>this.s = value</td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>delAttr (const std::string&amp; s) </td>
+ <td>del this.s</td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>delItem (const Object&amp; key) </td>
+ <td>del this[key]</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>isCallable () const</td>
+ <td>does this have callable behavior?</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>isList () const</td>
+ <td>is this a Python list?</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>isMapping () const</td>
+ <td>does this have mapping behaviors?</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>isNumeric () const</td>
+ <td>does this have numeric behaviors?</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>isSequence () const </td>
+ <td>does this have sequence behaviors?</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>isTrue () const</td>
+ <td>is this true in the Python sense?</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>isType (const Type&amp; t) const</td>
+ <td>is type(this) == t?</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>isTuple() const</td>
+ <td>is this a Python tuple?</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>isString() const</td>
+ <td>is this a Python string?</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>isUnicode() const</td>
+ <td>is this a Python Unicode string?</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>isDict() const</td>
+ <td>is this a Python dictionary?</td>
+ </tr>
+ <tr>
+ <td colspan="3" align="center"><strong>Comparison Operators</strong></td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>is(PyObject* pother) const</td>
+ <td>test for identity</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>is(const Object&amp; other) const</td>
+ <td>test for identity</td>
+ </tr>
+ <tr>
+ <td class=code>bool </td>
+ <td class=code>operator==(const Object&amp; o2) const</td>
+ <td>Comparisons use Python cmp</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>operator!=(const Object&amp; o2) const</td>
+ <td>Comparisons use Python cmp</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>operator&gt;=(const Object&amp; o2) const</td>
+ <td>Comparisons use Python cmp</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>operator&lt;=(const Object&amp; o2) const </td>
+ <td>Comparisons use Python cmp</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>operator&lt;(const Object&amp; o2) const</td>
+ <td>Comparisons use Python cmp</td>
+ </tr>
+ <tr>
+ <td class=code>bool</td>
+ <td class=code>operator&gt;(const Object&amp; o2) const</td>
+ <td>Comparisons use Python cmp</td>
+ </tr>
+</table>
+
+<h1>The Basic Types</h1>
+
+<p>Corresponding to each of the basic Python types is a class that inherits from Object.
+Here are the interfaces for those types. Each of them inherits from Object and therefore
+has all of the inherited methods listed for Object. Where a virtual function is overridden
+in a class, the name is underlined. </p>
+
+<h2>Class Type</h2>
+
+<p>Class Type corresponds to Python type objects. There is no default constructor.</p>
+
+<h3>Table 2: class Type</h3>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Returns</th>
+ <th>Name and Signature</th>
+ <th>Comments</th>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Type (PyObject* pyob, bool owned = false)</td>
+ <td>Constructor</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Type (const Object&amp; ob)</td>
+ <td>Constructor</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Type(const Type&amp; t)</td>
+ <td>Copycons</td>
+ </tr>
+ <tr>
+ <td class=code>Type&amp;</td>
+ <td class=code>operator= (const Object&amp; rhs) </td>
+ <td>Assignment</td>
+ </tr>
+ <tr>
+ <td class=code>Type&amp;</td>
+ <td class=code>operator= (PyObject* rhsp) </td>
+ <td>Assignment</td>
+ </tr>
+ <tr>
+ <td class=code>virtual bool</td>
+ <td class=code><u>accepts</u> (PyObject *pyob) const</td>
+ <td>Uses PyType_Check</td>
+ </tr>
+</table>
+
+<h2>Class Int</h2>
+
+<p>Class Int, derived publically from Object, corresponds to Python ints. Note that the
+latter correspond to C long ints. Class Int has an implicit user-defined conversion to
+long int. All constructors, on the other hand, are explicit. The default constructor
+creates a Python int zero.</p>
+
+<h3>Table 3: class Int</h3>
+
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Returns</td>
+ <th>Name and Signature</td>
+ <th>Comments</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Int (PyObject *pyob, bool owned= false, bool owned = false)</td>
+ <td>Constructor</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Int (const Int&amp; ob)</td>
+ <td>Constructor</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Int (long v = 0L)</td>
+ <td>Construct from long</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Int (int v)</td>
+ <td>Contruct from int</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Int (const Object&amp; ob)</td>
+ <td>Copycons</td>
+ </tr>
+ <tr>
+ <td class=code>Int&amp;</td>
+ <td class=code>operator= (const Object&amp; rhs)</td>
+ <td>Assignment</td>
+ </tr>
+ <tr>
+ <td class=code>Int&amp;</td>
+ <td class=code>operator= (PyObject* rhsp)</td>
+ <td>Assignment</td>
+ </tr>
+ <tr>
+ <td class=code>virtual bool&nbsp;&nbsp; </td>
+ <td class=code> (PyObject *pyob) const </td>
+ <td>Based on PyInt_Check</td>
+ </tr>
+ <tr>
+ <td class=code>long</td>
+ <td class=code>operator long() const </td>
+ <td><em>Implicit</em> conversion to long int</td>
+ </tr>
+ <tr>
+ <td class=code>Int&amp;</td>
+ <td class=code>operator= (int v)</td>
+ <td>Assign from int</td>
+ </tr>
+ <tr>
+ <td class=code>Int&amp;</td>
+ <td class=code>operator= (long v) </td>
+ <td>Assign from long</td>
+ </tr>
+</table>
+
+<hr>
+
+<h2>Class Long</h2>
+
+<p>Class Long, derived publically from Object, corresponds to Python type long. In Python,
+a long is an integer type of unlimited size, and is usually used for applications such as
+cryptography, not as a normal integer. Implicit conversions to both double and long are
+provided, although the latter may of course fail if the number is actually too big. All
+constructors are explicit. The default constructor produces a Python long zero.</p>
+
+<h3>Table 4: Class Long</h3>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Returns</td>
+ <th>Name and Signature</td>
+ <th>Comments</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Long (PyObject *pyob</a>, bool owned = false)</td>
+ <td>Constructor</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Long (const Int&amp; ob)</td>
+ <td>Constructor</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Long (long v = 0L)</td>
+ <td>Construct from long</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Long (int v)</td>
+ <td>Contruct from int</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Long (const Object&amp; ob)</td>
+ <td>Copycons</td>
+ </tr>
+ <tr>
+ <td class=code>Long&amp;</td>
+ <td class=code>operator= (const Object&amp; rhs)</td>
+ <td>Assignment</td>
+ </tr>
+ <tr>
+ <td class=code>Long&amp;</td>
+ <td class=code>operator= (PyObject* rhsp)</td>
+ <td>Assignment</td>
+ </tr>
+ <tr>
+ <td class=code>virtual bool</td>
+ <td class=code>(PyObject *pyob) const </td>
+ <td>Based on PyLong_Check</td>
+ </tr>
+ <tr>
+ <td class=code>double</td>
+ <td class=code>operator double() const </td>
+ <td><em>Implicit</em> conversion to double</td>
+ </tr>
+ <tr>
+ <td class=code>long</td>
+ <td class=code>operator long() const</td>
+ <td><em>Implicit</em> conversion to long</td>
+ </tr>
+ <tr>
+ <td class=code>Long&amp;</td>
+ <td class=code>operator= (int v)</td>
+ <td>Assign from int</td>
+ </tr>
+ <tr>
+ <td class=code>Long&amp;</td>
+ <td class=code>operator= (long v) </td>
+ <td>Assign from long</td>
+ </tr>
+</table>
+
+<h2>Class Float</h2>
+
+<p>Class Float corresponds to Python floats, which in turn correspond to C double. The
+default constructor produces the Python float 0.0. </p>
+
+<h3>Table 5: Class Float</h3>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Returns</td>
+ <th>Name and Signature</td>
+ <th>Comments</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Float (PyObject *pyob</a>, bool owned = false)
+ </td>
+ <td>Constructor</td>
+ </tr>
+ <tr>
+ <td class=code></td>
+ <td class=code>Float (const Float&amp; f)&nbsp;&nbsp; </td>
+ <td>Construct from float</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Float (double v=0.0)</td>
+ <td>Construct from double</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Float (const Object&amp; ob)</td>
+ <td>Copycons</td>
+ </tr>
+ <tr>
+ <td class=code>Float&amp;</td>
+ <td class=code>operator= (const Object&amp; rhs)</td>
+ <td>Assignment</td>
+ </tr>
+ <tr>
+ <td class=code>Float&amp;</td>
+ <td class=code>operator= (PyObject* rhsp)</td>
+ <td>Assignment</td>
+ </tr>
+ <tr>
+ <td class=code>virtual bool </td>
+ <td class=code>accepts (PyObject *pyob) const</td>
+ <td>Based on PyFloat_Check</td>
+ </tr>
+ <tr>
+ <td class=code>double </td>
+ <td class=code>operator double () const</td>
+ <td><em>Implicit</em> conversion to double</td>
+ </tr>
+ <tr>
+ <td class=code>Float&amp; </td>
+ <td class=code>operator= (double v)</td>
+ <td>Assign from double</td>
+ </tr>
+ <tr>
+ <td class=code>Float&amp; </td>
+ <td class=code>operator= (int v)</td>
+ <td>Assign from int</td>
+ </tr>
+ <tr>
+ <td class=code>Float&amp; </td>
+ <td class=code>operator= (long v)</td>
+ <td>Assign from long</td>
+ </tr>
+ <tr>
+ <td class=code>Float&amp; </td>
+ <td class=code>operator= (const Int&amp; iob)</td>
+ <td>Assign from Int</td>
+ </tr>
+</table>
+
+<h1>Sequences</h1>
+
+<p>PyCXX implements a quite sophisticated wrapper class for Python sequences. While every
+effort has been made to disguise the sophistication, it may pop up in the form of obscure
+compiler error messages, so in this documentation we will first detail normal usage and
+then discuss what is under the hood.</p>
+
+<p>The basic idea is that we would like the subscript operator [] to work properly, and to
+be able to use STL-style iterators and STL algorithms across the elements of the sequence.</p>
+
+<p>Sequences are implemented in terms of a templated base class, SeqBase&lt;T&gt;. The
+parameter T is the answer to the question, sequence of what? For Lists, for example, T is
+Object, because the most specific thing we know about an element of a List is simply that
+it is an Object. (Class List is defined below; it is a descendent of Object that holds a
+pointer to a Python list). For strings, T is Char, which is a wrapper in turn of Python
+strings whose length is one.</p>
+
+<p>For convenience, the word <strong>Sequence</strong> is a typedef of SeqBase&lt;Object&gt;.</p>
+
+<h2>General sequences</h2>
+
+<p>Suppose you are writing an extension module method that expects the first argument to
+be any kind of Python sequence, and you wish to return the length of that sequence. You
+might write:</p>
+
+<pre>static PyObject*
+my_module_seqlen (PyObject *self, PyObject* args) {
+ try
+ {
+ Tuple t(args); // set up a Tuple pointing to the arguments.
+ if(t.length() != 1)
+ throw PyException(&quot;Incorrect number of arguments to seqlen.&quot;);
+ Sequence s = t[0]; // get argument and be sure it is a sequence
+ return new_reference_to(Int(s.length()));
+ }
+ catch(const PyException&amp;)
+ {
+ return Py_Null;
+ }
+}</pre>
+
+<p>As we will explain later, the try/catch structure converts any errors, such as the
+first argument not being a sequence, into a Python exception.</p>
+
+<h3>Subscripting</h3>
+
+<p>When a sequence is subscripted, the value returned is a special kind of object which
+serves as a proxy object. The general idea of proxy objects is discussed in Scott Meyers'
+book, &quot;More Effective C++&quot;. Proxy objects are necessary because when one
+subscripts a sequence it is not clear whether the value is to be used or the location
+assigned to. Our proxy object is even more complicated than normal because a sequence
+reference such as s[i] is not a direct reference to the i'th object of s. </p>
+
+<p>In normal use, you are not supposed to notice this magic going on behind your back. You
+write:</p>
+
+<pre>Object t;
+Sequence s;
+s[2] = t + s[1]</pre>
+
+<p>and here is what happens: s[1] returns a proxy object. Since there is no addition
+operator in Object that takes a proxy as an argument, the compiler decides to invoke an
+automatic conversion of the proxy to an Object, which returns the desired component of s.
+The addition takes place, and then there is an assignment operator in the proxy class
+created by the s[2], and that assignment operator stuffs the result into the 2 component
+of s.</p>
+
+<p>It is possible to fool this mechanism and end up with a compiler failing to admit that
+a s[i] is an Object. If that happens, you can work around it by writing Object(s[i]),
+which makes the desired implicit conversion, explicit.</p>
+
+<h3>Iterators</h3>
+
+<p>Each sequence class provides the following interface. The class seqref&lt;T&gt; is the
+proxy class. We omit the details of the iterator, const_iterator, and seqref&lt;T&gt;
+here. See CXX_Objects.h if necessary. The purpose of most of this interface is to satisfy
+requirements of the STL.</p>
+
+<h3>The SeqBase&lt;T&gt; Interface</h3>
+
+<p>SeqBase&lt;T&gt; inherits from Object.</p>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</td>
+ <th>Name</td>
+ </tr>
+ <tr>
+ <td class=code>typedef int </td>
+ <td class=code>size_type</td>
+ </tr>
+ <tr>
+ <td class=code>typedef seqref&lt;T&gt;</td>
+ <td class=code>reference</td>
+ </tr>
+ <tr>
+ <td class=code>typedef T </td>
+ <td class=code>const_reference</td>
+ </tr>
+ <tr>
+ <td class=code>typedef seqref&lt;T&gt;*</td>
+ <td class=code>pointer</td>
+ </tr>
+ <tr>
+ <td class=code>typedef int </td>
+ <td class=code>difference_type</td>
+ </tr>
+ <tr>
+ <td class=code>virtual size_type</td>
+ <td class=code>max_size() const</td>
+ </tr>
+ <tr>
+ <td class=code>virtual size_type </td>
+ <td class=code>capacity() const;</td>
+ </tr>
+ <tr>
+ <td class=code>virtual void </td>
+ <td class=code>swap(SeqBase&lt;T&gt;&amp; c);</td>
+ </tr>
+ <tr>
+ <td class=code>virtual size_type </td>
+ <td class=code>size () const;</td>
+ </tr>
+ <tr>
+ <td class=code>explicit </td>
+ <td class=code>SeqBase&lt;T&gt; ();</td>
+ </tr>
+ <tr>
+ <td class=code>explicit </td>
+ <td class=code>SeqBase&lt;T&gt; (PyObject* pyob, bool owned = false);</td>
+ </tr>
+ <tr>
+ <td class=code>explicit </td>
+ <td class=code>SeqBase&lt;T&gt; (const Object&amp; ob);</td>
+ </tr>
+ <tr>
+ <td class=code>SeqBase&lt;T&gt;&amp; </td>
+ <td class=code>operator= (const Object&amp; rhs);</td>
+ </tr>
+ <tr>
+ <td class=code>SeqBase&lt;T&gt;&amp; </td>
+ <td class=code>operator= (PyObject* rhsp);</td>
+ </tr>
+ <tr>
+ <td class=code>virtual bool </td>
+ <td class=code>accepts (PyObject *pyob) const;</td>
+ </tr>
+ <tr>
+ <td class=code>size_type </td>
+ <td class=code>length () const ;</td>
+ </tr>
+ <tr>
+ <td class=code>const T </td>
+ <td class=code>operator[](size_type index) const; </td>
+ </tr>
+ <tr>
+ <td class=code>seqref&lt;T&gt; </td>
+ <td class=code>operator[](size_type index); </td>
+ </tr>
+ <tr>
+ <td class=code>virtual T </td>
+ <td class=code>getItem (size_type i) const;</td>
+ </tr>
+ <tr>
+ <td class=code>virtual void </td>
+ <td class=code>setItem (size_type i, const T&amp; ob);</td>
+ </tr>
+ <tr>
+ <td class=code>SeqBase&lt;T&gt; </td>
+ <td class=code>repeat (int count) const;</td>
+ </tr>
+ <tr>
+ <td class=code>SeqBase&lt;T&gt; </td>
+ <td class=code>concat (const SeqBase&lt;T&gt;&amp; other) const ;</td>
+ </tr>
+ <tr>
+ <td class=code>const T </td>
+ <td class=code>front () const;</td>
+ </tr>
+ <tr>
+ <td class=code>seqref&lt;T&gt; </td>
+ <td class=code>front();</td>
+ </tr>
+ <tr>
+ <td class=code>const T </td>
+ <td class=code>back () const;</td>
+ </tr>
+ <tr>
+ <td class=code>seqref&lt;T&gt; </td>
+ <td class=code>back(); </td>
+ </tr>
+ <tr>
+ <td class=code>void </td>
+ <td class=code>verify_length(size_type required_size);</td>
+ </tr>
+ <tr>
+ <td class=code>void </td>
+ <td class=code>verify_length(size_type min_size, size_type max_size);</td>
+ </tr>
+ <tr>
+ <td class=code>class</td>
+ <td class=code>iterator;</td>
+ </tr>
+ <tr>
+ <td class=code>iterator </td>
+ <td class=code>begin (); </td>
+ </tr>
+ <tr>
+ <td class=code>iterator </td>
+ <td class=code>end ();</td>
+ </tr>
+ <tr>
+ <td class=code>class </td>
+ <td class=code>const_iterator;</td>
+ </tr>
+ <tr>
+ <td class=code>const_iterator </td>
+ <td class=code>begin () const;</td>
+ </tr>
+ <tr>
+ <td class=code>const_iterator </td>
+ <td class=code>end () const;</td>
+ </tr>
+</table>
+
+<p>Any heir of class Object that has a sequence behavior should inherit from class
+SeqBase&lt;T&gt;, where T is specified as the type of object that represents the
+individual elements of the sequence. The requirements on T are that it has a constructor
+that takes a PyObject* as an argument, that it has a default constructor, a copy
+constructor, and an assignment operator. In short, any properly defined heir of Object
+will work. </p>
+
+<h2>Classes Char and String</h2>
+
+<p>Python strings are unusual in that they are immutable sequences of characters. However,
+there is no character type per se; rather, when subscripted strings return a string of
+length one. To simulate this, we define two classes Char and String. The Char class
+represents a Python string object of length one. The String class represents a Python
+string, and its elements make up a sequence of Char's.</p>
+
+<p>The user interface for Char is limited. Unlike String, for example, it is not a
+sequence.</p>
+
+<h3>The Char interface</h3>
+
+<p>Char inherits from Object.</p>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</td>
+ <th>Name</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Char (PyObject *pyob, bool owned = false)</td>
+ </tr>
+ <tr>
+ <td class=code></td>
+ <td class=code>Char (const Object&amp; ob) </td>
+ </tr>
+ <tr>
+ <td class=code></td>
+ <td class=code>Char (const std::string&amp; v = &quot;&quot;) </td>
+ </tr>
+ <tr>
+ <td class=code></td>
+ <td class=code>Char (char v)</td>
+ </tr>
+ <tr>
+ <td class=code></td>
+ <td class=code>Char (Py_UNICODE v)</td>
+ </tr>
+ <tr>
+ <td class=code>Char&amp;</td>
+ <td class=code>operator= (const std::string&amp; v)</td>
+ </tr>
+ <tr>
+ <td class=code>Char&amp;</td>
+ <td class=code>operator= (char v) </td>
+ </tr>
+ <tr>
+ <td class=code>Char&amp;</td>
+ <td class=code>operator= (Py_UNICODE v) </td>
+ </tr>
+ <tr>
+ <td class=code>Char&amp;</td>
+ <td class=code>operator= (std::basic_string<Py_UNICODE> v) </td>
+ </tr>
+ <tr>
+ <td class=code></td>
+ <td class=code>operator String() const</td>
+ </tr>
+ <tr>
+ <td class=code></td>
+ <td class=code>operator std::string () const </td>
+ </tr>
+</table>
+
+<h3>The String Interface</h3>
+
+<p>String inherits from SeqBase&lt;Char&gt;.</p>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</td>
+ <th>Name</td>
+ </tr>
+ <tr>
+ <td class=code>explicit </td>
+ <td class=code>String (PyObject *pyob, bool owned = false)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>String (const Object&amp; ob)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>String (const std::string&amp; v = &quot;&quot;)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>String (const std::string&amp; v, const char *encoding, const char *error=&quot;strict&quot;)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>String (const char *s, const char *encoding, const char *error=&quot;strict&quot;)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>String (const char *s, int len, const char *encoding, const char *error=&quot;strict&quot;)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>String (const std::string&amp; v, std::string::size_type vsize)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>String (const char* v)</td>
+ </tr>
+ <tr>
+ <td class=code>String&amp;</td>
+ <td class=code>operator= (const std::string&amp; v) </td>
+ </tr>
+ <tr>
+ <td class=code>std::string</td>
+ <td class=code>operator std::string () const</td>
+ </tr>
+ <tr>
+ <td class=code>String</td>
+ <td class=code>encode( const char *encoding, const char *error=&quot;strict&quot; )</td>
+ </tr>
+ <tr>
+ <td class=code>String</td>
+ <td class=code>decode( const char *encoding, const char *error=&quot;strict&quot; )</td>
+ </tr>
+ <tr>
+ <td class=code>std::string</td>
+ <td class=code>as_std_string() const</td>
+ </tr>
+ <tr>
+ <td class=code>unicodestring</td>
+ <td class=code>as_unicodestring() const</td>
+ </tr>
+</table>
+
+<h2>Class Tuple</h2>
+
+<p>Class Tuple represents Python tuples. A Tuple is a Sequence. There are two kinds of
+constructors: one takes a PyObject* as usual, the other takes an integer number as an
+argument and returns a Tuple of that length, each component initialized to Py_None. The
+default constructor produces an empty Tuple. </p>
+
+<p>Tuples are not immutable, but attempts to assign to their components will fail if the
+reference count is not 1. That is, it is safe to set the elements of a Tuple you have just
+made, but not thereafter.</p>
+
+<p>Example: create a Tuple containing (1, 2, 4)</p>
+
+<pre>Tuple t(3)
+t[0] = Int(1)
+t[1] = Int(2)
+t[2] = Int(4)</pre>
+
+<p>Example: create a Tuple from a list:</p>
+
+<pre>Dict d
+...
+Tuple t(d.keys())</pre>
+
+<h3>The Tuple Interface</h3>
+
+<p>Tuple inherits from Sequence.. Special run-time checks prevent modification if the
+reference count is greater than one.</p>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</td>
+ <th>Name</td>
+ <th>Comment</td>
+ </tr>
+ <tr>
+ <td class=code>virtual void</td>
+ <td class=code>setItem (int offset, const Object&amp;ob) </td>
+ <td>setItem is overriden to handle tuples properly. </td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Tuple (PyObject *pyob, bool owned = false)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>Tuple (const Object&amp; ob)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Tuple (int size = 0)</td>
+ <td>Create a tuple of the given size. Items initialize to Py_None. Default is an empty
+ tuple.</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Tuple (const Sequence&amp; s)</td>
+ <td>Create a tuple from any sequence.</td>
+ </tr>
+ <tr>
+ <td class=code>Tuple&amp;</td>
+ <td class=code>operator= (const Object&amp; rhs)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>Tuple&amp;</td>
+ <td class=code>operator= (PyObject* rhsp)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>Tuple</td>
+ <td class=code>getSlice (int i, int j) const </td>
+ <td>Equivalent to python's t[i:j]</td>
+ </tr>
+</table>
+
+<h2>Class List</h2>
+
+<p>Class List represents a Python list, and the methods available faithfully reproduce the
+Python API for lists. A List is a Sequence.</p>
+
+<h3>The List Interface</h3>
+
+<p>List inherits from Sequence.</p>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</td>
+ <th>Name</td>
+ <th>Comment</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>List (PyObject *pyob, bool owned = false)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>List (const Object&amp; ob)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>List (int size = 0)</td>
+ <td>Create a list of the given size. Items initialized to Py_None. Default is an empty list.</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>List (const Sequence&amp; s)</td>
+ <td>Create a list from any sequence.</td>
+ </tr>
+ <tr>
+ <td class=code>List&amp;</td>
+ <td class=code>operator= (const Object&amp; rhs)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>List&amp;</td>
+ <td class=code>operator= (PyObject* rhsp)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>List</td>
+ <td class=code>getSlice (int i, int j) const</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>setSlice (int i, int j, const Object&amp; v) </td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>append (const Object&amp; ob)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>insert (int i, const Object&amp; ob)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>sort ()</td>
+ <td>Sorts the list in place, using Python's member function. You can also use
+ the STL sort function on any List instance.</td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>reverse ()</td>
+ <td>Reverses the list in place, using Python's member function.</td>
+ </tr>
+</table>
+
+<h1>Mappings</h1>
+
+<p>A class MapBase&lt;T&gt; is used as the base class for Python objects with a mapping
+behavior. The key behavior of this class is the ability to set and use items by
+subscripting with strings. A proxy class mapref&lt;T&gt; is defined to produce the correct
+behavior for both use and assignment.</p>
+
+<p>For convenience, <cite>Mapping</cite> is a typedef for <cite>MapBase&lt;Object&gt;</cite>.</p>
+
+<h3>The MapBase&lt;T&gt; interface</h3>
+
+<p>MapBase&lt;T&gt; inherits from Object. T should be chosen to reflect the kind of
+element returned by the mapping.</p>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</td>
+ <th>Name</td>
+ <th>Comment</td>
+ </tr>
+ <tr>
+ <td class=code>T</td>
+ <td class=code>operator[](const std::string&amp; key) const</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>mapref&lt;T&gt; </td>
+ <td class=code>operator[](const std::string&amp; key)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>int</td>
+ <td class=code>length () const</td>
+ <td>Number of entries.</td>
+ </tr>
+ <tr>
+ <td class=code>int</td>
+ <td class=code>hasKey (const std::string&amp; s) const </td>
+ <td>Is m[s] defined?</td>
+ </tr>
+ <tr>
+ <td class=code>T</td>
+ <td class=code>getItem (const std::string&amp; s) const</td>
+ <td>m[s]</td>
+ </tr>
+ <tr>
+ <td class=code>virtual void</td>
+ <td class=code>setItem (const std::string&amp; s, const Object&amp; ob)</td>
+ <td>m[s] = ob</td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>delItem (const std::string&amp; s)</td>
+ <td>del m[s]</td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>delItem (const Object&amp; s)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>List</td>
+ <td class=code>keys () const</td>
+ <td>A list of the keys.</td>
+ </tr>
+ <tr>
+ <td class=code>List</td>
+ <td class=code>values () const</td>
+ <td>A list of the values.</td>
+ </tr>
+ <tr>
+ <td class=code>List</td>
+ <td class=code>items () const</td>
+ <td>Each item is a key-value pair.</td>
+ </tr>
+</table>
+
+<h2>Class Dict</h2>
+
+<p>Class Dict represents Python dictionarys. A Dict is a Mapping. Assignment to
+subscripts can be used to set the components.</p>
+
+<pre>Dict d
+d[&quot;Paul Dubois&quot;] = &quot;(925)-422-5426&quot;</pre>
+
+<h3>Interface for Class Dict</h3>
+
+<p>Dict inherits from MapBase&lt;Object&gt;.</p>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</td>
+ <th>Name</td>
+ <th>Comment</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Dict (PyObject *pyob</a>, bool owned = false)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>Dict (const Dict&amp; ob)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>Dict () </td>
+ <td>Creates an empty dictionary</td>
+ </tr>
+ <tr>
+ <td class=code>Dict&amp;</td>
+ <td class=code>operator= (const Object&amp; rhs)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>Dict&amp;</td>
+ <td class=code>operator= (PyObject* rhsp)</td>
+ <td></td>
+ </tr>
+</table>
+
+<h1>Other classes and facilities.</h1>
+
+<p>Class Callable provides an interface to those Python objects that support a call
+method. Class Module holds a pointer to a module. If you want to create an extension
+module, however, see the extension facility. There is a large set of numeric operators.</p>
+
+<h3>Interface to class Callable</h3>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</td>
+ <th>Name</td>
+ <th>Comment</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Callable (PyObject *pyob</a>, bool owned = false)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>Callable&amp; </td>
+ <td class=code>operator= (const Object&amp; rhs)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>Callable&amp; </td>
+ <td class=code>operator= (PyObject* rhsp)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>Object</td>
+ <td class=code>apply(const Tuple&amp; args) const</td>
+ <td>Call the object with the given arguments</td>
+ </tr>
+ <tr>
+ <td class=code>Object</td>
+ <td class=code>apply(PyObject* pargs = 0) const </td>
+ <td>Call the object with args as the arguments. Checks that pargs is a tuple.</td>
+ </tr>
+</table>
+
+<h3>Interface to class Module</h3>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</td>
+ <th>Name</td>
+ <th>Comment</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Module (PyObject* pyob, bool owned = false)</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>Module (const std::string name)</td>
+ <td>Construct from name of module; does the import if needed.</td>
+ </tr>
+ <tr>
+ <td class=code></td>
+ <td class=code>Module (const Module&amp; ob) </td>
+ <td>Copy constructor</td>
+ </tr>
+ <tr>
+ <td class=code>Module&amp;</td>
+ <td class=code>operator= (const Object&amp; rhs) </td>
+ <td>Assignment</td>
+ </tr>
+ <tr>
+ <td class=code>Module&amp;</td>
+ <td class=code>operator= (PyObject* rhsp) </td>
+ <td>Assignment</td>
+ </tr>
+</table>
+
+<h3>Numeric interface</h3>
+
+<p>Unary operators for plus and minus, and binary operators +, -, *, /, and % are defined
+for pairs of objects and for objects with scalar integers or doubles (in either
+order). Functions abs(ob) and coerce(o1, o2) are also defined. </p>
+
+<p>The signature for coerce is:</p>
+
+<pre>inline std::pair&lt;Object,Object&gt; coerce(const Object&amp; a, const Object&amp; b)</pre>
+
+<p>Unlike the C API function, this simply returns the pair after coercion.</p>
+
+<h3>Stream I/O</h3>
+
+<p>Any object can be printed using stream I/O, using std::ostream&amp; operator&lt;&lt;
+(std::ostream&amp; os, const Object&amp; ob). The object's str() representation is
+converted to a standard string which is passed to std::ostream&amp; operator&lt;&lt;
+(std::ostream&amp; os, const std::string&amp;).</p>
+
+<h2>Exceptions</h2>
+
+<p>The Python exception facility and the C++ exception facility can be merged via the use
+of try/catch blocks in the bodies of extension objects and module functions.</p>
+
+<h3>Class Exception and its children</h3>
+
+<p>A set of classes is provided. Each is derived from class Exception, and represents a
+particular sort of Python exception, such as IndexError, RuntimeError, ValueError. Each of
+them (other than Exception) has a constructor which takes an explanatory string as an
+argument, and is used in a throw statement such as:</p>
+
+<pre>throw IndexError(&quot;Index too large in MyObject access.&quot;);</pre>
+
+<p>If in using a routine from the Python API, you discover that it has returned a NULL
+indicating an error, then Python has already set the error message. In that case you
+merely throw Exception.</p>
+
+<h3>List of Exceptions</h3>
+
+<p>The exception hierarchy mirrors the Python exception hierarchy. The concrete exception
+classes are shown here.</p>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</th>
+ <th>Interface for class Exception</th>
+ </tr>
+ <tr>
+ <td class=code>explicit </td>
+ <td class=code>Exception()</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>Exception (const std::string&amp; reason) </td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>Exception (PyObject* exception, const std::string&amp; reason) </td>
+ </tr>
+ <tr>
+ <td class=code>void </td>
+ <td class=code>clear()</td>
+ </tr>
+ <tr>
+ <td class=code></td>
+ <td>Constructors for other children of class Exception</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>TypeError (const std::string&amp; reason)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>IndexError (const std::string&amp; reason)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>AttributeError (const std::string&amp; reason)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>NameError (const std::string&amp; reason)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>RuntimeError (const std::string&amp; reason)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>SystemError (const std::string&amp; reason)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>KeyError (const std::string&amp; reason)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>ValueError (const std::string&amp; reason)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>OverflowError (const std::string&amp; reason)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>ZeroDivisionError (const std::string&amp; reason)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>MemoryError (const std::string&amp; reason)</td>
+ </tr>
+ <tr>
+ <td class=code> </td>
+ <td class=code>SystemExit (const std::string&amp; reason)</td>
+ </tr>
+</table>
+
+<h2>Using Exceptions in extension methods</h2>
+
+<p>The exception facility allows you to integrate the C++ and Python exception mechanisms.
+To do this, you must use the style described below when writing module methods in the old
+C style. </p>
+
+<p>Note: If using the ExtensionModule or PythonExtension mechanisms described below, the
+method handlers include exception handling so that you only need to use exceptions
+explicitly in unusual cases.</p>
+
+<h3>Catching Exceptions from the Python API or PyCXX.</h3>
+
+<p>When writing an extension module method, you can use the following boilerplate. Any
+exceptions caused by the Python API or PyCXX itself will be converted into a Python
+exception. Note that Exception is the most general of the exceptions listed above, and
+therefore this one catch clause will serve to catch all of them. You may wish to catch
+other exceptions, not in the Exception family, in the same way. If so, you need to make
+sure you set the error in Python before returning.</p>
+
+<pre>static PyObject *
+some_module_method(PyObject* self, PyObject* args)
+{
+ Tuple a(args); // we know args is a Tuple
+ try {
+ ...calculate something from a...
+ return ...something, usually of the form new_reference_to(some Object);
+ }
+ catch(const Exception&amp;) {
+ //Exception caught, passing it on to Python
+ return Null ();
+ }
+}
+</pre>
+
+<h3>How to clear an Exception</h3>
+
+<p>If you anticipate that an Exception may be thrown and wish to recover from it, change
+the catch phrase to set a reference to an Exception, and use the method clear() from class
+Exception to clear it.:</p>
+
+<pre>catch(Exception&amp; e)
+ {
+ e.clear();
+ ...now decide what to do about it...
+ }
+</pre>
+
+<h2>Extension Facilities</h2>
+
+<p>CXX/Extensions.hxx provides facilities for:
+
+<ul>
+ <li>Creating a Python extension module</li>
+ <li>Creating new Python extension types</li>
+</ul>
+
+<p>These facilities use CXX/Objects.hxx and its support file cxxsupport.cxx.</p>
+
+<p>If you use CXX/Extensions.hxx you must also include source files cxxextensions.c and
+cxx_extensions.cxx</p>
+
+<h3>Creating an Python extension module</h3>
+
+<p>The usual method of creating a Python extension module is to declare and initialize its
+method table in C. This requires knowledge of the correct form for the table and the order
+in which entries are to be made into it, and requires casts to get everything to compile
+without warning. The PyCXX header file CXX/Extensions.h offers a simpler method. Here is a
+sample usage, in which a module named &quot;example&quot; is created. Note that two
+details are necessary:
+
+<ul>
+ <li>The initialization function must be declared to have external C linkage and to have the
+ expected name. This is a requirement imposed by Python</li>
+ <li>The ExtensionModule object must have a storage class that survives the call to the
+ initialization function. This is most easily accomplished by using a static local inside
+ the initialization function, as in initexample below.</li>
+</ul>
+
+<p>To create an extension module, you inherit from class ExtensionModule templated on
+yourself: In the constructor, you make calls to register methods of this class with Python
+as extension module methods. In this example, two methods are added (this is a simplified
+form of the example in Demo/example.cxx):</p>
+
+<pre>class example_module : public ExtensionModule&lt;example_module&gt;
+{
+public:
+ example_module()
+ : ExtensionModule&lt;example_module&gt;( &quot;example&quot; )
+ {
+ add_varargs_method(&quot;sum&quot;, &amp;example_module::ex_sum, &quot;sum(arglist) = sum of arguments&quot;);
+ add_varargs_method(&quot;test&quot;, &amp;example_module::ex_test, &quot;test(arglist) runs a test suite&quot;);
+
+ initialize( &quot;documentation for the example module&quot; );
+ }
+
+ virtual ~example_module() {}
+
+private:
+ Object ex_sum(const Tuple &amp;a) { ... }
+ Object ex_test(const Tuple &amp;a) { ... }
+};
+</pre>
+
+<p>To initialize the extension, you just instantiate one static instance (static so it
+does not destroy itself!):</p>
+
+<pre>void initexample()
+{
+static example_module* example = new example_module;
+}</pre>
+
+<p>The methods can be written to take Tuples as arguments and return Objects. If
+exceptions occur they are trapped for you and a Python exception is generated. So, for
+example, the implementation of ex_sum might be:</p>
+
+<pre>Object ex_sum (const Tuple &amp;a)
+ {
+ Float f(0.0);
+ for( int i = 0; i &lt; a.length(); i++ )
+ {
+ Float g(a[i]);
+ f = f + g;
+ }
+ return f;
+ }</pre>
+
+<p>class ExtensionModule contains methods to return itself as a Module object, or to
+return its dictionary.</p>
+
+<h3>Interface to class ExtensionModule</h3>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</td>
+ <th>Name</td>
+ <th>Comment</td>
+ </tr>
+ <tr>
+ <td class=code>explicit</td>
+ <td class=code>ExtensionModule (char* name) </td>
+ <td>Create an extension module named &quot;name&quot;</td>
+ </tr>
+ <tr>
+ <td class=code>virtual </td>
+ <td class=code>~ExtensionModule () </td>
+ <td>Destructor</td>
+ </tr>
+ <tr>
+ <td class=code>Dict</td>
+ <td class=code>moduleDictionary() const</td>
+ <td>Returns the module dictionary; module must be initialized.</td>
+ </tr>
+ <tr>
+ <td class=code>Module</td>
+ <td class=code>module() const</td>
+ <td>This module as a Module.</td>
+ </tr>
+ <tr>
+ <td class=code>void </td>
+ <td class=code>add_varargs_method (char *name, method_varargs_function_t method, char *documentation=&quot;&quot;)</td>
+ <td>Add a method to the module.</td>
+ </tr>
+ <tr>
+ <td class=code>void </td>
+ <td class=code>add_keyword_method (char *name, method_keyword_function_t method, char *documentation=&quot;&quot;</td>
+ <td>Add a method that takes keywords</td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>initialize() (protected, call from constructor)</td>
+ <td>Initialize the module once all methods have been added. </td>
+ </tr>
+</table>
+
+<p>The signatures above are:</p>
+
+<pre>typedef Object (T::*method_varargs_function_t)( const Tuple &amp;args );
+typedef Object (T::*method_keyword_function_t)( const Tuple &amp;args, const Dict &amp;kws
+);</pre>
+
+<p>That is, the methods take a Tuple or a Tuple and a Dict, and return an Object. The
+example below has an &amp; in front of the name of the method; we found one compiler that
+needed this.</p>
+
+<h2>Creating a Python extension type</h2>
+
+<p>One of the great things about Python is the way you can create your own object types
+and have Python welcome them as first-class citizens. Unfortunately, part of the way you
+have to do this is not great. Key to the process is the creation of a Python &quot;type
+object&quot;. All instances of this type must share a reference to this one unique type
+object. The type object itself has a multitude of &quot;slots&quot; into which the
+addresses of functions can be added in order to give the object the desired behavior. </p>
+
+<p>Creating extension objects is of course harder since you must specify
+how the object behaves and give it methods. This is shown in some detail in the example
+range.h and range.cxx, with the test routine rangetest.cxx, in directory Demo. If you have never
+created a Python extension before, you should read the Extension manual first and be very
+familiar with Python's &quot;special class methods&quot;. Then what follows will make more
+sense.</p>
+
+<p>The basic idea is to inherit from PythonExtension templated on your self</p>
+
+<pre>class MyObject: public PythonExtension&lt;MyObject&gt; {...}</pre>
+
+<p>As a consequence:
+
+<ul>
+ <li>MyObject is a child of PyObject, so that a MyObject* is-a PyObject*. </li>
+ <li>A static method <cite>check(PyObject*)</cite> is created in class MyObject. This function
+ returns a boolean, testing whether or not the argument is in fact a pointer to an instance
+ of MyObject.</li>
+ <li>The user can connect methods of MyObject to Python so that they are methods on MyObject
+ objects. Each such method has the signature:<br>
+ Object method_name (const Tuple&amp; args).</li>
+ <li>The user can override virtual methods of PythonExtension in order to set behaviors.</li>
+ <li>A method is created to handle the deletion of an instance if and when its reference
+ count goes to zero. This method ensures the calling of the class destructor ~MyObject(),
+ if any, and releases the memory (see below).</li>
+ <li>Both automatic and heap-based instances of MyObject can be created.</li>
+</ul>
+
+<h3>Sample usage of PythonExtension</h3>
+
+<p>Here is a brief overview. You create a class that inherits from PythonExtension
+templated upon itself. You override various methods from PythonExtension to implement
+behaviors, such as getattr, sequence_item, etc. You can also add methods to the object
+that are usable from Python using a similar scheme as for module methods above. </p>
+
+<p>One of the consequences of inheriting from PythonExtension is that you are inheriting
+from PyObject itself. So your class is-a PyObject and instances of it can be passed to the
+Python C API. Note: this example uses the namespace feature of PyCXX.</p>
+
+<p>Hint: You can avoid needing to specify the Py:: prefix if you include the C++ statement
+<cite>using Py;</cite> at the top of your files.</p>
+
+<pre>class range: public Py::PythonExtension&lt;range&gt; {
+public:
+ ... constructors, data, etc.
+ ... methods not callable from Python
+ // initializer, see below
+ static void init_type();
+ // override functions from PythonExtension
+ virtual Py::Object repr();
+ virtual Py::Object getattr( const char *name );
+
+ virtual int sequence_length();
+ virtual Py::Object sequence_item( int i );
+ virtual Py::Object sequence_concat( const Py::Object &amp;j );
+ virtual Py::Object sequence_slice( int i, int j );
+
+ // define python methods of this object
+ Py::Object amethod (const Py::Tuple&amp; args);
+ Py::Object value (const Py::Tuple&amp; args);
+ Py::Object assign (const Py::Tuple&amp; args);
+};</pre>
+
+<p>
+To initialize the type we provide a static method that we can call from some module's
+initializer. We set the name, doc string, and indicate which behaviors range objects
+support. Then we adds the methods.</p>
+
+<pre>void range::init_type()
+{
+ behaviors().name(&quot;range&quot;);
+ behaviors().doc(&quot;range objects: start, stop, step&quot;);
+ behaviors().supportRepr();
+ behaviors().supportGetattr();
+ behaviors().supportSequenceType();
+
+ add_varargs_method(&quot;amethod&quot;, &amp;range::amethod,
+ &quot;demonstrate how to document amethod&quot;);
+ add_varargs_method(&quot;assign&quot;, &amp;range::assign);
+ add_varargs_method(&quot;value&quot;, &amp;range::value);
+}</pre>
+</a>
+
+<p>Do not forget to add the call range::init_type() to some module's init function. You will want
+a method in some module that can create range objects, too.</p>
+
+<h3>Interface to PythonExtension &lt;T&gt;</h3>
+
+<p>Your extension class T inherits PythonExtension&lt;T&gt;.</p>
+
+<table cellspacing=0 cellpadding=3px width="95%">
+ <tr>
+ <th>Type</td>
+ <th>Name</td>
+ <th>Comment</td>
+ </tr>
+ <tr>
+ <td class=code>virtual </td>
+ <td class=code>~PythonExtension&lt;T&gt;() </td>
+ <td>Destructor</td>
+ </tr>
+ <tr>
+ <td class=code>PyTypeObject* </td>
+ <td class=code>type_object() const</td>
+ <td>Returns the object type object.</td>
+ </tr>
+ <tr>
+ <td class=code>int</td>
+ <td class=code>check (PyObject* p)</td>
+ <td>Is p a T?</td>
+ </tr>
+ <tr>
+ <td colspan="3"><strong>Protected </strong></td>
+ </tr>
+ <tr>
+ <td class=code>void </td>
+ <td class=code>add_varargs_method (char *name, method_keyword_function_t method, char *documentation=&quot;&quot;</td>
+ <td>Add a method that takes arguments</td>
+ </tr>
+ <tr>
+ <td class=code>void </td>
+ <td class=code>add_keyword_method (char *name, method_keyword_function_t method, char *documentation=&quot;&quot;</td>
+ <td>Add a method that takes keywords</td>
+ </tr>
+ <tr>
+ <td class=code>static PythonType&amp;</td>
+ <td class=code>behaviors()</td>
+ <td>The type object</td>
+ </tr>
+ <tr>
+ <td class=code>void</td>
+ <td class=code>initialize() (protected, call from constructor)</td>
+ <td>Initialize the module once all methods have been added. </td>
+ </tr>
+</table>
+
+<p>As before the signatures for the methods are Object mymethod(const Tuple&amp;
+args) and Object mykeywordmethod (const Tuple&amp; args, const Dict&amp; keys). In this
+case, the methods must be methods of T.</p>
+
+<p>To set the behaviors of the object you override some or all of these methods from
+PythonExtension&lt;T&gt;:</p>
+
+<pre> virtual int print( FILE *, int );
+ virtual Object getattr( const char * );
+ virtual int setattr( const char *, const Object &amp; );
+ virtual Object getattro( const Object &amp; );
+ virtual int setattro( const Object &amp;, const Object &amp; );
+ virtual int compare( const Object &amp; );
+ virtual Object repr();
+ virtual Object str();
+ virtual long hash();
+ virtual Object call( const Object &amp;, const Object &amp; );
+
+ // Sequence methods
+ virtual int sequence_length();
+ virtual Object sequence_concat( const Object &amp; );
+ virtual Object sequence_repeat( int );
+ virtual Object sequence_item( int );
+ virtual Object sequence_slice( int, int );
+ virtual int sequence_ass_item( int, const Object &amp; );
+ virtual int sequence_ass_slice( int, int, const Object &amp; );
+
+ // Mapping
+ virtual int mapping_length();
+ virtual Object mapping_subscript( const Object &amp; );
+ virtual int mapping_ass_subscript( const Object &amp;, const Object &amp; );
+
+ // 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 &amp; );
+ virtual Object number_subtract( const Object &amp; );
+ virtual Object number_multiply( const Object &amp; );
+ virtual Object number_divide( const Object &amp; );
+ virtual Object number_remainder( const Object &amp; );
+ virtual Object number_divmod( const Object &amp; );
+ virtual Object number_lshift( const Object &amp; );
+ virtual Object number_rshift( const Object &amp; );
+ virtual Object number_and( const Object &amp; );
+ virtual Object number_xor( const Object &amp; );
+ virtual Object number_or( const Object &amp; );
+ virtual Object number_power( const Object &amp;, const Object &amp; );
+
+ // Buffer
+ virtual int buffer_getreadbuffer( int, void** );
+ virtual int buffer_getwritebuffer( int, void** );
+ virtual int buffer_getsegcount( int* );</pre>
+
+<p>Note that dealloc is not one of the functions you can override. That is what your
+destructor is for. As noted below, dealloc behavior is provided for you by
+PythonExtension.</p>
+
+<h3>Type initialization</h3>
+
+<p>To initialize your type, supply a static public member function that can be called
+from the extension module. In that function, obtain the PythonType object by calling
+behaviors() and apply appropriate &quot;support&quot; methods from PythonType to turn on
+the support for that behavior or set of behaviors.</p>
+
+<pre> void supportPrint(void);
+ void supportGetattr(void);
+ void supportSetattr(void);
+ void supportGetattro(void);
+ void supportSetattro(void);
+ void supportCompare(void);
+ void supportRepr(void);
+ void supportStr(void);
+ void supportHash(void);
+ void supportCall(void);
+
+ void supportSequenceType(void);
+ void supportMappingType(void);
+ void supportNumberType(void);
+ void supportBufferType(void);</pre>
+
+<p>Then call add_varargs_method or add_keyword_method to add any methods desired to the
+object.</p>
+
+<h3>Notes on memory management and extension objects</h3>
+
+<p>Normal Python objects exist only on the heap. That is unfortunate, as object creation
+and destruction can be relatively expensive. Class PythonExtension allows creation of both
+local and heap-based objects.</p>
+
+<p>If an extension object is created using operator new, as in:</p>
+
+<pre>range* my_r_ref = new range(1, 20, 3)</pre>
+
+<p>then the entity my_r_ref can be thought of as &quot;owning&quot; the reference created
+in the new object. Thus, the object will never have a reference count of zero. If the
+creator wishes to delete this object, they should either make sure the reference count is
+1 and then do delete my_r_ref, or decrement the reference with Py_DECREF(my_r_ref).</p>
+
+<p>Should my_r_ref give up ownership by being used in an Object constructor, all will
+still be well. When the Object goes out of scope its destructor will be called, and that
+will decrement the reference count, which in turn will trigger the special dealloc routine
+that calls the destructor and deletes the pointer.</p>
+
+<p>If the object is created with automatic scope, as in:</p>
+
+<pre>range my_r(1, 20, 3)</pre>
+
+<p>then my_r can be thought of as owning the reference, and when my_r goes out of scope
+the object will be destroyed. Of course, care must be taken not to have kept any permanent
+reference to this object. Fortunately, in the case of an exception, the C++ exception
+facility will call the destructor of my_r. Naturally, care must be taken not to end up
+with a dangling reference, but such objects can be created and destroyed more efficiently
+than heap-based PyObjects.</p>
+
+<h2>Putting it all together</h2>
+
+<p>The Demo directory of the distribution contains an extensive example of how to use many
+of the facilities in PyCXX. It also serves as a test routine. This test is not completely
+exhaustive but does excercise much of the facility.</p>
+
+<h2>Acknowledgment</h2>
+
+<p>Thank you to Geoffrey Furnish for patiently teaching me the finer points of C++ and its
+template facility, and his critique of PyCXX in particular. With version 4 I welcome Barry
+Scott as co-author. -- Paul Dubois</p>
+
+</body>
+</html>
diff --git a/lib/kross/python/cxx/README.html b/lib/kross/python/cxx/README.html
new file mode 100644
index 00000000..d698725a
--- /dev/null
+++ b/lib/kross/python/cxx/README.html
@@ -0,0 +1,436 @@
+<html>
+
+<head>
+<title>PyCXX README</title>
+
+<style>
+H1, H2, H3, H4 {color: #000099;
+ background-color: lightskyblue}
+h3 {position: relative; left: 20px}
+
+p {position: relative; left: 20px; margin-right: 20px}
+pre {color: #0000cc; background-color: #eeeeee; position: relative; left: 40px; margin-right: 80px;
+ border-style: solid; border-color: black; border-width: thin}
+kbd {color: #990000}
+p cite, ol cite, ul cite {font-family: monospace; font-style: normal; font-size: normal}
+li var, pre var, p var, kbd var {color: #009900; font-style: italic}
+li samp, pre samp, p samp, kbd samp {color: #009900; font-weight: bold}
+li p {position: relative; left: 0}
+table { position: relative; left: 20px; border: solid #888888 1px; background-color: #eeeeee}
+table th {border: solid #888888 1px; background-color: #88dd88; color: black}
+table td {border: solid #888888 1px}
+table td.code {border: solid #888888 1px;font-family: monospace; font-style: normal; font-size: normal}
+p.param {background-color: #eeeeee; border-top: lightskyblue solid 4}
+</style>
+</head>
+
+<body>
+
+<h1>PyCXX -- Python C++ Extensions Support</h1>
+
+<h2>Installation using distutils</h2>
+
+<h3>Windows Installation and Demo</h3>
+<ol>
+<li>Fetch <a href="http://prdownloads.sourceforge.net/cxx/pycxx_5_3_1.tar.gz">
+http://prdownloads.sourceforge.net/cxx/pycxx_5_3_1.tar.gz</a>
+<li>Expand the archive into a directory of your choosing C:\ for example. Note: WinZip can expand .tar.gz files.
+<li>Install the PyCXX files:
+<ol>
+<li><pre>C:> cd \pycxx_5_3_1</pre>
+<li><pre>C:\pycxx_5_3_1> python setup.py install</pre>
+</ol>
+<li>Install the PyCXX Demo:
+<ol>
+<li><pre>C:> cd \PYCXX_5_3_1\Demo</pre>
+<li><pre>C:\PYCXX_5_3_1\Demo> python setup.py install</pre>
+</ol>
+<li>Run the demo:
+<ol>
+<li><pre>C:> python</pre>
+<li><pre>&gt;&gt;&gt; import CXX.example</pre>
+<li><pre>&gt;&gt;&gt; CXX.example.test()</pre>
+<li><pre>&gt;&gt;&gt; r = CXX.example.range( 11, 100, 13 )</pre>
+<li><pre>&gt;&gt;&gt; for i in r: print i</pre>
+<li><pre>...</pre>
+</ol>
+</ul>
+</ol>
+
+
+<h3>Unix Installation and Demo</h3>
+<p>Note: distutils is not available for Python 1.5.2</p>
+
+<ol>
+<li>Fetch <a href="http://prdownloads.sourceforge.net/cxx/pycxx_5_3_1.tar.gz">
+http://prdownloads.sourceforge.net/cxx/PyCXX-V5.3.0.tar.gz</a>
+<li>Login as root. root access is typically needed on Unix systems to install the PyCXX files into the Python directories.
+<li>Expand the archive into a directory of your choosing ~\ for example.
+<li>Install the PyCXX files:
+<ol>
+<li><pre># cd ~\PYCXX_5_3_1</pre>
+<li><pre># python setup.py install</pre>
+</ol>
+<li>Install the PyCXX Demo:
+<ol>
+<li><pre># cd ~\PYCXX_5_3_1\Demo</pre>
+<li><pre># python setup.py install</pre>
+</ol>
+<li>Run the demo:
+<ol>
+<li><pre>~ python</pre>
+<li><pre>&gt;&gt;&gt; import CXX.example</pre>
+<li><pre>&gt;&gt;&gt; CXX.example.test()</pre>
+<li><pre>&gt;&gt;&gt; r = CXX.example.range( 11, 100, 13 )</pre>
+<li><pre>&gt;&gt;&gt; for i in r: print i</pre>
+<li><pre>...</pre>
+</ol>
+</ul>
+</ol>
+
+<h2>Installation using Project and Makefile</h2>
+
+<p>If you cannot or do not wish to use the distutils methods to work with PyCXX a set
+of Makefiles and Project files are provided.</p>
+
+<h3>Windows Installation and Demo</h3>
+<p>
+<ol>
+<li>Fetch <a href="http://prdownloads.sourceforge.net/cxx/PyCXX-V5.3.0.tar.gz">
+http://prdownloads.sourceforge.net/cxx/pycxx_5_3_1.tar.gz</a>
+<li>Expand the archive into a directory of your choosing C:\ for example. WinZip can expand .tar.gz files.
+<li>Build the example. Using Microsoft Visual C++ 6.0 load the workspace corresponsing to the version of
+Python you wish the work with.
+<ul>
+<li>example_py15.dsw - Python 1.5.2
+<li>example_py20.dsw - Python 2.0 and 2.0.1
+<li>example_py21.dsw - Python 2.1 and 2.1.1
+<li>example_py22.dsw - Python 2.2 and its maintanence release
+<li>example_py23.dsw - Python 2.3 and its maintanence release
+</ul>
+<li>Run the example. (I'll assume you are testing Python 2.3)
+<ul>
+<li>cd c:\PYCXX_5_3_1\pyds23
+<li>c:\python21\python -c "import example;example.test()"
+</ul>
+</ol>
+</p>
+<h3>Unix Installation and Demo</h3>
+<p>
+<ol>
+<li>Fetch <a href="http://prdownloads.sourceforge.net/cxx/PyCXX-V5.3.0.tar.gz">
+http://prdownloads.sourceforge.net/cxx/PyCXX-V5.3.0.tar.gz</a>
+<li>Expand the archive into a directory of your choosing ~/ for example.
+<li>Select to makefile for your system and python version.
+<ul>
+<li>example_freebsd_py15.mak - FreeBSD Python 1.5.2 (see <a href="#note_1_5_2">note</a> below)
+<li>example_freebsd_py20.mak - FreeBSD Python 2.0, 2.0.1
+<li>example_freebsd_py21.mak - FreeBSD Python 2.1, 2.1.1
+<li>example_freebsd_py22.mak - FreeBSD Python 2.2
+<li>example_linux_py15.mak - Linux Python 1.5.2
+<li>example_linux_py20.mak - Linux Python 2.0, 2.0.1
+<li>example_linux_py21.mak - Linux Python 2.1, 2.1.1
+<li>example_linux_py22.mak - Linux Python 2.2
+</ul>
+<li>Build the example. Use GNU make<br>
+$ make -f <var>example-makefile</var> example.so
+<li>Run the example.<br>
+$ make -f <var>example-makefile</var> test
+</ol>
+</p>
+
+<p><a id="note_1_5_2">Note:</a> The Unix version of python 1.5.2 may need to be rebuilt so that C++ is support.
+If you get reports of undefined symbols like cout or cerr then its likely that python
+is not compiled and linked to support C and C++.</p>
+
+<p>To create a makefile for another vendors Unix follow these steps:</p>
+<ol>
+<li>copy one of the example make files above.
+<li>edit the variables to match your Python installation and C++ compile needs
+<li>Proceed to build and test as above.
+</ol>
+<p>Note: most of the makefile rules to build PyCXX and its example are contained in example_common.mak.
+</p>
+
+<h2>Revision History</h2>
+<h3>Version 5.3.1 (19-Jan-2005)</h3>
+<p>Support GCC4 and Microsoft .NET 2003 aka MSVC 7.1
+
+<h3>Version 5.3 (21-Oct-2004)</h3>
+<p>String object now support python string and unicode string objects.
+<p>Fix most bugs reported on SourceForge
+
+<h3>Version 5.2 (27-Nov-2003)</h3>
+<p>PyCXX supports Python version 2.3, 2.2, 2.1, 2.0 and 1.5.2 on Windows and Unix.</p>
+<p>Fixed problems with keyword functions.</p>
+<p>Improve Extension API to give access to names and docs
+<p>Support GCC 3.</p>
+<p>Added support for custom Exceptions</p>
+<p></p>
+
+<h3>Version 5.1 (2-Aug-2001)</h3>
+<p>I'm using the name PyCXX for this package, CXX is far to close to a compilers name.</p>
+
+<p>PyCXX supports Python version 2.2, 2.1.1, 2.1, 2.0, 2.0.1 and 1.5.2 on Windows and Unix.</p>
+
+<p>New in this release:</p>
+<ul>
+<li>Support for the Windows Linker /DELAYLOAD feature. Enable this feature by
+defining PY_WIN32_DELAYLOAD_PYTHON_DLL when compiling IndirectPythonInterface.cxx
+<li>Remove "CXX/Array.hxx" and associated code - its does not belong in PyCXX
+<li>Work on the docs. Mostly to clean up the HTML to allow more extensive work.
+<li>Reformated the sources to a consistent style. The mix of styles and tabs sizes
+was making working on the sources error prone.
+<li>Added workaround to setup.py to allow GCC to compile c++ code.
+<li>Added Microsoft Visual C++ 6.0 project files for 1.5, 2.0 and 2.1 builds
+<li>Added Unix make files for Linux (tested on RedHat 7.1) and FreeBSD (tested on 4.3)
+<li>Merged changes from Tom Malcolmson
+</ul>
+
+<h3>(July 9, 2000)</h3>
+<p>Renamed all header files to reflect the CXX include name space and that they are
+C++ header files.
+<p>
+<table cellspacing=0 cellpadding=3px>
+<tr><th>Old</th><th>New</th></tr>
+<tr><td>#include "CXX_Config.h"</td><td>#include "CXX/Config.hxx"</td>
+<tr><td>#include "CXX_Exception.h"</td><td>#include "CXX/Exception.hxx"</td>
+<tr><td>#include "CXX_Extensions.h"</td><td>#include "CXX/Extensions.hxx"</td>
+<tr><td>#include "CXX_Objects.h"</td><td>#include "CXX/Objects.hxx"</td>
+</table>
+
+<h3>Version 5 (May 18, 2000)</h3>
+<p>This version adds Distutils support for installation and some code cleanup.</p>
+
+<h3>Version 4 (October 11, 1999)</h3>
+
+<p>This version contains a massive revision to the part of CXX that supports creating
+extension objects and extension modules. Barry Scott contributed these changes.</p>
+
+<p>CXX has always consisted of two parts: the basic CXX_Objects.h and the more
+experimental CXX_Extensions.h. We will describe the changes to CXX_Objects first, and then
+the changes to CXX_Extensions.h.</p>
+
+<h3>Changes to CXX_Objects</h3>
+
+<h4>1. Owned option eliminates need for FromAPI in most cases</h4>
+
+<p>Object's constructor from PyObject* and method set have a new (backward compatible)
+signature:</p>
+
+<pre>
+Object (PyObject* pyob, bool owned = false);
+void set(PyObject* pyob, bool owned = false);
+</pre>
+
+<p>Users may call these with owned = true if they own the reference pyob already and want
+the Object instance to take over ownership.</p>
+
+<p>A new inline function Object asObject(PyObject* pyob) returns Object(pyob, true); thus,
+one way to construct an object from a pointer returned by the Python API is to call
+asObject on it. </p>
+
+<p>Previously a class FromAPI was provided to solve the problem of taking over an owned
+reference. FromAPI will be eliminated in the next release. It is no longer used by CXX
+itself or its demos. The new mechanism is much cleaner and more efficient.</p>
+
+<p>Other classes in CXX have been given the same &quot;owned&quot; option on their
+constructors: Int, Float, Long, Complex, SeqBase&lt;T&gt;, Tuple, List, Dict, Module,
+Callable.</p>
+
+<h4>2. Namespace support in compiler assumed</h4>
+
+<p>Since EGCS / GCC now supports namespaces and the standard library, the need for
+CXX_config.h is almost gone. We have eliminated all the macros except for one obscure one
+dealing with iterator traits in the standard library.</p>
+
+<h3>Changes to CXX_Extensions</h3>
+
+<p>The changes to CXX_Extensions.h are not backward compatible. However, they simplify
+coding so much that we think it is worth the disruption.</p>
+
+<h4>1. Creating an extension module</h4>
+
+<p>To create an extension module, you inherit from class ExtensionModule templated on
+yourself: In the constructor, you make calls to register methods of this class with Python
+as extension module methods. In this example, two methods are added (this is a simplified
+form of the example in Demo/example.cxx):</p>
+
+<pre>class example_module : public ExtensionModule&lt;example_module&gt;
+{
+public:
+ example_module()
+ : ExtensionModule&lt;example_module&gt;( &quot;example&quot; )
+ {
+ add_varargs_method(&quot;sum&quot;, &amp;example_module::ex_sum, &quot;sum(arglist) = sum of arguments&quot;);
+ add_varargs_method(&quot;test&quot;, &amp;example_module::ex_test, &quot;test(arglist) runs a test suite&quot;);
+
+ initialize( &quot;documentation for the example module&quot; );
+ }
+
+ virtual ~example_module() {}
+
+private:
+ Object ex_sum (const Tuple &amp;a) { ... }
+ Object ex_test( const Tuple &amp;a) { ... }
+};
+</pre>
+
+<p>To initialize the extension, you just instantiate one static instance (static so it
+doesn't destroy itself!):</p>
+
+<pre>
+void initexample()
+ {
+ static example_module* example = new example_module;
+ }
+</pre>
+
+<p>The methods can be written to take Tuples as arguments and return Objects. If
+exceptions occur they are trapped for you and a Python exception is generated. So, for
+example, the implementation of ex_sum might be:</p>
+
+<pre>
+Object ex_sum (const Tuple &amp;a)
+ {
+ Float f(0.0);
+ for( int i = 0; i &lt; a.length(); i++ )
+ {
+ Float g(a[i]);
+ f = f + g;
+ }
+ return f;
+ }
+</pre>
+
+<p>class ExtensionModule contains methods to return itself as a Module object, or to
+return its dictionary.</p>
+
+<h4>Creating extension objects</h4>
+
+<p>Creating extension objects is of course harder since you must specify how the object
+behaves and give it methods. This is shown in some detail in the example range.h and range.cxx,
+with the test routine rangetest.cxx, in directory Demo.</p>
+
+<p>Here is a brief overview. You create a class that inherits from PythonExtension
+templated upon itself. You override various methods from PythonExtension to implement
+behaviors, such as getattr, sequence_item, etc. You can also add methods to the object
+that are usable from Python using a similar scheme as for module methods above. </p>
+
+<p>One of the consequences of inheriting from PythonExtension is that you are inheriting
+from PyObject itself. So your class is-a PyObject and instances of it can be passed to the
+Python C API. Note: this example uses the namespace feature of CXX. The Py:: 's are not
+required if you use the namespace instead.</p>
+
+<pre>
+class range: public Py::PythonExtension&lt;range&gt; {
+public:
+ ... constructors, etc.
+
+ ... methods
+ // initializer, see below
+ static void init_type();
+ // override functions from PythonExtension
+ virtual Py::Object repr();
+ virtual Py::Object getattr( const char *name );
+
+ virtual int sequence_length();
+ virtual Py::Object sequence_item( int i );
+ virtual Py::Object sequence_concat( const Py::Object &amp;j );
+ virtual Py::Object sequence_slice( int i, int j );
+
+ // define python methods of this object
+ Py::Object amethod (const Py::Tuple&amp; args);
+ Py::Object value (const Py::Tuple&amp; args);
+ Py::Object assign (const Py::Tuple&amp; args);
+};
+</pre>
+
+<p>
+To initialize the type you provide a static method that you can call from some module's
+initializer. This method sets the name, doc string, and indicates which behaviors it
+supports. It then adds the methods.</p>
+
+<pre>
+void range::init_type()
+{
+ behaviors().name(&quot;range&quot;);
+ behaviors().doc(&quot;range objects: start, stop, step&quot;);
+ behaviors().supportRepr();
+ behaviors().supportGetattr();
+ behaviors().supportSequenceType();
+
+ add_varargs_method(&quot;amethod&quot;, &amp;range::amethod,
+ &quot;demonstrate how to document amethod&quot;);
+ add_varargs_method(&quot;assign&quot;, &amp;range::assign);
+ add_varargs_method(&quot;value&quot;, &amp;range::value);
+}
+</pre>
+
+<h3>Version 3 (June 18, 1999)</h3>
+
+<p>1. CXX compiles with EGCS snapshot 19990616. EGCS requires a standard library class
+random_access_iterator that is not yet available in some other compilers (such as Windows
+VC6). Therefore a new switch:</p>
+
+<p>STANDARD_LIBRARY_HAS_ITERATOR_TRAITS</p>
+
+<p>has been added to CXX_Config.h that you may need to toggle if you get an error on the
+two lines that mention random_access_iterator. The current definition is correct for VC6
+and EGCS-19990616. </p>
+
+<p>2. A new constructor was added to Module to allow construction from a string containing
+the module name. A test was added for this to the demo.</p>
+
+<h3>Version 2 (Dec. 28, 1998)</h3>
+
+<p>Fixed definition of extension type to match 1.5.2. This version will presumably not
+compile with older versions of Python. This can be fixed by using the previous version's
+definition. I did not take the time to find out what these new &quot;flags&quot; are for
+nor put in any methods to deal with them.</p>
+
+<h3>Version 1</h3>
+
+<p>This is an experimental set of files for supporting the creation of Python extensions
+in C++. </p>
+
+<p>Documentation is in progress at <a href="http://xfiles.llnl.gov">http://xfiles.llnl.gov</a>.
+</p>
+
+<p>To use CXX you use the header files in Include, such as CXX_Objects.h or
+CXX_Extensions.h. You must include the sources in Src in your sources to supply parts of
+the CXX classes required.</p>
+
+<p>A demo is included. The Setup file in this directory compiles this demo named
+&quot;example&quot;. To try the demo, which is also a test routine, you import example and
+then execute:</p>
+
+<pre>
+example.test()
+</pre>
+
+<p>You can also play with the extension object whose constructor is named &quot;range&quot;:</p>
+
+<pre>
+s = range(1, 100, 2)
+print s[2] # should print 5
+</pre>
+
+<p>Compilation with Microsoft Visual C++ 5.0 will succeed but only if you have Service
+Pack 3 installed. Compilation has been known to succeed on a Unix system using KCC by
+using:</p>
+
+<pre>
+setenv CCC &quot;KCC -x&quot;
+</pre>
+
+<p>before running makethis.py.</p>
+
+<p>There is also a python.cxx file for making a stand-alone Python containing this
+example, as well as a similar file arraytest.cxx for testing Array.</p>
+
+<p>Comments to barry@barrys-emacs.org, please.</p>
+
+<p>Barry Scott</p>
+</body>
+</html>
diff --git a/lib/kross/python/cxx/Readme.Kross.txt b/lib/kross/python/cxx/Readme.Kross.txt
new file mode 100644
index 00000000..ec00230a
--- /dev/null
+++ b/lib/kross/python/cxx/Readme.Kross.txt
@@ -0,0 +1,16 @@
+Kross uses PyCXX 5.3.1 (http://cxx.sourceforge.net/)
+to access the Python C API.
+
+Following patches where applied and send back to the PyCXX team.
+
+- Unsigned patch
+ http://sourceforge.net/tracker/index.php?func=detail&aid=1085205&group_id=3180&atid=303180
+- isInstance patch
+ http://sourceforge.net/tracker/index.php?func=detail&aid=1178048&group_id=3180&atid=303180
+- dir patch
+ http://sourceforge.net/tracker/index.php?func=detail&aid=1186676&group_id=3180&atid=303180
+- fixed typos
+ http://sourceforge.net/tracker/index.php?func=detail&aid=1266579&group_id=3180&atid=103180
+ http://sourceforge.net/tracker/index.php?func=detail&aid=1293777&group_id=3180&atid=103180
+
+I also changed the includes to get PyCXX compiled the way we use it.
diff --git a/lib/kross/python/cxx/Version.txt b/lib/kross/python/cxx/Version.txt
new file mode 100644
index 00000000..27be42b3
--- /dev/null
+++ b/lib/kross/python/cxx/Version.txt
@@ -0,0 +1 @@
+PyCxx 5.3.1
diff --git a/lib/kross/python/cxx/cxx_extensions.cxx b/lib/kross/python/cxx/cxx_extensions.cxx
new file mode 100644
index 00000000..f9c942ad
--- /dev/null
+++ b/lib/kross/python/cxx/cxx_extensions.cxx
@@ -0,0 +1,1287 @@
+#include "Extensions.hxx"
+#include "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 )
+ {
+ int 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*);
+
+#if PY_VERSION_HEX < 0x02050000
+ typedef int Py_ssize_t;
+#endif
+ // 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 );
+ }
+
+void PythonType::supportSequenceType()
+ {
+ if( !sequence_table )
+ {
+ sequence_table = new PySequenceMethods;
+ 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?
+ }
+ }
+
+void PythonType::supportMappingType()
+ {
+ if( !mapping_table )
+ {
+ mapping_table = new PyMappingMethods;
+ 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?
+ }
+ }
+
+void PythonType::supportNumberType()
+ {
+ if( !number_table )
+ {
+ number_table = new PyNumberMethods;
+ 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;
+ }
+ }
+
+void PythonType::supportBufferType()
+ {
+ if( !buffer_table )
+ {
+ buffer_table = new PyBufferProcs;
+ 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;
+ }
+ }
+
+// 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 )
+ {
+ *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 = 0L;
+ 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
+
+#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;}
+
+void PythonType::name( const char* nam )
+ {
+ table->tp_name = const_cast<char *>( nam );
+ }
+
+const char *PythonType::getName() const
+ {
+ return table->tp_name;
+ }
+
+void PythonType::doc( const char* d )
+ {
+ table->tp_doc = const_cast<char *>( d );
+ }
+
+const char *PythonType::getDoc() const
+ {
+ return table->tp_doc;
+ }
+
+void PythonType::dealloc( void( *f )( PyObject* ))
+ {
+ table->tp_dealloc = f;
+ }
+
+void PythonType::supportPrint()
+ {
+ table->tp_print = print_handler;
+ }
+
+void PythonType::supportGetattr()
+ {
+ table->tp_getattr = getattr_handler;
+ }
+
+void PythonType::supportSetattr()
+ {
+ table->tp_setattr = setattr_handler;
+ }
+
+void PythonType::supportGetattro()
+ {
+ table->tp_getattro = getattro_handler;
+ }
+
+void PythonType::supportSetattro()
+ {
+ table->tp_setattro = setattro_handler;
+ }
+
+void PythonType::supportCompare()
+ {
+ table->tp_compare = compare_handler;
+ }
+
+void PythonType::supportRepr()
+ {
+ table->tp_repr = repr_handler;
+ }
+
+void PythonType::supportStr()
+ {
+ table->tp_str = str_handler;
+ }
+
+void PythonType::supportHash()
+ {
+ table->tp_hash = hash_handler;
+ }
+
+void PythonType::supportCall()
+ {
+ table->tp_call = call_handler;
+ }
+
+//--------------------------------------------------------------------------------
+//
+// 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 );
+ return new_reference_to( p->call( Py::Object( args ), Py::Object( kw ) ) );
+ 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
+ }
+ }
+
+
+// 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 );
+ int i_count = *count;
+ Py_ssize_t r = p->buffer_getsegcount( &i_count );
+ *count = i_count;
+ return r;
+ }
+ 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(); }
+
+
+// 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( int )
+ { missing_method( sequence_repeat ); return Py::Nothing(); }
+
+Py::Object PythonExtensionBase::sequence_item( int )
+ { missing_method( sequence_item ); return Py::Nothing(); }
+
+Py::Object PythonExtensionBase::sequence_slice( int, int )
+ { missing_method( sequence_slice ); return Py::Nothing(); }
+
+int PythonExtensionBase::sequence_ass_item( int, const Py::Object & )
+ { missing_method( sequence_ass_item ); return -1; }
+
+int PythonExtensionBase::sequence_ass_slice( int, int, 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
+int PythonExtensionBase::buffer_getreadbuffer( int, void** )
+ { missing_method( buffer_getreadbuffer ); return -1; }
+
+int PythonExtensionBase::buffer_getwritebuffer( int, void** )
+ { missing_method( buffer_getwritebuffer ); return -1; }
+
+int PythonExtensionBase::buffer_getsegcount( int* )
+ { 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() );
+ }
+ else
+ {
+ 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 );
+ }
+
+ExtensionExceptionType::~ExtensionExceptionType()
+ {
+ }
+
+Exception::Exception( ExtensionExceptionType &exception, const std::string& reason )
+ {
+ PyErr_SetString (exception.ptr(), reason.c_str());
+ }
+
+
+} // end of namespace Py
diff --git a/lib/kross/python/cxx/cxxextensions.c b/lib/kross/python/cxx/cxxextensions.c
new file mode 100644
index 00000000..6f369b2d
--- /dev/null
+++ b/lib/kross/python/cxx/cxxextensions.c
@@ -0,0 +1,19 @@
+/*
+ Copyright 1998 The Regents of the University of California.
+ All rights reserved. See Legal.htm for full text and disclaimer.
+*/
+
+#include "Python.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+PyObject py_object_initializer = {PyObject_HEAD_INIT(0)};
+#ifdef __cplusplus
+}
+#endif
+
+
+
+
+
+
diff --git a/lib/kross/python/cxx/cxxsupport.cxx b/lib/kross/python/cxx/cxxsupport.cxx
new file mode 100644
index 00000000..61329b60
--- /dev/null
+++ b/lib/kross/python/cxx/cxxsupport.cxx
@@ -0,0 +1,142 @@
+//----------------------------------*-C++-*----------------------------------//
+// Copyright 1998 The Regents of the University of California.
+// All rights reserved. See Legal.htm for full text and disclaimer.
+//---------------------------------------------------------------------------//
+
+#include "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/lib/kross/python/pythonconfig.h b/lib/kross/python/pythonconfig.h
new file mode 100644
index 00000000..64b4eefb
--- /dev/null
+++ b/lib/kross/python/pythonconfig.h
@@ -0,0 +1,105 @@
+/***************************************************************************
+ * pythonconfig.h
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#ifndef KROSS_PYTHON_CONFIG_H
+#define KROSS_PYTHON_CONFIG_H
+
+#include "../main/krossconfig.h"
+
+// Prevent warnings
+#if defined(_XOPEN_SOURCE)
+ #undef _XOPEN_SOURCE
+#endif
+#if defined(_POSIX_C_SOURCE)
+ #undef _POSIX_C_SOURCE
+#endif
+
+// The Python.h needs to be included first.
+#include <Python.h>
+#include <object.h>
+#include <compile.h>
+#include <eval.h>
+#include <frameobject.h>
+
+// Include the PyCXX stuff.
+#include "cxx/Config.hxx"
+#include "cxx/Objects.hxx"
+#include "cxx/Extensions.hxx"
+
+namespace Kross {
+
+/**
+ * The Python plugin for the \a Kross scripting framework.
+ *
+ * The code in this namespace manage the embedded python
+ * interpreter and python-scripts.
+ *
+ * There is no dependency to e.g. the \a Kross::KexiDB
+ * wrapper. Everything is handled through the common
+ * \a Kross::Api bridge. Therefore this interpreter-
+ * implementation should be able to make all defined
+ * wrappers accessible by the python scripting
+ * language.
+ *
+ * Internaly we use PyCXX - a set of classes to help
+ * create extensions of python in the C++ language - to
+ * access the python c api. Any python version since
+ * 2.0 is supported.
+ *
+ * \author Sebastian Sauer
+ * \sa http://www.python.org
+ * \sa http://cxx.sourceforge.net
+ */
+namespace Python {
+
+ // The version of this python plugin. This will be exported
+ // to the scripting code. That way we're able to write
+ // scripting code for different incompatible Kross python
+ // bindings by checking the version. You should increment
+ // this number only if you really know what you're doing.
+ #define KROSS_PYTHON_VERSION 1
+
+ // Enable debugging for Kross::Python::PythonScript
+ //#define KROSS_PYTHON_SCRIPT_CTOR_DEBUG
+ //#define KROSS_PYTHON_SCRIPT_DTOR_DEBUG
+ //#define KROSS_PYTHON_SCRIPT_INIT_DEBUG
+ //#define KROSS_PYTHON_SCRIPT_FINALIZE_DEBUG
+ //#define KROSS_PYTHON_SCRIPT_EXEC_DEBUG
+ //#define KROSS_PYTHON_SCRIPT_CALLFUNC_DEBUG
+ //#define KROSS_PYTHON_SCRIPT_CLASSINSTANCE_DEBUG
+
+ // Enable debugging for Kross::Python::PythonModule
+ //#define KROSS_PYTHON_MODULE_DEBUG
+
+ // Enable debugging for Kross::Python::PythonExtension
+ //#define KROSS_PYTHON_EXTENSION_CTOR_DEBUG
+ //#define KROSS_PYTHON_EXTENSION_DTOR_DEBUG
+
+ //#define KROSS_PYTHON_EXTENSION_TOOBJECT_DEBUG
+ //#define KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+
+ //#define KROSS_PYTHON_EXTENSION_GETATTR_DEBUG
+ //#define KROSS_PYTHON_EXTENSION_GETATTRMETHOD_DEBUG
+ //#define KROSS_PYTHON_EXTENSION_SETATTR_DEBUG
+
+ //#define KROSS_PYTHON_EXTENSION_CALL_DEBUG
+
+}}
+
+#endif
diff --git a/lib/kross/python/pythonextension.cpp b/lib/kross/python/pythonextension.cpp
new file mode 100644
index 00000000..59d9aaed
--- /dev/null
+++ b/lib/kross/python/pythonextension.cpp
@@ -0,0 +1,445 @@
+/***************************************************************************
+ * pythonextension.cpp
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#include "pythonextension.h"
+#include "pythonobject.h"
+
+#include "../api/variant.h"
+#include "../api/dict.h"
+#include "../api/exception.h"
+
+using namespace Kross::Python;
+
+PythonExtension::PythonExtension(Kross::Api::Object::Ptr object)
+ : Py::PythonExtension<PythonExtension>()
+ , m_object(object)
+{
+#ifdef KROSS_PYTHON_EXTENSION_CTOR_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::Constructor objectname='%1' objectclass='%2'").arg(m_object->getName()).arg(m_object->getClassName()) );
+#endif
+
+ behaviors().name("KrossPythonExtension");
+ /*
+ behaviors().doc(
+ "The common KrossPythonExtension object enables passing "
+ "of Kross::Api::Object's from C/C++ to Python and "
+ "backwards in a transparent way."
+ );
+ */
+ behaviors().supportGetattr();
+
+ m_proxymethod = new Py::MethodDefExt<PythonExtension>(
+ "", // methodname, not needed cause we use the method only internaly.
+ 0, // method that should handle the callback, not needed cause proxyhandler will handle it.
+ Py::method_varargs_call_handler_t( proxyhandler ), // callback handler
+ "" // documentation
+ );
+}
+
+PythonExtension::~PythonExtension()
+{
+#ifdef KROSS_PYTHON_EXTENSION_DTOR_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::Destructor objectname='%1' objectclass='%2'").arg(m_object->getName()).arg(m_object->getClassName()) );
+#endif
+ delete m_proxymethod;
+}
+
+#if 0
+Py::Object PythonExtension::str()
+{
+ Kross::Api::Callable* callable = dynamic_cast< Kross::Api::Callable* >(m_object);
+ QString s = callable ? callable->getName() : m_object->getClassName();
+ return toPyObject(s.isEmpty() ? : s);
+}
+
+Py::Object PythonExtension::repr()
+{
+ return toPyObject( m_object->toString() );
+}
+#endif
+
+Py::Object PythonExtension::getattr(const char* n)
+{
+#ifdef KROSS_PYTHON_EXTENSION_GETATTR_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::getattr name='%1'").arg(n) );
+#endif
+
+ if(n[0] == '_') {
+ if(!strcmp(n, "__methods__")) {
+ Py::List methods;
+ QStringList calls = m_object->getCalls();
+ for(QStringList::Iterator it = calls.begin(); it != calls.end(); ++it) {
+#ifdef KROSS_PYTHON_EXTENSION_GETATTR_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::getattr name='%1' callable='%2'").arg(n).arg(*it) );
+#endif
+ methods.append(Py::String( (*it).latin1() ));
+ }
+ return methods;
+ }
+
+ if(!strcmp(n, "__members__")) {
+ Py::List members;
+ Kross::Api::Callable* callable = dynamic_cast<Kross::Api::Callable*>(m_object.data());
+ if(callable) {
+ QMap<QString, Kross::Api::Object::Ptr> children = callable->getChildren();
+ QMap<QString, Kross::Api::Object::Ptr>::Iterator it( children.begin() );
+ for(; it != children.end(); ++it) {
+#ifdef KROSS_PYTHON_EXTENSION_GETATTR_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::getattr n='%1' child='%2'").arg(n).arg(it.key()) );
+#endif
+ members.append(Py::String( it.key().latin1() ));
+ }
+ }
+ return members;
+ }
+
+ //if(n == "__dict__") { krosswarning( QString("PythonExtension::getattr(%1) __dict__").arg(n) ); return Py::None(); }
+ //if(n == "__class__") { krosswarning( QString("PythonExtension::getattr(%1) __class__").arg(n) ); return Py::None(); }
+
+#ifdef KROSS_PYTHON_EXTENSION_GETATTR_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::getattr name='%1' is a internal name.").arg(n) );
+#endif
+ return Py::PythonExtension<PythonExtension>::getattr_methods(n);
+ }
+
+ // Redirect the call to our static proxy method which will take care
+ // of handling the call.
+ Py::Tuple self(2);
+ self[0] = Py::Object(this);
+ self[1] = Py::String(n);
+ return Py::Object(PyCFunction_New( &m_proxymethod->ext_meth_def, self.ptr() ), true);
+}
+
+/*
+Py::Object PythonExtension::getattr_methods(const char* n)
+{
+#ifdef KROSS_PYTHON_EXTENSION_GETATTRMETHOD_DEBUG
+ krossdebug( QString("PythonExtension::getattr_methods name=%1").arg(n) );
+#endif
+ return Py::PythonExtension<PythonExtension>::getattr_methods(n);
+}
+
+int PythonExtension::setattr(const char* name, const Py::Object& value)
+{
+#ifdef KROSS_PYTHON_EXTENSION_SETATTR_DEBUG
+ krossdebug( QString("PythonExtension::setattr name=%1 value=%2").arg(name).arg(value.as_string().c_str()) );
+#endif
+ return Py::PythonExtension<PythonExtension>::setattr(name, value);
+}
+*/
+
+Kross::Api::List::Ptr PythonExtension::toObject(const Py::Tuple& tuple)
+{
+#ifdef KROSS_PYTHON_EXTENSION_TOOBJECT_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::toObject(Py::Tuple)") );
+#endif
+
+ QValueList<Kross::Api::Object::Ptr> l;
+ uint size = tuple.size();
+ for(uint i = 0; i < size; i++)
+ l.append( toObject( tuple[i] ) );
+ return new Kross::Api::List(l);
+}
+
+Kross::Api::List::Ptr PythonExtension::toObject(const Py::List& list)
+{
+#ifdef KROSS_PYTHON_EXTENSION_TOOBJECT_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::toObject(Py::List)") );
+#endif
+
+ QValueList<Kross::Api::Object::Ptr> l;
+ uint length = list.length();
+ for(uint i = 0; i < length; i++)
+ l.append( toObject( list[i] ) );
+ return new Kross::Api::List(l);
+}
+
+Kross::Api::Dict::Ptr PythonExtension::toObject(const Py::Dict& dict)
+{
+ QMap<QString, Kross::Api::Object::Ptr> map;
+ Py::List l = dict.keys();
+ uint length = l.length();
+ for(Py::List::size_type i = 0; i < length; ++i) {
+ const char* n = l[i].str().as_string().c_str();
+ map.replace(n, toObject( dict[n] ));
+ }
+ return new Kross::Api::Dict(map);
+}
+
+Kross::Api::Object::Ptr PythonExtension::toObject(const Py::Object& object)
+{
+#ifdef KROSS_PYTHON_EXTENSION_TOOBJECT_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::toObject(Py::Object) object='%1'").arg(object.as_string().c_str()) );
+#endif
+ if(object == Py::None())
+ return 0;
+ PyTypeObject *type = (PyTypeObject*) object.type().ptr();
+#ifdef KROSS_PYTHON_EXTENSION_TOOBJECT_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::toObject(Py::Object) type='%1'").arg(type->tp_name) );
+#endif
+ if(type == &PyInt_Type)
+ return new Kross::Api::Variant(int(Py::Int(object)));
+ if(type == &PyBool_Type)
+ return new Kross::Api::Variant(QVariant(object.isTrue(),0));
+ if(type == &PyLong_Type)
+ return new Kross::Api::Variant(Q_LLONG(long(Py::Long(object))));
+ if(type == &PyFloat_Type)
+ return new Kross::Api::Variant(double(Py::Float(object)));
+
+ if( PyType_IsSubtype(type,&PyString_Type) ) {
+#ifdef Py_USING_UNICODE
+ /* TODO
+ if(type == &PyUnicode_Type) {
+ Py::unicodestring u = Py::String(object).as_unicodestring();
+ std::string s;
+ std::copy(u.begin(), u.end(), std::back_inserter(s));
+ return new Kross::Api::Variant(s.c_str());
+ }
+ */
+#endif
+ return new Kross::Api::Variant(object.as_string().c_str());
+ }
+
+ if(type == &PyTuple_Type)
+ return toObject(Py::Tuple(object)).data();
+ if(type == &PyList_Type)
+ return toObject(Py::List(object)).data();
+ if(type == &PyDict_Type)
+ return toObject(Py::Dict(object.ptr())).data();
+
+ if(object.isInstance())
+ return new PythonObject(object);
+
+ Py::ExtensionObject<PythonExtension> extobj(object);
+ PythonExtension* extension = extobj.extensionObject();
+ if(! extension) {
+ krosswarning("EXCEPTION in PythonExtension::toObject(): Failed to determinate PythonExtension object.");
+ throw Py::Exception("Failed to determinate PythonExtension object.");
+ }
+ if(! extension->m_object) {
+ krosswarning("EXCEPTION in PythonExtension::toObject(): Failed to convert the PythonExtension object into a Kross::Api::Object.");
+ throw Py::Exception("Failed to convert the PythonExtension object into a Kross::Api::Object.");
+ }
+
+#ifdef KROSS_PYTHON_EXTENSION_TOOBJECT_DEBUG
+ krossdebug( "Kross::Python::PythonExtension::toObject(Py::Object) successfully converted into Kross::Api::Object." );
+#endif
+ return extension->m_object;
+}
+
+const Py::Object PythonExtension::toPyObject(const QString& s)
+{
+#ifdef KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::toPyObject(QString)") );
+#endif
+ return s.isNull() ? Py::String() : Py::String(s.latin1());
+}
+
+const Py::List PythonExtension::toPyObject(const QStringList& list)
+{
+#ifdef KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::toPyObject(QStringList)") );
+#endif
+ Py::List l;
+ for(QStringList::ConstIterator it = list.constBegin(); it != list.constEnd(); ++it)
+ l.append(toPyObject(*it));
+ return l;
+}
+
+const Py::Dict PythonExtension::toPyObject(const QMap<QString, QVariant>& map)
+{
+#ifdef KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::toPyObject(QMap<QString,QVariant>)") );
+#endif
+ Py::Dict d;
+ for(QMap<QString, QVariant>::ConstIterator it = map.constBegin(); it != map.constEnd(); ++it)
+ d.setItem(it.key().latin1(), toPyObject(it.data()));
+ return d;
+}
+
+const Py::List PythonExtension::toPyObject(const QValueList<QVariant>& list)
+{
+#ifdef KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::toPyObject(QValueList<QVariant>)") );
+#endif
+ Py::List l;
+ for(QValueList<QVariant>::ConstIterator it = list.constBegin(); it != list.constEnd(); ++it)
+ l.append(toPyObject(*it));
+ return l;
+}
+
+const Py::Object PythonExtension::toPyObject(const QVariant& variant)
+{
+#ifdef KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::toPyObject(QVariant) typename='%1'").arg(variant.typeName()) );
+#endif
+
+ switch(variant.type()) {
+ case QVariant::Invalid:
+ return Py::None();
+ case QVariant::Bool:
+ return Py::Int(variant.toBool());
+ case QVariant::Int:
+ return Py::Int(variant.toInt());
+ case QVariant::UInt:
+ return Py::Long((unsigned long)variant.toUInt());
+ case QVariant::Double:
+ return Py::Float(variant.toDouble());
+ case QVariant::Date:
+ case QVariant::Time:
+ case QVariant::DateTime:
+ case QVariant::ByteArray:
+ case QVariant::BitArray:
+ case QVariant::CString:
+ case QVariant::String:
+ return toPyObject(variant.toString());
+ case QVariant::StringList:
+ return toPyObject(variant.toStringList());
+ case QVariant::Map:
+ return toPyObject(variant.toMap());
+ case QVariant::List:
+ return toPyObject(variant.toList());
+
+ // To handle following both cases is a bit difficult
+ // cause Python doesn't spend an easy possibility
+ // for such large numbers (TODO maybe BigInt?). So,
+ // we risk overflows here, but well...
+ case QVariant::LongLong: {
+ Q_LLONG l = variant.toLongLong();
+ //return (l < 0) ? Py::Long((long)l) : Py::Long((unsigned long)l);
+ return Py::Long((long)l);
+ //return Py::Long(PyLong_FromLong( (long)l ), true);
+ } break;
+ case QVariant::ULongLong: {
+ return Py::Long((unsigned long)variant.toULongLong());
+ } break;
+
+ default: {
+ krosswarning( QString("Kross::Python::PythonExtension::toPyObject(QVariant) Not possible to convert the QVariant type '%1' to a Py::Object.").arg(variant.typeName()) );
+ return Py::None();
+ }
+ }
+}
+
+const Py::Object PythonExtension::toPyObject(Kross::Api::Object::Ptr object)
+{
+ if(! object) {
+#ifdef KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+ krossdebug("Kross::Python::PythonExtension::toPyObject(Kross::Api::Object) is NULL => Py::None");
+#endif
+ return Py::None();
+ }
+
+ const QString classname = object->getClassName();
+ if(classname == "Kross::Api::Variant") {
+ QVariant v = static_cast<Kross::Api::Variant*>( object.data() )->getValue();
+#ifdef KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::toPyObject(Kross::Api::Object) is Kross::Api::Variant %1").arg(v.toString()) );
+#endif
+ return toPyObject(v);
+ }
+
+ if(classname == "Kross::Api::List") {
+#ifdef KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+ krossdebug("Kross::Python::PythonExtension::toPyObject(Kross::Api::Object) is Kross::Api::List");
+#endif
+ Py::List pylist;
+ Kross::Api::List* list = static_cast<Kross::Api::List*>( object.data() );
+ QValueList<Kross::Api::Object::Ptr> valuelist = list->getValue();
+ for(QValueList<Kross::Api::Object::Ptr>::Iterator it = valuelist.begin(); it != valuelist.end(); ++it)
+ pylist.append( toPyObject(*it) ); // recursive
+ return pylist;
+ }
+
+ if(classname == "Kross::Api::Dict") {
+#ifdef KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+ krossdebug("Kross::Python::PythonExtension::toPyObject(Kross::Api::Object) is Kross::Api::Dict");
+#endif
+ Py::Dict pydict;
+ Kross::Api::Dict* dict = static_cast<Kross::Api::Dict*>( object.data() );
+ QMap<QString, Kross::Api::Object::Ptr> valuedict = dict->getValue();
+ for(QMap<QString, Kross::Api::Object::Ptr>::Iterator it = valuedict.begin(); it != valuedict.end(); ++it) {
+ const char* n = it.key().latin1();
+ pydict[ n ] = toPyObject( it.data() ); // recursive
+ }
+ return pydict;
+ }
+
+#ifdef KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+ krossdebug( QString("Trying to handle PythonExtension::toPyObject(%1) as PythonExtension").arg(object->getClassName()) );
+#endif
+ return Py::asObject( new PythonExtension(object) );
+}
+
+const Py::Tuple PythonExtension::toPyTuple(Kross::Api::List::Ptr list)
+{
+#ifdef KROSS_PYTHON_EXTENSION_TOPYOBJECT_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::toPyTuple(Kross::Api::List) name='%1'").arg(list ? list->getName() : "NULL") );
+#endif
+ uint count = list ? list->count() : 0;
+ Py::Tuple tuple(count);
+ for(uint i = 0; i < count; i++)
+ tuple.setItem(i, toPyObject(list->item(i)));
+ return tuple;
+}
+
+PyObject* PythonExtension::proxyhandler(PyObject *_self_and_name_tuple, PyObject *args)
+{
+ Py::Tuple tuple(_self_and_name_tuple);
+ PythonExtension *self = static_cast<PythonExtension*>( tuple[0].ptr() );
+ QString methodname = Py::String(tuple[1]).as_string().c_str();
+
+ try {
+ Kross::Api::List::Ptr arguments = toObject( Py::Tuple(args) );
+
+#ifdef KROSS_PYTHON_EXTENSION_CALL_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::proxyhandler methodname='%1' arguments='%2'").arg(methodname).arg(arguments->toString()) );
+#endif
+
+ Kross::Api::Callable* callable = dynamic_cast<Kross::Api::Callable*>(self->m_object.data());
+ if(callable && callable->hasChild(methodname)) {
+#ifdef KROSS_PYTHON_EXTENSION_CALL_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::proxyhandler methodname='%1' is a child object of '%2'.").arg(methodname).arg(self->m_object->getName()) );
+#endif
+ Py::Object result = toPyObject( callable->getChild(methodname)->call(QString::null, arguments) );
+ result.increment_reference_count();
+ return result.ptr();
+ }
+#ifdef KROSS_PYTHON_EXTENSION_CALL_DEBUG
+ krossdebug( QString("Kross::Python::PythonExtension::proxyhandler try to call function with methodname '%1' in object '%2'.").arg(methodname).arg(self->m_object->getName()) );
+#endif
+ Py::Object result = toPyObject( self->m_object->call(methodname, arguments) );
+ result.increment_reference_count();
+ return result.ptr();
+ }
+ catch(Py::Exception& e) {
+ const QString err = Py::value(e).as_string().c_str();
+ krosswarning( QString("Py::Exception in Kross::Python::PythonExtension::proxyhandler %1").arg(err) );
+ //throw e;
+ }
+ catch(Kross::Api::Exception::Ptr e) {
+ const QString err = e->toString();
+ krosswarning( QString("Kross::Api::Exception in Kross::Python::PythonExtension::proxyhandler %1").arg(err) );
+ // Don't throw here cause it will end in a crash deep in python. The
+ // error is already handled anyway.
+ //throw Py::Exception( (char*) e->toString().latin1() );
+ }
+
+ return Py_None;
+}
diff --git a/lib/kross/python/pythonextension.h b/lib/kross/python/pythonextension.h
new file mode 100644
index 00000000..02e42587
--- /dev/null
+++ b/lib/kross/python/pythonextension.h
@@ -0,0 +1,221 @@
+/***************************************************************************
+ * pythonextension.h
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#ifndef KROSS_PYTHON_EXTENSION_H
+#define KROSS_PYTHON_EXTENSION_H
+
+#include "pythonconfig.h"
+
+#include "../api/object.h"
+#include "../api/list.h"
+#include "../api/dict.h"
+#include "../api/class.h"
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qvaluelist.h>
+#include <qvaluevector.h>
+#include <qmap.h>
+#include <qvariant.h>
+
+namespace Kross { namespace Python {
+
+ // Forward declaration.
+ class PythonScript;
+
+ /**
+ * The PythonExtension is a wrapper-object to let C++ and
+ * Python interact together.
+ * Instances of this class are used everytime if we send
+ * or got something to/from python.
+ */
+ class PythonExtension : public Py::PythonExtension<PythonExtension>
+ {
+ friend class PythonScript;
+ friend class PythonObject;
+ friend class PythonModule;
+
+ public:
+
+ /**
+ * Constructor.
+ *
+ * \param object The \a Kross::Api::Object object
+ * this instance is the wrapper for.
+ */
+ explicit PythonExtension(Kross::Api::Object::Ptr object);
+
+ /**
+ * Destructor.
+ */
+ virtual ~PythonExtension();
+
+#if 0
+ /**
+ * Overloaded method to return the string-representation
+ * of this object.
+ *
+ * \return The string representation.
+ */
+ virtual Py::Object str();
+
+ /**
+ * Overloaded method to return the string-representation
+ * of the value this object has.
+ *
+ * \return A string representation of the value.
+ */
+ virtual Py::Object repr();
+#endif
+
+ /**
+ * Overloaded method to handle attribute calls
+ * from within python.
+ *
+ * \param name The name of the attribute that
+ * should be handled.
+ * \return An \a Py::Object that could be
+ * a value or a callable object. Python
+ * will decide what to do with the
+ * returnvalue.
+ */
+ virtual Py::Object getattr(const char* name);
+
+ //virtual Py::Object getattr_methods(const char* name);
+ //virtual int setattr(const char* name, const Py::Object& value);
+
+ private:
+
+ /**
+ * Converts a \a Py::Tuple into a \a Kross::Api::List .
+ *
+ * \param tuple The Py::Tuple to convert.
+ * \return The to a Kross::Api::List converted Py::Tuple .
+ */
+ static Kross::Api::List::Ptr toObject(const Py::Tuple& tuple);
+
+ /**
+ * Converts a \a Py::List into a \a Kross::Api::List .
+ *
+ * \param list The Py::List to convert.
+ * \return The to a Kross::Api::List converted Py::List .
+ */
+ static Kross::Api::List::Ptr toObject(const Py::List& list);
+
+ /**
+ * Converts a \a Py::Dict into a \a Kross::Api::Dict .
+ *
+ * \param dict The Py::Dict to convert.
+ * \return The to a Kross::Api::Dict converted Py::Dict .
+ */
+ static Kross::Api::Dict::Ptr toObject(const Py::Dict& dict);
+
+ /**
+ * Converts a \a Py::Object into a \a Kross::Api::Object.
+ *
+ * \param object The Py::Object to convert.
+ * \return The to a Kross::Api::Object converted Py::Object.
+ */
+ static Kross::Api::Object::Ptr toObject(const Py::Object& object);
+
+ /**
+ * Converts a QString to a Py::Object. If
+ * the QString isNull() then Py::None() will
+ * be returned.
+ *
+ * \param s The QString to convert.
+ * \return The to a Py::String converted QString.
+ */
+ static const Py::Object toPyObject(const QString& s);
+
+ /**
+ * Converts a QStringList to a Py::List.
+ *
+ * \param list The QStringList to convert.
+ * \return The to a Py::List converted QStringList.
+ */
+ static const Py::List toPyObject(const QStringList& list);
+
+ /**
+ * Converts a QMap to a Py::Dict.
+ *
+ * \param map The QMap to convert.
+ * \return The to a Py::Dict converted QMap.
+ */
+ static const Py::Dict toPyObject(const QMap<QString, QVariant>& map);
+
+ /**
+ * Converts a QValueList to a Py::List.
+ *
+ * \param list The QValueList to convert.
+ * \return The to a Py::List converted QValueList.
+ */
+ static const Py::List toPyObject(const QValueList<QVariant>& list);
+
+ /**
+ * Converts a QVariant to a Py::Object.
+ *
+ * \param variant The QVariant to convert.
+ * \return The to a Py::Object converted QVariant.
+ */
+ static const Py::Object toPyObject(const QVariant& variant);
+
+ /**
+ * Converts a \a Kross::Api::Object to a Py::Object.
+ *
+ * \param object The Kross::Api::Object to convert.
+ * \return The to a Py::Object converted Kross::Api::Object.
+ */
+ static const Py::Object toPyObject(Kross::Api::Object::Ptr object);
+
+ /**
+ * Converts a \a Kross::Api::List into a Py::Tuple.
+ *
+ * \param list The Kross::Api::List to convert.
+ * \return The to a Py::Tuple converted Kross::Api::List.
+ */
+ static const Py::Tuple toPyTuple(Kross::Api::List::Ptr list);
+
+ /// The \a Kross::Api::Object this PythonExtension wraps.
+ Kross::Api::Object::Ptr m_object;
+
+ /**
+ * The proxymethod which will handle all calls to our
+ * \a PythonExtension instance.
+ */
+ Py::MethodDefExt<PythonExtension>* m_proxymethod;
+
+ /**
+ * The static proxy-handler which will be used to dispatch
+ * a call to our \a PythonExtension instance and redirect
+ * the call to the matching method.
+ *
+ * \param _self_and_name_tuple A tuple containing as first
+ * argument a reference to our \a PythonExtension
+ * instance.
+ * \param _args The optional passed arguments for the method
+ * which should be called.
+ * \return The returnvalue of the methodcall.
+ */
+ static PyObject* proxyhandler(PyObject* _self_and_name_tuple, PyObject* _args);
+ };
+
+}}
+
+#endif
diff --git a/lib/kross/python/pythoninterpreter.cpp b/lib/kross/python/pythoninterpreter.cpp
new file mode 100644
index 00000000..92f627dd
--- /dev/null
+++ b/lib/kross/python/pythoninterpreter.cpp
@@ -0,0 +1,255 @@
+/***************************************************************************
+ * pythoninterpreter.cpp
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#include "pythoninterpreter.h"
+#include "pythonscript.h"
+#include "pythonmodule.h"
+#include "pythonsecurity.h"
+//#include "pythonextension.h"
+#include "../api/variant.h"
+
+#include <kglobal.h>
+#include <kstandarddirs.h>
+
+#if defined(Q_WS_WIN)
+ #define PYPATHDELIMITER ";"
+#else
+ #define PYPATHDELIMITER ":"
+#endif
+
+extern "C"
+{
+ /**
+ * Exported and loadable function as entry point to use
+ * the \a PythonInterpreter.
+ * The krosspython library the \a PythonInterpreter is part
+ * will be loaded dynamicly at runtime from e.g.
+ * \a Kross::Api::Manager::getInterpreter and this exported
+ * function will be used to return an instance of the
+ * \a PythonInterpreter implementation.
+ */
+ void* krossinterpreter(Kross::Api::InterpreterInfo* info)
+ {
+ try {
+ return new Kross::Python::PythonInterpreter(info);
+ }
+ catch(Kross::Api::Exception::Ptr e) {
+ Kross::krosswarning("krossinterpreter(Kross::Api::InterpreterInfo* info): Unhandled exception.");
+ }
+ return 0;
+ }
+}
+
+using namespace Kross::Python;
+
+namespace Kross { namespace Python {
+
+ /// \internal
+ class PythonInterpreterPrivate
+ {
+ public:
+
+ /// The __main__ python module.
+ PythonModule* mainmodule;
+
+ /// The \a PythonSecurity python module to wrap the RestrictedPython functionality.
+ PythonSecurity* security;
+ };
+
+}}
+
+PythonInterpreter::PythonInterpreter(Kross::Api::InterpreterInfo* info)
+ : Kross::Api::Interpreter(info)
+ , d(new PythonInterpreterPrivate())
+{
+ // Initialize the python interpreter.
+ initialize();
+
+ // Set name of the program.
+ Py_SetProgramName(const_cast<char*>("Kross"));
+
+ /*
+ // Set arguments.
+ //char* comm[0];
+ const char* comm = const_cast<char*>("kross"); // name.
+ PySys_SetArgv(1, comm);
+ */
+
+ // In the python sys.path are all module-directories are
+ // listed in.
+ QString path;
+
+ // First import the sys-module to remember it's sys.path
+ // list in our path QString.
+ Py::Module sysmod( PyImport_ImportModule("sys"), true );
+ Py::Dict sysmoddict = sysmod.getDict();
+ Py::Object syspath = sysmoddict.getItem("path");
+ if(syspath.isList()) {
+ Py::List syspathlist = syspath;
+ for(Py::List::iterator it = syspathlist.begin(); it != syspathlist.end(); ++it)
+ if( (*it).isString() )
+ path.append( QString(Py::String(*it).as_string().c_str()) + PYPATHDELIMITER );
+ }
+ else
+ path = Py_GetPath();
+
+ // Determinate additional module-paths we like to add.
+ // First add the global Kross modules-path.
+ QStringList krossdirs = KGlobal::dirs()->findDirs("data", "kross/python");
+ for(QStringList::Iterator krossit = krossdirs.begin(); krossit != krossdirs.end(); ++krossit)
+ path.append(*krossit + PYPATHDELIMITER);
+ // Then add the application modules-path.
+ QStringList appdirs = KGlobal::dirs()->findDirs("appdata", "kross/python");
+ for(QStringList::Iterator appit = appdirs.begin(); appit != appdirs.end(); ++appit)
+ path.append(*appit + PYPATHDELIMITER);
+
+ // Set the extended sys.path.
+ PySys_SetPath( (char*) path.latin1() );
+
+ krossdebug(QString("Python ProgramName: %1").arg(Py_GetProgramName()));
+ krossdebug(QString("Python ProgramFullPath: %1").arg(Py_GetProgramFullPath()));
+ krossdebug(QString("Python Version: %1").arg(Py_GetVersion()));
+ krossdebug(QString("Python Platform: %1").arg(Py_GetPlatform()));
+ krossdebug(QString("Python Prefix: %1").arg(Py_GetPrefix()));
+ krossdebug(QString("Python ExecPrefix: %1").arg(Py_GetExecPrefix()));
+ krossdebug(QString("Python Path: %1").arg(Py_GetPath()));
+ krossdebug(QString("Python System Path: %1").arg(path));
+
+ // Initialize the main module.
+ d->mainmodule = new PythonModule(this);
+
+ // The main dictonary.
+ Py::Dict moduledict = d->mainmodule->getDict();
+ //TODO moduledict["KrossPythonVersion"] = Py::Int(KROSS_PYTHON_VERSION);
+
+ // Prepare the interpreter.
+ QString s =
+ "import sys\n"
+ //"sys.setdefaultencoding('latin-1')\n"
+
+ // Dirty hack to get sys.argv defined. Needed for e.g. TKinter.
+ "sys.argv = ['']\n"
+
+ // On the try to read something from stdin always return an empty
+ // string. That way such reads don't block our script.
+ "import cStringIO\n"
+ "sys.stdin = cStringIO.StringIO()\n"
+
+ // Class to redirect something. We use this class e.g. to redirect
+ // <stdout> and <stderr> to a c++ event.
+ "class Redirect:\n"
+ " def __init__(self, target):\n"
+ " self.target = target\n"
+ " def write(self, s):\n"
+ " self.target.call(s)\n"
+
+ // Wrap builtin __import__ method. All import requests are
+ // first redirected to our PythonModule.import method and
+ // if the call returns None, then we call the original
+ // python import mechanism.
+ "import __builtin__\n"
+ "import __main__\n"
+ "class Importer:\n"
+ " def __init__(self):\n"
+ " self.realImporter = __builtin__.__import__\n"
+ " __builtin__.__import__ = self._import\n"
+ " def _import(self, name, globals=None, locals=None, fromlist=[]):\n"
+ " mod = __main__._import(name, globals, locals, fromlist)\n"
+ " if mod != None: return mod\n"
+ " return self.realImporter(name, globals, locals, fromlist)\n"
+ "Importer()\n"
+ ;
+
+ PyObject* pyrun = PyRun_String(s.latin1(), Py_file_input, moduledict.ptr(), moduledict.ptr());
+ if(! pyrun) {
+ Py::Object errobj = Py::value(Py::Exception()); // get last error
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Failed to prepare the __main__ module: %1").arg(errobj.as_string().c_str())) );
+ }
+ Py_XDECREF(pyrun); // free the reference.
+
+ // Initialize the RestrictedPython module.
+ d->security = new PythonSecurity(this);
+}
+
+PythonInterpreter::~PythonInterpreter()
+{
+ // Free the zope security module.
+ delete d->security; d->security = 0;
+ // Free the main module.
+ delete d->mainmodule; d->mainmodule = 0;
+ // Finalize the python interpreter.
+ finalize();
+ // Delete the private d-pointer.
+ delete d;
+}
+
+void PythonInterpreter::initialize()
+{
+ // Initialize python.
+ Py_Initialize();
+
+ /* Not needed cause we use the >= Python 2.3 GIL-mechanism.
+ PyThreadState* d->globalthreadstate, d->threadstate;
+ // First we have to initialize threading if python supports it.
+ PyEval_InitThreads();
+ // The main thread. We don't use it later.
+ d->globalthreadstate = PyThreadState_Swap(NULL);
+ d->globalthreadstate = PyEval_SaveThread();
+ // We use an own sub-interpreter for each thread.
+ d->threadstate = Py_NewInterpreter();
+ // Note that this application has multiple threads.
+ // It maintains a separate interp (sub-interpreter) for each thread.
+ PyThreadState_Swap(d->threadstate);
+ // Work done, release the lock.
+ PyEval_ReleaseLock();
+ */
+}
+
+void PythonInterpreter::finalize()
+{
+ /* Not needed cause we use the >= Python 2.3 GIL-mechanism.
+ // Lock threads.
+ PyEval_AcquireLock();
+ // Free the used thread.
+ PyEval_ReleaseThread(d->threadstate);
+ // Set back to rememberd main thread.
+ PyThreadState_Swap(d->globalthreadstate);
+ // Work done, unlock.
+ PyEval_ReleaseLock();
+ */
+
+ // Finalize python.
+ Py_Finalize();
+}
+
+Kross::Api::Script* PythonInterpreter::createScript(Kross::Api::ScriptContainer* scriptcontainer)
+{
+ return new PythonScript(this, scriptcontainer);
+}
+
+PythonModule* PythonInterpreter::mainModule()
+{
+ return d->mainmodule;
+}
+
+PythonSecurity* PythonInterpreter::securityModule()
+{
+ return d->security;
+}
+
diff --git a/lib/kross/python/pythoninterpreter.h b/lib/kross/python/pythoninterpreter.h
new file mode 100644
index 00000000..7c4088fa
--- /dev/null
+++ b/lib/kross/python/pythoninterpreter.h
@@ -0,0 +1,90 @@
+/***************************************************************************
+ * pythoninterpreter.h
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#ifndef KROSS_PYTHON_INTERPRETER_H
+#define KROSS_PYTHON_INTERPRETER_H
+
+#include "pythonconfig.h"
+#include "../api/object.h"
+#include "../api/interpreter.h"
+#include "../main/manager.h"
+//#include "../api/script.h"
+#include "../main/scriptcontainer.h"
+
+#include <qstring.h>
+
+namespace Kross { namespace Python {
+
+ // Forward declarations.
+ class PythonSecurity;
+ class PythonModule;
+ class PythonInterpreterPrivate;
+
+ /**
+ * Python interpreter bridge.
+ *
+ * Implements an \a Kross::Api::Interpreter for the python
+ * interpreter.
+ */
+ class PythonInterpreter : public Kross::Api::Interpreter
+ {
+ public:
+
+ /**
+ * Constructor.
+ *
+ * \param info The \a Kross::Api::InterpreterInfo instance
+ * which describes the \a PythonInterpreter for
+ * applications using Kross.
+ */
+ PythonInterpreter(Kross::Api::InterpreterInfo* info);
+
+ /**
+ * Destructor.
+ */
+ virtual ~PythonInterpreter();
+
+ /**
+ * \return a \a PythonScript instance.
+ */
+ virtual Kross::Api::Script* createScript(Kross::Api::ScriptContainer* scriptcontainer);
+
+ /**
+ * \return the \a MainModule instance.
+ */
+ PythonModule* mainModule();
+
+ /**
+ * \return the \a PythonSecurity instance.
+ */
+ PythonSecurity* securityModule();
+
+ private:
+ /// Internal d-pointer class.
+ PythonInterpreterPrivate* d;
+
+ /// Initialize the python interpreter.
+ inline void initialize();
+ /// Finalize the python interpreter.
+ inline void finalize();
+ };
+
+}}
+
+#endif
diff --git a/lib/kross/python/pythonmodule.cpp b/lib/kross/python/pythonmodule.cpp
new file mode 100644
index 00000000..b54eb73f
--- /dev/null
+++ b/lib/kross/python/pythonmodule.cpp
@@ -0,0 +1,100 @@
+/***************************************************************************
+ * pythonmodule.cpp
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#include "pythonmodule.h"
+#include "pythoninterpreter.h"
+
+#include <qregexp.h>
+
+using namespace Kross::Python;
+
+namespace Kross { namespace Python {
+
+ /// @internal
+ class PythonModulePrivate
+ {
+ public:
+
+ /**
+ * The \a PythonInterpreter instance this module is
+ * part of.
+ */
+ PythonInterpreter* m_interpreter;
+
+ /**
+ * List of \a PythonExtension instances accessible
+ * via this \a PythonModule instance.
+ */
+ QMap<QString, PythonExtension*> m_modules;
+
+ };
+
+}}
+
+PythonModule::PythonModule(PythonInterpreter* interpreter)
+ : Py::ExtensionModule<PythonModule>("__main__")
+ , d(new PythonModulePrivate())
+{
+#ifdef KROSS_PYTHON_MODULE_DEBUG
+ krossdebug( QString("Kross::Python::PythonModule::Constructor") );
+#endif
+
+ d->m_interpreter = interpreter;
+
+ add_varargs_method("_import", &PythonModule::import, "FIXME: Documentation");
+
+ initialize("The PythonModule is the __main__ python environment used as global object namespace.");
+}
+
+PythonModule::~PythonModule()
+{
+#ifdef KROSS_PYTHON_MODULE_DEBUG
+ krossdebug( QString("Kross::Python::PythonModule::Destructor name='%1'").arg(name().c_str()) );
+#endif
+
+ delete d;
+}
+
+Py::Dict PythonModule::getDict()
+{
+ return moduleDictionary();
+}
+
+Py::Object PythonModule::import(const Py::Tuple& args)
+{
+ if(args.size() > 0) {
+ QString modname = args[0].as_string().c_str();
+ if(modname.startsWith("kross")) {
+#ifdef KROSS_PYTHON_MODULE_DEBUG
+ krossdebug( QString("Kross::Python::PythonModule::import() module=%1").arg(modname) );
+#endif
+ if( modname.find( QRegExp("[^a-zA-Z0-9\\_\\-]") ) >= 0 ) {
+ krosswarning( QString("Denied import of Kross module '%1' cause of untrusted chars.").arg(modname) );
+ }
+ else {
+ Kross::Api::Module::Ptr module = Kross::Api::Manager::scriptManager()->loadModule(modname);
+ if(module)
+ return PythonExtension::toPyObject( Kross::Api::Object::Ptr(module) );
+ krosswarning( QString("Loading of Kross module '%1' failed.").arg(modname) );
+ }
+
+ }
+ }
+ return Py::None();
+}
diff --git a/lib/kross/python/pythonmodule.h b/lib/kross/python/pythonmodule.h
new file mode 100644
index 00000000..1775ae68
--- /dev/null
+++ b/lib/kross/python/pythonmodule.h
@@ -0,0 +1,76 @@
+/***************************************************************************
+ * pythonmodule.h
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#ifndef KROSS_PYTHON_MODULE_H
+#define KROSS_PYTHON_MODULE_H
+
+#include "pythonconfig.h"
+#include "../api/object.h"
+#include "../api/script.h"
+#include "pythonextension.h"
+
+#include <qstring.h>
+
+namespace Kross { namespace Python {
+
+ // Forward declaration.
+ class PythonInterpreter;
+ class PythonModulePrivate;
+
+ /**
+ * The PythonModule is the __main__ python environment
+ * used as global object namespace.
+ *
+ * The module also spends access to the whole Kross
+ * functionality and manages all the PythonExtension
+ * modules.
+ */
+ class PythonModule : public Py::ExtensionModule<PythonModule>
+ {
+ public:
+
+ /**
+ * Constructor.
+ *
+ * \param interpreter The \a PythonInterpreter instance
+ * used to create this PythonModule.
+ */
+ PythonModule(PythonInterpreter* interpreter);
+
+ /**
+ * Destructor.
+ */
+ virtual ~PythonModule();
+
+ /**
+ * \return the dictonary this PythonModule has.
+ */
+ Py::Dict getDict();
+
+ private:
+ /// Internal d-pointer class.
+ PythonModulePrivate* d;
+
+ /// Import hook used to load external kross libs on demand.
+ Py::Object import(const Py::Tuple&);
+ };
+
+}}
+
+#endif
diff --git a/lib/kross/python/pythonobject.cpp b/lib/kross/python/pythonobject.cpp
new file mode 100644
index 00000000..d59087b3
--- /dev/null
+++ b/lib/kross/python/pythonobject.cpp
@@ -0,0 +1,94 @@
+/***************************************************************************
+ * pythonobject.cpp
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#include "pythonobject.h"
+#include "pythonextension.h"
+
+using namespace Kross::Python;
+
+PythonObject::PythonObject(const Py::Object& object)
+ : Kross::Api::Object()
+ , m_pyobject(object)
+{
+ krossdebug( QString("PythonObject::PythonObject() constructor") );
+
+ Py::List x( object.dir() );
+ for(Py::Sequence::iterator i= x.begin(); i != x.end(); ++i) {
+ std::string s = (*i).str();
+ if(s == "__init__")
+ continue;
+
+ //if(! m_pyobject.hasAttr( (*i).str() )) continue;
+ Py::Object o = m_pyobject.getAttr(s);
+
+ QString t;
+ if(o.isCallable()) t += "isCallable ";
+ if(o.isDict()) t += "isDict ";
+ if(o.isList()) t += "isList ";
+ if(o.isMapping()) t += "isMapping ";
+ if(o.isNumeric()) t += "isNumeric ";
+ if(o.isSequence()) t += "isSequence ";
+ if(o.isTrue()) t += "isTrue ";
+ if(o.isInstance()) t += "isInstance ";
+ krossdebug( QString("PythonObject::PythonObject() method '%1' (%2)").arg( (*i).str().as_string().c_str() ).arg(t) );
+
+ if(o.isCallable())
+ m_calls.append( (*i).str().as_string().c_str() );
+ }
+}
+
+PythonObject::~PythonObject()
+{
+}
+
+const QString PythonObject::getClassName() const
+{
+ return "Kross::Python::PythonObject";
+}
+
+Kross::Api::Object::Ptr PythonObject::call(const QString& name, Kross::Api::List::Ptr arguments)
+{
+ krossdebug( QString("PythonObject::call(%1)").arg(name) );
+
+ if(m_pyobject.isInstance()) {
+ //if(! m_calls.contains(n)) throw ...
+
+ PyObject* r = PyObject_CallMethod(m_pyobject.ptr(), (char*) name.latin1(), 0);
+ if(! r) { //FIXME happens too if e.g. number of arguments doesn't match !!!
+ Py::Object errobj = Py::value(Py::Exception()); // get last error
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Failed to call method '%1': %2").arg(name).arg(errobj.as_string().c_str())) );
+ }
+ Py::Object result(r, true);
+
+ //krossdebug( QString("PythonObject::call(%1) call return value = '%2'").arg(name).arg(result.as_string().c_str()) );
+ return PythonExtension::toObject(result);
+ }
+ /*TODO??? ELSE create class instance for class-definitions???
+ Kross::Api::ClassBase* clazz = new Kross::Api::ClassBase("", this);
+ return new PythonExtension(clazz);
+ */
+
+ return Kross::Api::Object::call(name, arguments);
+}
+
+QStringList PythonObject::getCalls()
+{
+ return m_calls;
+}
+
diff --git a/lib/kross/python/pythonobject.h b/lib/kross/python/pythonobject.h
new file mode 100644
index 00000000..6d33da26
--- /dev/null
+++ b/lib/kross/python/pythonobject.h
@@ -0,0 +1,95 @@
+/***************************************************************************
+ * pythonobject.h
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#ifndef KROSS_PYTHON_OBJECT_H
+#define KROSS_PYTHON_OBJECT_H
+
+#include "pythonconfig.h"
+#include "../api/object.h"
+#include "../api/list.h"
+#include "pythonextension.h"
+
+#include <qstring.h>
+#include <qstringlist.h>
+
+namespace Kross { namespace Python {
+
+ /**
+ * The PythonObject class is used for Instances of Python
+ * Classes by the \a PythonExtension class.
+ */
+ class PythonObject : public Kross::Api::Object
+ {
+ public:
+
+ /**
+ * Constructor.
+ *
+ * \param object The Py::Object this \a PythonObject
+ * provides access to.
+ */
+ explicit PythonObject(const Py::Object& object);
+
+ /**
+ * Destructor.
+ */
+ virtual ~PythonObject();
+
+ /**
+ * Return the class name. This could be something
+ * like "Kross::Python::PythonObject" for this
+ * object. The value is mainly used for display
+ * purposes.
+ *
+ * \return The name of this class.
+ */
+ virtual const QString getClassName() const;
+
+ /**
+ * Pass a call to the object. Objects like \a Class
+ * are able to handle call's by just implementating
+ * this function.
+ *
+ * \throws TypeException if the object or the name
+ * is not callable.
+ * \param name Each call has a name that says what
+ * should be called. In the case of a \a Class
+ * the name is the functionname.
+ * \param arguments The list of arguments passed to
+ * the call.
+ * \return The call-result as Object* instance or
+ * NULL if the call has no result.
+ */
+ virtual Kross::Api::Object::Ptr call(const QString& name, Kross::Api::List::Ptr arguments);
+
+ /**
+ * Return a list of supported callable objects.
+ *
+ * \return List of supported calls.
+ */
+ virtual QStringList getCalls();
+
+ private:
+ const Py::Object m_pyobject;
+ QStringList m_calls;
+ };
+
+}}
+
+#endif
diff --git a/lib/kross/python/pythonscript.cpp b/lib/kross/python/pythonscript.cpp
new file mode 100644
index 00000000..082b5440
--- /dev/null
+++ b/lib/kross/python/pythonscript.cpp
@@ -0,0 +1,460 @@
+/***************************************************************************
+ * pythonscript.cpp
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#include "pythonscript.h"
+#include "pythonmodule.h"
+#include "pythoninterpreter.h"
+#include "pythonsecurity.h"
+#include "../main/scriptcontainer.h"
+
+//#include <kapplication.h>
+
+using namespace Kross::Python;
+
+namespace Kross { namespace Python {
+
+ /// @internal
+ class PythonScriptPrivate
+ {
+ public:
+
+ /**
+ * The \a Py::Module instance this \a PythonScript
+ * has as local context.
+ */
+ Py::Module* m_module;
+
+ /**
+ * The PyCodeObject object representing the
+ * compiled python code. Internaly we first
+ * compile the python code and later execute
+ * it.
+ */
+ Py::Object* m_code;
+
+ /**
+ * A list of functionnames.
+ */
+ QStringList m_functions;
+
+ /**
+ * A list of classnames.
+ */
+ QStringList m_classes;
+ };
+
+}}
+
+PythonScript::PythonScript(Kross::Api::Interpreter* interpreter, Kross::Api::ScriptContainer* scriptcontainer)
+ : Kross::Api::Script(interpreter, scriptcontainer)
+ , d(new PythonScriptPrivate())
+{
+#ifdef KROSS_PYTHON_SCRIPT_CTOR_DEBUG
+ krossdebug("PythonScript::PythonScript() Constructor.");
+#endif
+ d->m_module = 0;
+ d->m_code = 0;
+}
+
+PythonScript::~PythonScript()
+{
+#ifdef KROSS_PYTHON_SCRIPT_DTOR_DEBUG
+ krossdebug("PythonScript::~PythonScript() Destructor.");
+#endif
+ finalize();
+ delete d;
+}
+
+void PythonScript::initialize()
+{
+ finalize();
+ clearException(); // clear previously thrown exceptions.
+
+ try {
+ if(m_scriptcontainer->getCode().isNull())
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Invalid scripting code for script '%1'").arg( m_scriptcontainer->getName() )) );
+
+ if(m_scriptcontainer->getName().isNull())
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Name for the script is invalid!")) );
+
+ PyObject* pymod = PyModule_New( (char*) m_scriptcontainer->getName().latin1() );
+ d->m_module = new Py::Module(pymod, true);
+ if(! d->m_module)
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Failed to initialize local module context for script '%1'").arg( m_scriptcontainer->getName() )) );
+
+#ifdef KROSS_PYTHON_SCRIPT_INIT_DEBUG
+ krossdebug( QString("PythonScript::initialize() module='%1' refcount='%2'").arg(d->m_module->as_string().c_str()).arg(d->m_module->reference_count()) );
+#endif
+
+ // Set the "self" variable to point to the ScriptContainer
+ // we are using for the script. That way we are able to
+ // simply access the ScriptContainer itself from within
+ // python scripting code.
+ Py::Dict moduledict = d->m_module->getDict();
+ moduledict["self"] = PythonExtension::toPyObject( m_scriptcontainer );
+ //moduledict["parent"] = PythonExtension::toPyObject( m_manager );
+
+/*
+ // Prepare the local context.
+ QString s =
+ //"import sys\n"
+ "if self.has(\"stdout\"):\n"
+ " self.stdout = Redirect( self.get(\"stdout\") )\n"
+ "if self.has(\"stderr\"):\n"
+ " self.stderr = Redirect( self.get(\"stderr\") )\n"
+ ;
+ Py::Dict mainmoduledict = ((PythonInterpreter*)m_interpreter)->mainModule()->getDict();
+ PyObject* pyrun = PyRun_StringFlags((char*)s.latin1(), Py_file_input, mainmoduledict.ptr(), moduledict.ptr());
+ if(! pyrun)
+ throw Py::Exception(); // throw exception
+ Py_XDECREF(pyrun); // free the reference.
+*/
+
+ // Compile the python script code. It will be later on request
+ // executed. That way we cache the compiled code.
+ PyObject* code = 0;
+ bool restricted = m_scriptcontainer->getOption("restricted", QVariant(false,0), true).toBool();
+
+ krossdebug( QString("PythonScript::initialize() name=%1 restricted=%2").arg(m_scriptcontainer->getName()).arg(restricted) );
+ if(restricted) {
+
+ // Use the RestrictedPython module wrapped by the PythonSecurity class.
+ code = dynamic_cast<PythonInterpreter*>(m_interpreter)->securityModule()->compile_restricted(
+ m_scriptcontainer->getCode(),
+ m_scriptcontainer->getName(),
+ "exec"
+ );
+
+ }
+ else {
+ //PyCompilerFlags* cf = new PyCompilerFlags;
+ //cf->cf_flags |= PyCF_SOURCE_IS_UTF8;
+
+ // Just compile the code without any restrictions.
+ code = Py_CompileString(
+ (char*) m_scriptcontainer->getCode().latin1(),
+ (char*) m_scriptcontainer->getName().latin1(),
+ Py_file_input
+ );
+ }
+
+ if(! code)
+ throw Py::Exception();
+ d->m_code = new Py::Object(code, true);
+ }
+ catch(Py::Exception& e) {
+ QString err = Py::value(e).as_string().c_str();
+ Kross::Api::Exception::Ptr exception = toException( QString("Failed to compile python code: %1").arg(err) );
+ e.clear(); // exception is handled. clear it now.
+ throw exception;
+ }
+}
+
+void PythonScript::finalize()
+{
+#ifdef KROSS_PYTHON_SCRIPT_FINALIZE_DEBUG
+ if(d->m_module)
+ krossdebug( QString("PythonScript::finalize() module='%1' refcount='%2'").arg(d->m_module->as_string().c_str()).arg(d->m_module->reference_count()) );
+#endif
+
+ delete d->m_module; d->m_module = 0;
+ delete d->m_code; d->m_code = 0;
+ d->m_functions.clear();
+ d->m_classes.clear();
+}
+
+Kross::Api::Exception::Ptr PythonScript::toException(const QString& error)
+{
+ long lineno = -1;
+ QStringList errorlist;
+
+ PyObject *type, *value, *traceback;
+ PyErr_Fetch(&type, &value, &traceback);
+ Py_FlushLine();
+ PyErr_NormalizeException(&type, &value, &traceback);
+
+ if(traceback) {
+ Py::List tblist;
+ try {
+ Py::Module tbmodule( PyImport_Import(Py::String("traceback").ptr()), true );
+ Py::Dict tbdict = tbmodule.getDict();
+ Py::Callable tbfunc(tbdict.getItem("format_tb"));
+ Py::Tuple args(1);
+ args.setItem(0, Py::Object(traceback));
+ tblist = tbfunc.apply(args);
+ uint length = tblist.length();
+ for(Py::List::size_type i = 0; i < length; ++i)
+ errorlist.append( Py::Object(tblist[i]).as_string().c_str() );
+ }
+ catch(Py::Exception& e) {
+ QString err = Py::value(e).as_string().c_str();
+ e.clear(); // exception is handled. clear it now.
+ krosswarning( QString("Kross::Python::PythonScript::toException() Failed to fetch a traceback: %1").arg(err) );
+ }
+
+ PyObject *next;
+ while (traceback && traceback != Py_None) {
+ PyFrameObject *frame = (PyFrameObject*)PyObject_GetAttrString(traceback, "tb_frame");
+ Py_DECREF(frame);
+ {
+ PyObject *getobj = PyObject_GetAttrString(traceback, "tb_lineno");
+ lineno = PyInt_AsLong(getobj);
+ Py_DECREF(getobj);
+ }
+ if(Py_OptimizeFlag) {
+ PyObject *getobj = PyObject_GetAttrString(traceback, "tb_lasti");
+ int lasti = PyInt_AsLong(getobj);
+ Py_DECREF(getobj);
+ lineno = PyCode_Addr2Line(frame->f_code, lasti);
+ }
+
+ //const char* filename = PyString_AsString(frame->f_code->co_filename);
+ //const char* name = PyString_AsString(frame->f_code->co_name);
+ //errorlist.append( QString("%1#%2: \"%3\"").arg(filename).arg(lineno).arg(name) );
+
+ next = PyObject_GetAttrString(traceback, "tb_next");
+ Py_DECREF(traceback);
+ traceback = next;
+ }
+ }
+
+ if(lineno < 0) {
+ if(value) {
+ PyObject *getobj = PyObject_GetAttrString(value, "lineno");
+ if(getobj) {
+ lineno = PyInt_AsLong(getobj);
+ Py_DECREF(getobj);
+ }
+ }
+ if(lineno < 0)
+ lineno = 0;
+ }
+
+ //PyErr_Restore(type, value, traceback);
+
+ Kross::Api::Exception::Ptr exception = new Kross::Api::Exception(error, lineno - 1);
+ if(errorlist.count() > 0)
+ exception->setTrace( errorlist.join("\n") );
+ return exception;
+}
+
+const QStringList& PythonScript::getFunctionNames()
+{
+ if(! d->m_module)
+ initialize(); //TODO catch exception
+ return d->m_functions;
+ /*
+ QStringList list;
+ Py::List l = d->m_module->getDict().keys();
+ int length = l.length();
+ for(Py::List::size_type i = 0; i < length; ++i)
+ list.append( l[i].str().as_string().c_str() );
+ return list;
+ */
+}
+
+Kross::Api::Object::Ptr PythonScript::execute()
+{
+#ifdef KROSS_PYTHON_SCRIPT_EXEC_DEBUG
+ krossdebug( QString("PythonScript::execute()") );
+#endif
+
+ try {
+ if(! d->m_module)
+ initialize();
+
+ // the main module dictonary.
+ Py::Dict mainmoduledict = ((PythonInterpreter*)m_interpreter)->mainModule()->getDict();
+ // the local context dictonary.
+ Py::Dict moduledict( d->m_module->getDict().ptr() );
+
+ // Initialize context before execution.
+ QString s =
+ "import sys\n"
+ //"if self.has(\"stdout\"):\n"
+ //" sys.stdout = Redirect( self.get(\"stdout\") )\n"
+ //"if self.has(\"stderr\"):\n"
+ //" sys.stderr = Redirect( self.get(\"stderr\") )\n"
+ ;
+
+ PyObject* pyrun = PyRun_String(s.latin1(), Py_file_input, mainmoduledict.ptr(), moduledict.ptr());
+ if(! pyrun)
+ throw Py::Exception(); // throw exception
+ Py_XDECREF(pyrun); // free the reference.
+
+ // Acquire interpreter lock*/
+ PyGILState_STATE gilstate = PyGILState_Ensure();
+
+ // Evaluate the already compiled code.
+ PyObject* pyresult = PyEval_EvalCode(
+ (PyCodeObject*)d->m_code->ptr(),
+ mainmoduledict.ptr(),
+ moduledict.ptr()
+ );
+
+ // Free interpreter lock
+ PyGILState_Release(gilstate);
+
+ if(! pyresult || PyErr_Occurred()) {
+ krosswarning("Kross::Python::PythonScript::execute(): Failed to PyEval_EvalCode");
+ throw Py::Exception();
+ }
+ Py::Object result(pyresult, true);
+
+#ifdef KROSS_PYTHON_SCRIPT_EXEC_DEBUG
+ krossdebug( QString("PythonScript::execute() result=%1").arg(result.as_string().c_str()) );
+#endif
+
+ for(Py::Dict::iterator it = moduledict.begin(); it != moduledict.end(); ++it) {
+ Py::Dict::value_type vt(*it);
+ if(PyClass_Check( vt.second.ptr() )) {
+#ifdef KROSS_PYTHON_SCRIPT_EXEC_DEBUG
+ krossdebug( QString("PythonScript::execute() class '%1' added.").arg(vt.first.as_string().c_str()) );
+#endif
+ d->m_classes.append( vt.first.as_string().c_str() );
+ }
+ else if(vt.second.isCallable()) {
+#ifdef KROSS_PYTHON_SCRIPT_EXEC_DEBUG
+ krossdebug( QString("PythonScript::execute() function '%1' added.").arg(vt.first.as_string().c_str()) );
+#endif
+ d->m_functions.append( vt.first.as_string().c_str() );
+ }
+ }
+
+ Kross::Api::Object::Ptr r = PythonExtension::toObject(result);
+ return r;
+ }
+ catch(Py::Exception& e) {
+ try {
+ Py::Object errobj = Py::value(e);
+ if(errobj.ptr() == Py_None) // at least string-exceptions have there errormessage in the type-object
+ errobj = Py::type(e);
+ QString err = errobj.as_string().c_str();
+
+ Kross::Api::Exception::Ptr exception = toException( QString("Failed to execute python code: %1").arg(err) );
+ e.clear(); // exception is handled. clear it now.
+ setException( exception );
+ }
+ catch(Py::Exception& e) {
+ QString err = Py::value(e).as_string().c_str();
+ Kross::Api::Exception::Ptr exception = toException( QString("Failed to execute python code: %1").arg(err) );
+ e.clear(); // exception is handled. clear it now.
+ setException( exception );
+ }
+ }
+ catch(Kross::Api::Exception::Ptr e) {
+ setException(e);
+ }
+
+ return 0; // return nothing if exception got thrown.
+}
+
+Kross::Api::Object::Ptr PythonScript::callFunction(const QString& name, Kross::Api::List::Ptr args)
+{
+#ifdef KROSS_PYTHON_SCRIPT_CALLFUNC_DEBUG
+ krossdebug( QString("PythonScript::callFunction(%1, %2)")
+ .arg(name)
+ .arg(args ? QString::number(args->count()) : QString("NULL")) );
+#endif
+
+ if(hadException()) return 0; // abort if we had an unresolved exception.
+
+ if(! d->m_module) {
+ setException( new Kross::Api::Exception(QString("Script not initialized.")) );
+ return 0;
+ }
+
+ try {
+ Py::Dict moduledict = d->m_module->getDict();
+
+ // Try to determinate the function we like to execute.
+ PyObject* func = PyDict_GetItemString(moduledict.ptr(), name.latin1());
+
+ if( (! d->m_functions.contains(name)) || (! func) )
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("No such function '%1'.").arg(name)) );
+
+ Py::Callable funcobject(func, true); // the funcobject takes care of freeing our func pyobject.
+
+ // Check if the object is really a function and therefore callable.
+ if(! funcobject.isCallable())
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Function is not callable.")) );
+
+ // Call the function.
+ Py::Object result = funcobject.apply(PythonExtension::toPyTuple(args));
+ return PythonExtension::toObject(result);
+ }
+ catch(Py::Exception& e) {
+ QString err = Py::value(e).as_string().c_str();
+ e.clear(); // exception is handled. clear it now.
+ setException( new Kross::Api::Exception(QString("Python Exception: %1").arg(err)) );
+ }
+ catch(Kross::Api::Exception::Ptr e) {
+ setException(e);
+ }
+
+ return 0; // return nothing if exception got thrown.
+}
+
+const QStringList& PythonScript::getClassNames()
+{
+ if(! d->m_module)
+ initialize(); //TODO catch exception
+ return d->m_classes;
+}
+
+Kross::Api::Object::Ptr PythonScript::classInstance(const QString& name)
+{
+ if(hadException()) return 0; // abort if we had an unresolved exception.
+
+ if(! d->m_module) {
+ setException( new Kross::Api::Exception(QString("Script not initialized.")) );
+ return 0;
+ }
+
+ try {
+ Py::Dict moduledict = d->m_module->getDict();
+
+ // Try to determinate the class.
+ PyObject* pyclass = PyDict_GetItemString(moduledict.ptr(), name.latin1());
+ if( (! d->m_classes.contains(name)) || (! pyclass) )
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("No such class '%1'.").arg(name)) );
+
+ PyObject *pyobj = PyInstance_New(pyclass, 0, 0);//aclarg, 0);
+ if(! pyobj)
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Failed to create instance of class '%1'.").arg(name)) );
+
+ Py::Object classobject(pyobj, true);
+
+#ifdef KROSS_PYTHON_SCRIPT_CLASSINSTANCE_DEBUG
+ krossdebug( QString("PythonScript::classInstance() inst='%1'").arg(classobject.as_string().c_str()) );
+#endif
+ return PythonExtension::toObject(classobject);
+ }
+ catch(Py::Exception& e) {
+ QString err = Py::value(e).as_string().c_str();
+ e.clear(); // exception is handled. clear it now.
+ setException( Kross::Api::Exception::Ptr( new Kross::Api::Exception(err) ) );
+ }
+ catch(Kross::Api::Exception::Ptr e) {
+ setException(e);
+ }
+
+ return 0; // return nothing if exception got thrown.
+}
+
diff --git a/lib/kross/python/pythonscript.h b/lib/kross/python/pythonscript.h
new file mode 100644
index 00000000..6cbef625
--- /dev/null
+++ b/lib/kross/python/pythonscript.h
@@ -0,0 +1,98 @@
+/***************************************************************************
+ * pythonscript.h
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#ifndef KROSS_PYTHON_PYTHONSCRIPT_H
+#define KROSS_PYTHON_PYTHONSCRIPT_H
+
+#include "pythonconfig.h"
+#include "../api/script.h"
+
+namespace Kross { namespace Python {
+
+ // Forward declarations.
+ class PythonScriptPrivate;
+ class PythonModuleManager;
+
+ /**
+ * Handle python scripts. This class implements
+ * \a Kross::Api::Script for python.
+ */
+ class PythonScript : public Kross::Api::Script
+ {
+ public:
+
+ /**
+ * Constructor.
+ *
+ * \param interpreter The \a Kross::Python::PythonInterpreter used
+ * to create this PythonScript instance.
+ * \param scriptcontainer The with this PythonScript associated
+ * \a Kross::Api::ScriptContainer instance that spends us
+ * e.g. the python scripting code.
+ */
+ explicit PythonScript(Kross::Api::Interpreter* interpreter, Kross::Api::ScriptContainer* scriptcontainer);
+
+ /**
+ * Destructor.
+ */
+ virtual ~PythonScript();
+
+ /**
+ * Return a list of callable functionnames this
+ * script spends.
+ */
+ virtual const QStringList& getFunctionNames();
+
+ /**
+ * Execute the script.
+ */
+ virtual Kross::Api::Object::Ptr execute();
+
+ /**
+ * Call a function.
+ */
+ virtual Kross::Api::Object::Ptr callFunction(const QString& name, Kross::Api::List::Ptr args);
+
+ /**
+ * Return a list of class types this script supports.
+ */
+ virtual const QStringList& getClassNames();
+
+ /**
+ * Create and return a new class instance.
+ */
+ virtual Kross::Api::Object::Ptr classInstance(const QString& name);
+
+ private:
+ /// Private d-pointer class.
+ PythonScriptPrivate* d;
+
+ /// Initialize the script.
+ void initialize();
+ /// Finalize and cleanup the script.
+ void finalize();
+
+ /// \return a \a Kross::Api::Exception instance.
+ Kross::Api::Exception::Ptr toException(const QString& error);
+ };
+
+}}
+
+#endif
+
diff --git a/lib/kross/python/pythonsecurity.cpp b/lib/kross/python/pythonsecurity.cpp
new file mode 100644
index 00000000..86be0092
--- /dev/null
+++ b/lib/kross/python/pythonsecurity.cpp
@@ -0,0 +1,181 @@
+/***************************************************************************
+ * pythonsecurity.cpp
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#include "pythonsecurity.h"
+#include "pythoninterpreter.h"
+#include "pythonmodule.h"
+
+using namespace Kross::Python;
+
+PythonSecurity::PythonSecurity(PythonInterpreter* interpreter)
+ : Py::ExtensionModule<PythonSecurity>("PythonSecurity")
+ , m_interpreter(interpreter)
+ , m_pymodule(0)
+{
+ add_varargs_method("_getattr_", &PythonSecurity::_getattr_, "Secure wapper around the getattr method.");
+ initialize("The PythonSecurity module used to wrap the RestrictedPython functionality.");
+
+ /* TESTCASE
+ initRestrictedPython();
+ compile_restricted(
+ "a = 2 + 5\n"
+ "import os\n"
+ "import sys\n"
+ "b = sys.path\n"
+ "print \"######### >>>testcase<<< #########\" \n"
+ ,
+ "mytestcase", // filename
+ "exec" // 'exec' or 'eval' or 'single'
+ );
+ */
+
+}
+
+PythonSecurity::~PythonSecurity()
+{
+ delete m_pymodule;
+}
+
+void PythonSecurity::initRestrictedPython()
+{
+ try {
+ Py::Dict mainmoduledict = ((PythonInterpreter*)m_interpreter)->mainModule()->getDict();
+ PyObject* pymodule = PyImport_ImportModuleEx(
+ "RestrictedPython", // name of the module being imported (may be a dotted name)
+ mainmoduledict.ptr(), // reference to the current global namespace
+ mainmoduledict.ptr(), // reference to the local namespace
+ 0 // PyObject *fromlist
+ );
+ if(! pymodule)
+ throw Py::Exception();
+ m_pymodule = new Py::Module(pymodule, true);
+
+ PyObject* pyrun = PyRun_String(
+ //"import os\n"
+ //"import sys\n"
+ "import __main__\n"
+ "import PythonSecurity\n"
+ "from RestrictedPython import compile_restricted, PrintCollector\n"
+ "from RestrictedPython.Eval import RestrictionCapableEval\n"
+ "from RestrictedPython.RCompile import RModule\n"
+
+ "setattr(__main__, '_getattr_', PythonSecurity._getattr_)\n"
+ "setattr(__main__, '_print_', PrintCollector)\n"
+ ,
+ Py_file_input,
+ m_pymodule->getDict().ptr(),
+ m_pymodule->getDict().ptr()
+ );
+ if(! pyrun)
+ throw Py::Exception();
+
+ krossdebug("PythonSecurity::PythonSecurity SUCCESSFULLY LOADED");
+ }
+ catch(Py::Exception& e) {
+ QString err = Py::value(e).as_string().c_str();
+ e.clear();
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Failed to initialize PythonSecurity module: %1").arg(err) ) );
+ }
+}
+
+Py::Object PythonSecurity::_getattr_(const Py::Tuple& args)
+{
+ krossdebug("PythonSecurity::_getattr_");
+ for(uint i = 0; i < args.size(); i++) {
+ Py::Object o = args[i];
+ krossdebug( o.as_string().c_str() );
+ }
+ return Py::None();
+}
+
+PyObject* PythonSecurity::compile_restricted(const QString& source, const QString& filename, const QString& mode)
+{
+ krossdebug("PythonSecurity::compile_restricted");
+ if(! m_pymodule)
+ initRestrictedPython(); // throws exception if failed
+
+ try {
+ Py::Dict mainmoduledict = ((PythonInterpreter*)m_interpreter)->mainModule()->getDict();
+
+ PyObject* func = PyDict_GetItemString(m_pymodule->getDict().ptr(), "compile_restricted");
+ if(! func)
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("No such function '%1'.").arg("compile_restricted")) );
+
+ Py::Callable funcobject(func, true); // the funcobject takes care of freeing our func pyobject.
+
+ if(! funcobject.isCallable())
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Function '%1' is not callable.").arg("compile_restricted")) );
+
+ Py::Tuple args(3);
+ args[0] = Py::String(source.utf8());
+ args[1] = Py::String(filename.utf8());
+ args[2] = Py::String(mode.utf8());
+
+ Py::Object result = funcobject.apply(args);
+
+ PyObject* pycode = PyEval_EvalCode(
+ (PyCodeObject*)result.ptr(),
+ mainmoduledict.ptr(),
+ mainmoduledict.ptr()
+ );
+ if(! pycode)
+ throw Py::Exception();
+
+ /*
+ Py::List ml = mainmoduledict;
+ for(Py::List::size_type mi = 0; mi < ml.length(); ++mi) {
+ krossdebug( QString("dir() = %1").arg( ml[mi].str().as_string().c_str() ) );
+ //krossdebug( QString("dir().dir() = %1").arg( Py::Object(ml[mi]).dir().as_string().c_str() ) );
+ }
+ */
+
+ Py::Object code(pycode);
+ krossdebug( QString("%1 callable=%2").arg(code.as_string().c_str()).arg(PyCallable_Check(code.ptr())) );
+ Py::List l = code.dir();
+ for(Py::List::size_type i = 0; i < l.length(); ++i) {
+ krossdebug( QString("dir() = %1").arg( l[i].str().as_string().c_str() ) );
+ //krossdebug( QString("dir().dir() = %1").arg( Py::Object(l[i]).dir().as_string().c_str() ) );
+ }
+
+ return pycode;
+ }
+ catch(Py::Exception& e) {
+ QString err = Py::value(e).as_string().c_str();
+ e.clear();
+ throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Function '%1' failed with python exception: %2").arg("compile_restricted").arg(err) ) );
+ }
+}
+
+#if 0
+void PythonSecurity::compile_restricted_function(const Py::Tuple& /*args*/, const QString& /*body*/, const QString& /*name*/, const QString& /*filename*/, const Py::Object& /*globalize*/)
+{
+ //TODO
+}
+
+void PythonSecurity::compile_restricted_exec(const QString& /*source*/, const QString& /*filename*/)
+{
+ //TODO
+}
+
+void PythonSecurity::compile_restricted_eval(const QString& /*source*/, const QString& /*filename*/)
+{
+ //TODO
+}
+#endif
+
diff --git a/lib/kross/python/pythonsecurity.h b/lib/kross/python/pythonsecurity.h
new file mode 100644
index 00000000..7ffbcfff
--- /dev/null
+++ b/lib/kross/python/pythonsecurity.h
@@ -0,0 +1,109 @@
+/***************************************************************************
+ * pythonsecurity.h
+ * This file is part of the KDE project
+ * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ * You should have received a copy of the GNU Library General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ ***************************************************************************/
+
+#ifndef KROSS_PYTHON_SECURITY_H
+#define KROSS_PYTHON_SECURITY_H
+
+#include "pythonconfig.h"
+
+#include <qstring.h>
+
+namespace Kross { namespace Python {
+
+ // Forward declaration.
+ class PythonInterpreter;
+
+ /**
+ * This class handles the used Zope3 RestrictedPython
+ * package to spend a restricted sandbox for scripting
+ * code.
+ *
+ * The RestrictedPython code is avaible as Python files.
+ * So, this class takes care of loading them and spending
+ * the functions we need to access the functionality
+ * from within Kross. That way it's easy to update the
+ * module with a newer version if some security issues
+ * show up.
+ *
+ * What the RestrictedPython code does is to compile
+ * the plain python code (py) into compiled python code (pyc)
+ * and manipulate those compiled code by replacing unsafe
+ * code with own wrapped code.
+ * As example a simple "x = y.z" would be transfered to
+ * "x = _getattr_(y, 'z')". The _getattr_ is defined in
+ * the RestrictedPython module and will take care of
+ * applied restrictions.
+ *
+ * \see http://www.zope.org
+ * \see http://svn.zope.org/Zope3/trunk/src/RestrictedPython/
+ */
+ class PythonSecurity : public Py::ExtensionModule<PythonSecurity>
+ {
+ public:
+
+ /**
+ * Constructor.
+ *
+ * \param interpreter The \a PythonInterpreter instance
+ * used to create this Module.
+ */
+ explicit PythonSecurity(PythonInterpreter* interpreter);
+
+ /**
+ * Destructor.
+ */
+ virtual ~PythonSecurity();
+
+ /**
+ * Compile python scripting code and return a restricted
+ * code object.
+ *
+ * \param source The python scripting code.
+ * \param filename The filename used on errormessages.
+ * \param mode Compilemode, could be 'exec' or 'eval' or 'single'.
+ * \return The compiled python code object on success else
+ * NULL. The caller owns the resulting object and needs
+ * to take care to decrease the ref-counter it not needed
+ * any longer.
+ */
+ PyObject* compile_restricted(const QString& source, const QString& filename, const QString& mode);
+
+#if 0
+ //TODO
+ void compile_restricted_function(const Py::Tuple& args, const QString& body, const QString& name, const QString& filename, const Py::Object& globalize = Py::None());
+ void compile_restricted_exec(const QString& source, const QString& filename = "<string>");
+ void compile_restricted_eval(const QString& source, const QString& filename = "<string>");
+#endif
+
+ private:
+ /// We keep a pointer to the used \a PythonInterpreter.
+ PythonInterpreter* m_interpreter;
+ /// The imported external RestrictedPython module.
+ Py::Module* m_pymodule;
+
+ /// Initialize the restricted python module.
+ inline void initRestrictedPython();
+
+ /// Secure wrapper around the getattr method.
+ Py::Object _getattr_(const Py::Tuple&);
+ };
+
+}}
+
+#endif
diff --git a/lib/kross/python/scripts/Makefile.am b/lib/kross/python/scripts/Makefile.am
new file mode 100644
index 00000000..c3b720ce
--- /dev/null
+++ b/lib/kross/python/scripts/Makefile.am
@@ -0,0 +1,4 @@
+modulesdir = $(kde_datadir)/kross/python
+modules_SCRIPTS = gui.py
+
+SUBDIRS = RestrictedPython
diff --git a/lib/kross/python/scripts/RestrictedPython/Eval.py b/lib/kross/python/scripts/RestrictedPython/Eval.py
new file mode 100644
index 00000000..841067a1
--- /dev/null
+++ b/lib/kross/python/scripts/RestrictedPython/Eval.py
@@ -0,0 +1,118 @@
+##############################################################################
+#
+# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Restricted Python Expressions
+
+$Id: Eval.py 24763 2004-05-17 05:59:28Z philikon $
+"""
+
+__version__='$Revision: 1.6 $'[11:-2]
+
+from RestrictedPython import compile_restricted_eval
+
+from string import translate, strip
+import string
+
+nltosp = string.maketrans('\r\n',' ')
+
+default_guarded_getattr = getattr # No restrictions.
+
+def default_guarded_getitem(ob, index):
+ # No restrictions.
+ return ob[index]
+
+PROFILE = 0
+
+class RestrictionCapableEval:
+ """A base class for restricted code."""
+
+ globals = {'__builtins__': None}
+ rcode = None # restricted
+ ucode = None # unrestricted
+ used = None
+
+ def __init__(self, expr):
+ """Create a restricted expression
+
+ where:
+
+ expr -- a string containing the expression to be evaluated.
+ """
+ expr = strip(expr)
+ self.__name__ = expr
+ expr = translate(expr, nltosp)
+ self.expr = expr
+ self.prepUnrestrictedCode() # Catch syntax errors.
+
+ def prepRestrictedCode(self):
+ if self.rcode is None:
+ if PROFILE:
+ from time import clock
+ start = clock()
+ co, err, warn, used = compile_restricted_eval(
+ self.expr, '<string>')
+ if PROFILE:
+ end = clock()
+ print 'prepRestrictedCode: %d ms for %s' % (
+ (end - start) * 1000, `self.expr`)
+ if err:
+ raise SyntaxError, err[0]
+ self.used = tuple(used.keys())
+ self.rcode = co
+
+ def prepUnrestrictedCode(self):
+ if self.ucode is None:
+ # Use the standard compiler.
+ co = compile(self.expr, '<string>', 'eval')
+ if self.used is None:
+ # Examine the code object, discovering which names
+ # the expression needs.
+ names=list(co.co_names)
+ used={}
+ i=0
+ code=co.co_code
+ l=len(code)
+ LOAD_NAME=101
+ HAVE_ARGUMENT=90
+ while(i < l):
+ c=ord(code[i])
+ if c==LOAD_NAME:
+ name=names[ord(code[i+1])+256*ord(code[i+2])]
+ used[name]=1
+ i=i+3
+ elif c >= HAVE_ARGUMENT: i=i+3
+ else: i=i+1
+ self.used=tuple(used.keys())
+ self.ucode=co
+
+ def eval(self, mapping):
+ # This default implementation is probably not very useful. :-(
+ # This is meant to be overridden.
+ self.prepRestrictedCode()
+ code = self.rcode
+ d = {'_getattr_': default_guarded_getattr,
+ '_getitem_': default_guarded_getitem}
+ d.update(self.globals)
+ has_key = d.has_key
+ for name in self.used:
+ try:
+ if not has_key(name):
+ d[name] = mapping[name]
+ except KeyError:
+ # Swallow KeyErrors since the expression
+ # might not actually need the name. If it
+ # does need the name, a NameError will occur.
+ pass
+ return eval(code, d)
+
+ def __call__(self, **kw):
+ return self.eval(kw)
diff --git a/lib/kross/python/scripts/RestrictedPython/Guards.py b/lib/kross/python/scripts/RestrictedPython/Guards.py
new file mode 100644
index 00000000..4fbdcad1
--- /dev/null
+++ b/lib/kross/python/scripts/RestrictedPython/Guards.py
@@ -0,0 +1,136 @@
+##############################################################################
+#
+# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+__version__ = '$Revision: 1.14 $'[11:-2]
+
+import exceptions
+
+# This tiny set of safe builtins is extended by users of the module.
+# AccessControl.ZopeGuards contains a large set of wrappers for builtins.
+# DocumentTemplate.DT_UTil contains a few.
+
+safe_builtins = {}
+
+for name in ['False', 'None', 'True', 'abs', 'basestring', 'bool', 'callable',
+ 'chr', 'cmp', 'complex', 'divmod', 'float', 'hash',
+ 'hex', 'id', 'int', 'isinstance', 'issubclass', 'len',
+ 'long', 'oct', 'ord', 'pow', 'range', 'repr', 'round',
+ 'str', 'tuple', 'unichr', 'unicode', 'xrange', 'zip']:
+
+ safe_builtins[name] = __builtins__[name]
+
+# Wrappers provided by this module:
+# delattr
+# setattr
+
+# Wrappers provided by ZopeGuards:
+# __import__
+# apply
+# dict
+# enumerate
+# filter
+# getattr
+# hasattr
+# iter
+# list
+# map
+# max
+# min
+# sum
+
+# Builtins that are intentionally disabled
+# compile - don't let them produce new code
+# dir - a general purpose introspector, probably hard to wrap
+# execfile - no direct I/O
+# file - no direct I/O
+# globals - uncontrolled namespace access
+# input - no direct I/O
+# locals - uncontrolled namespace access
+# open - no direct I/O
+# raw_input - no direct I/O
+# vars - uncontrolled namespace access
+
+# There are several strings that describe Python. I think there's no
+# point to including these, although they are obviously safe:
+# copyright, credits, exit, help, license, quit
+
+# Not provided anywhere. Do something about these? Several are
+# related to new-style classes, which we are too scared of to support
+# <0.3 wink>. coerce, buffer, and reload are esoteric enough that no
+# one should care.
+
+# buffer
+# classmethod
+# coerce
+# eval
+# intern
+# object
+# property
+# reload
+# slice
+# staticmethod
+# super
+# type
+
+for name in dir(exceptions):
+ if name[0] != "_":
+ safe_builtins[name] = getattr(exceptions, name)
+
+def _write_wrapper():
+ # Construct the write wrapper class
+ def _handler(secattr, error_msg):
+ # Make a class method.
+ def handler(self, *args):
+ try:
+ f = getattr(self.ob, secattr)
+ except AttributeError:
+ raise TypeError, error_msg
+ f(*args)
+ return handler
+ class Wrapper:
+ def __len__(self):
+ # Required for slices with negative bounds.
+ return len(self.ob)
+ def __init__(self, ob):
+ self.__dict__['ob'] = ob
+ __setitem__ = _handler('__guarded_setitem__',
+ 'object does not support item or slice assignment')
+ __delitem__ = _handler('__guarded_delitem__',
+ 'object does not support item or slice assignment')
+ __setattr__ = _handler('__guarded_setattr__',
+ 'attribute-less object (assign or del)')
+ __delattr__ = _handler('__guarded_delattr__',
+ 'attribute-less object (assign or del)')
+ return Wrapper
+
+def _full_write_guard():
+ # Nested scope abuse!
+ # safetype and Wrapper variables are used by guard()
+ safetype = {dict: True, list: True}.has_key
+ Wrapper = _write_wrapper()
+ def guard(ob):
+ # Don't bother wrapping simple types, or objects that claim to
+ # handle their own write security.
+ if safetype(type(ob)) or hasattr(ob, '_guarded_writes'):
+ return ob
+ # Hand the object to the Wrapper instance, then return the instance.
+ return Wrapper(ob)
+ return guard
+full_write_guard = _full_write_guard()
+
+def guarded_setattr(object, name, value):
+ setattr(full_write_guard(object), name, value)
+safe_builtins['setattr'] = guarded_setattr
+
+def guarded_delattr(object, name):
+ delattr(full_write_guard(object), name)
+safe_builtins['delattr'] = guarded_delattr
diff --git a/lib/kross/python/scripts/RestrictedPython/Limits.py b/lib/kross/python/scripts/RestrictedPython/Limits.py
new file mode 100644
index 00000000..3b782e65
--- /dev/null
+++ b/lib/kross/python/scripts/RestrictedPython/Limits.py
@@ -0,0 +1,46 @@
+##############################################################################
+#
+# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+
+__version__='$Revision: 1.5 $'[11:-2]
+
+limited_builtins = {}
+
+def limited_range(iFirst, *args):
+ # limited range function from Martijn Pieters
+ RANGELIMIT = 1000
+ if not len(args):
+ iStart, iEnd, iStep = 0, iFirst, 1
+ elif len(args) == 1:
+ iStart, iEnd, iStep = iFirst, args[0], 1
+ elif len(args) == 2:
+ iStart, iEnd, iStep = iFirst, args[0], args[1]
+ else:
+ raise AttributeError, 'range() requires 1-3 int arguments'
+ if iStep == 0: raise ValueError, 'zero step for range()'
+ iLen = int((iEnd - iStart) / iStep)
+ if iLen < 0: iLen = 0
+ if iLen >= RANGELIMIT: raise ValueError, 'range() too large'
+ return range(iStart, iEnd, iStep)
+limited_builtins['range'] = limited_range
+
+def limited_list(seq):
+ if isinstance(seq, str):
+ raise TypeError, 'cannot convert string to list'
+ return list(seq)
+limited_builtins['list'] = limited_list
+
+def limited_tuple(seq):
+ if isinstance(seq, str):
+ raise TypeError, 'cannot convert string to tuple'
+ return tuple(seq)
+limited_builtins['tuple'] = limited_tuple
diff --git a/lib/kross/python/scripts/RestrictedPython/Makefile.am b/lib/kross/python/scripts/RestrictedPython/Makefile.am
new file mode 100644
index 00000000..3d5b3c73
--- /dev/null
+++ b/lib/kross/python/scripts/RestrictedPython/Makefile.am
@@ -0,0 +1,4 @@
+restrictedpythondir = $(kde_datadir)/kross/python/RestrictedPython
+restrictedpython_SCRIPTS = __init__.py Eval.py Guards.py Limits.py \
+ MutatingWalker.py PrintCollector.py RCompile.py RestrictionMutator.py \
+ SelectCompiler.py Utilities.py
diff --git a/lib/kross/python/scripts/RestrictedPython/MutatingWalker.py b/lib/kross/python/scripts/RestrictedPython/MutatingWalker.py
new file mode 100644
index 00000000..b0b8c9ce
--- /dev/null
+++ b/lib/kross/python/scripts/RestrictedPython/MutatingWalker.py
@@ -0,0 +1,74 @@
+##############################################################################
+#
+# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+
+__version__='$Revision: 1.6 $'[11:-2]
+
+from SelectCompiler import ast
+
+ListType = type([])
+TupleType = type(())
+SequenceTypes = (ListType, TupleType)
+
+class MutatingWalker:
+
+ def __init__(self, visitor):
+ self.visitor = visitor
+ self._cache = {}
+
+ def defaultVisitNode(self, node, walker=None, exclude=None):
+ for name, child in node.__dict__.items():
+ if exclude is not None and name in exclude:
+ continue
+ v = self.dispatchObject(child)
+ if v is not child:
+ # Replace the node.
+ node.__dict__[name] = v
+ return node
+
+ def visitSequence(self, seq):
+ res = seq
+ for idx in range(len(seq)):
+ child = seq[idx]
+ v = self.dispatchObject(child)
+ if v is not child:
+ # Change the sequence.
+ if type(res) is ListType:
+ res[idx : idx + 1] = [v]
+ else:
+ res = res[:idx] + (v,) + res[idx + 1:]
+ return res
+
+ def dispatchObject(self, ob):
+ '''
+ Expected to return either ob or something that will take
+ its place.
+ '''
+ if isinstance(ob, ast.Node):
+ return self.dispatchNode(ob)
+ elif type(ob) in SequenceTypes:
+ return self.visitSequence(ob)
+ else:
+ return ob
+
+ def dispatchNode(self, node):
+ klass = node.__class__
+ meth = self._cache.get(klass, None)
+ if meth is None:
+ className = klass.__name__
+ meth = getattr(self.visitor, 'visit' + className,
+ self.defaultVisitNode)
+ self._cache[klass] = meth
+ return meth(node, self)
+
+def walk(tree, visitor):
+ return MutatingWalker(visitor).dispatchNode(tree)
diff --git a/lib/kross/python/scripts/RestrictedPython/PrintCollector.py b/lib/kross/python/scripts/RestrictedPython/PrintCollector.py
new file mode 100644
index 00000000..15a1c180
--- /dev/null
+++ b/lib/kross/python/scripts/RestrictedPython/PrintCollector.py
@@ -0,0 +1,23 @@
+##############################################################################
+#
+# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+
+__version__='$Revision: 1.4 $'[11:-2]
+
+class PrintCollector:
+ '''Collect written text, and return it when called.'''
+ def __init__(self):
+ self.txt = []
+ def write(self, text):
+ self.txt.append(text)
+ def __call__(self):
+ return ''.join(self.txt)
diff --git a/lib/kross/python/scripts/RestrictedPython/RCompile.py b/lib/kross/python/scripts/RestrictedPython/RCompile.py
new file mode 100644
index 00000000..0a538657
--- /dev/null
+++ b/lib/kross/python/scripts/RestrictedPython/RCompile.py
@@ -0,0 +1,235 @@
+##############################################################################
+#
+# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Compiles restricted code using the compiler module from the
+Python standard library.
+"""
+
+__version__='$Revision: 1.6 $'[11:-2]
+
+from compiler import ast, parse, misc, syntax, pycodegen
+from compiler.pycodegen import AbstractCompileMode, Expression, \
+ Interactive, Module, ModuleCodeGenerator, FunctionCodeGenerator, findOp
+
+import MutatingWalker
+from RestrictionMutator import RestrictionMutator
+
+
+def niceParse(source, filename, mode):
+ try:
+ return parse(source, mode)
+ except:
+ # Try to make a clean error message using
+ # the builtin Python compiler.
+ try:
+ compile(source, filename, mode)
+ except SyntaxError:
+ raise
+ # Some other error occurred.
+ raise
+
+class RestrictedCompileMode(AbstractCompileMode):
+ """Abstract base class for hooking up custom CodeGenerator."""
+ # See concrete subclasses below.
+
+ def __init__(self, source, filename):
+ self.rm = RestrictionMutator()
+ AbstractCompileMode.__init__(self, source, filename)
+
+ def parse(self):
+ return niceParse(self.source, self.filename, self.mode)
+
+ def _get_tree(self):
+ tree = self.parse()
+ MutatingWalker.walk(tree, self.rm)
+ if self.rm.errors:
+ raise SyntaxError, self.rm.errors[0]
+ misc.set_filename(self.filename, tree)
+ syntax.check(tree)
+ return tree
+
+ def compile(self):
+ tree = self._get_tree()
+ gen = self.CodeGeneratorClass(tree)
+ self.code = gen.getCode()
+
+
+def compileAndTuplize(gen):
+ try:
+ gen.compile()
+ except SyntaxError, v:
+ return None, (str(v),), gen.rm.warnings, gen.rm.used_names
+ return gen.getCode(), (), gen.rm.warnings, gen.rm.used_names
+
+def compile_restricted_function(p, body, name, filename, globalize=None):
+ """Compiles a restricted code object for a function.
+
+ The function can be reconstituted using the 'new' module:
+
+ new.function(<code>, <globals>)
+
+ The globalize argument, if specified, is a list of variable names to be
+ treated as globals (code is generated as if each name in the list
+ appeared in a global statement at the top of the function).
+ """
+ gen = RFunction(p, body, name, filename, globalize)
+ return compileAndTuplize(gen)
+
+def compile_restricted_exec(s, filename='<string>'):
+ """Compiles a restricted code suite."""
+ gen = RModule(s, filename)
+ return compileAndTuplize(gen)
+
+def compile_restricted_eval(s, filename='<string>'):
+ """Compiles a restricted expression."""
+ gen = RExpression(s, filename)
+ return compileAndTuplize(gen)
+
+def compile_restricted(source, filename, mode):
+ """Replacement for the builtin compile() function."""
+ if mode == "single":
+ gen = RInteractive(source, filename)
+ elif mode == "exec":
+ gen = RModule(source, filename)
+ elif mode == "eval":
+ gen = RExpression(source, filename)
+ else:
+ raise ValueError("compile_restricted() 3rd arg must be 'exec' or "
+ "'eval' or 'single'")
+ gen.compile()
+ return gen.getCode()
+
+class RestrictedCodeGenerator:
+ """Mixin for CodeGenerator to replace UNPACK_SEQUENCE bytecodes.
+
+ The UNPACK_SEQUENCE opcode is not safe because it extracts
+ elements from a sequence without using a safe iterator or
+ making __getitem__ checks.
+
+ This code generator replaces use of UNPACK_SEQUENCE with calls to
+ a function that unpacks the sequence, performes the appropriate
+ security checks, and returns a simple list.
+ """
+
+ # Replace the standard code generator for assignments to tuples
+ # and lists.
+
+ def _gen_safe_unpack_sequence(self, num):
+ # We're at a place where UNPACK_SEQUENCE should be generated, to
+ # unpack num items. That's a security hole, since it exposes
+ # individual items from an arbitrary iterable. We don't remove
+ # the UNPACK_SEQUENCE, but instead insert a call to our _getiter_()
+ # wrapper first. That applies security checks to each item as
+ # it's delivered. codegen is (just) a bit messy because the
+ # iterable is already on the stack, so we have to do a stack swap
+ # to get things in the right order.
+ self.emit('LOAD_GLOBAL', '_getiter_')
+ self.emit('ROT_TWO')
+ self.emit('CALL_FUNCTION', 1)
+ self.emit('UNPACK_SEQUENCE', num)
+
+ def _visitAssSequence(self, node):
+ if findOp(node) != 'OP_DELETE':
+ self._gen_safe_unpack_sequence(len(node.nodes))
+ for child in node.nodes:
+ self.visit(child)
+
+ visitAssTuple = _visitAssSequence
+ visitAssList = _visitAssSequence
+
+ # Call to generate code for unpacking nested tuple arguments
+ # in function calls.
+
+ def unpackSequence(self, tup):
+ self._gen_safe_unpack_sequence(len(tup))
+ for elt in tup:
+ if isinstance(elt, tuple):
+ self.unpackSequence(elt)
+ else:
+ self._nameOp('STORE', elt)
+
+# A collection of code generators that adds the restricted mixin to
+# handle unpacking for all the different compilation modes. They
+# are defined here (at the end) so that can refer to RestrictedCodeGenerator.
+
+class RestrictedFunctionCodeGenerator(RestrictedCodeGenerator,
+ pycodegen.FunctionCodeGenerator):
+ pass
+
+class RestrictedExpressionCodeGenerator(RestrictedCodeGenerator,
+ pycodegen.ExpressionCodeGenerator):
+ pass
+
+class RestrictedInteractiveCodeGenerator(RestrictedCodeGenerator,
+ pycodegen.InteractiveCodeGenerator):
+ pass
+
+class RestrictedModuleCodeGenerator(RestrictedCodeGenerator,
+ pycodegen.ModuleCodeGenerator):
+
+ def initClass(self):
+ ModuleCodeGenerator.initClass(self)
+ self.__class__.FunctionGen = RestrictedFunctionCodeGenerator
+
+
+# These subclasses work around the definition of stub compile and mode
+# attributes in the common base class AbstractCompileMode. If it
+# didn't define new attributes, then the stub code inherited via
+# RestrictedCompileMode would override the real definitions in
+# Expression.
+
+class RExpression(RestrictedCompileMode, Expression):
+ mode = "eval"
+ CodeGeneratorClass = RestrictedExpressionCodeGenerator
+
+class RInteractive(RestrictedCompileMode, Interactive):
+ mode = "single"
+ CodeGeneratorClass = RestrictedInteractiveCodeGenerator
+
+class RModule(RestrictedCompileMode, Module):
+ mode = "exec"
+ CodeGeneratorClass = RestrictedModuleCodeGenerator
+
+class RFunction(RModule):
+ """A restricted Python function built from parts."""
+
+ CodeGeneratorClass = RestrictedModuleCodeGenerator
+
+ def __init__(self, p, body, name, filename, globals):
+ self.params = p
+ self.body = body
+ self.name = name
+ self.globals = globals or []
+ RModule.__init__(self, None, filename)
+
+ def parse(self):
+ # Parse the parameters and body, then combine them.
+ firstline = 'def f(%s): pass' % self.params
+ tree = niceParse(firstline, '<function parameters>', 'exec')
+ f = tree.node.nodes[0]
+ body_code = niceParse(self.body, self.filename, 'exec')
+ # Stitch the body code into the function.
+ f.code.nodes = body_code.node.nodes
+ f.name = self.name
+ # Look for a docstring.
+ stmt1 = f.code.nodes[0]
+ if (isinstance(stmt1, ast.Discard) and
+ isinstance(stmt1.expr, ast.Const) and
+ isinstance(stmt1.expr.value, str)):
+ f.doc = stmt1.expr.value
+ # The caller may specify that certain variables are globals
+ # so that they can be referenced before a local assignment.
+ # The only known example is the variables context, container,
+ # script, traverse_subpath in PythonScripts.
+ if self.globals:
+ f.code.nodes.insert(0, ast.Global(self.globals))
+ return tree
diff --git a/lib/kross/python/scripts/RestrictedPython/RestrictionMutator.py b/lib/kross/python/scripts/RestrictedPython/RestrictionMutator.py
new file mode 100644
index 00000000..a8b3850e
--- /dev/null
+++ b/lib/kross/python/scripts/RestrictedPython/RestrictionMutator.py
@@ -0,0 +1,372 @@
+##############################################################################
+#
+# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Modify AST to include security checks.
+
+RestrictionMutator modifies a tree produced by
+compiler.transformer.Transformer, restricting and enhancing the
+code in various ways before sending it to pycodegen.
+
+$Revision: 1.13 $
+"""
+
+from SelectCompiler import ast, parse, OP_ASSIGN, OP_DELETE, OP_APPLY
+
+# These utility functions allow us to generate AST subtrees without
+# line number attributes. These trees can then be inserted into other
+# trees without affecting line numbers shown in tracebacks, etc.
+def rmLineno(node):
+ """Strip lineno attributes from a code tree."""
+ if node.__dict__.has_key('lineno'):
+ del node.lineno
+ for child in node.getChildren():
+ if isinstance(child, ast.Node):
+ rmLineno(child)
+
+def stmtNode(txt):
+ """Make a "clean" statement node."""
+ node = parse(txt).node.nodes[0]
+ rmLineno(node)
+ return node
+
+# The security checks are performed by a set of six functions that
+# must be provided by the restricted environment.
+
+_apply_name = ast.Name("_apply_")
+_getattr_name = ast.Name("_getattr_")
+_getitem_name = ast.Name("_getitem_")
+_getiter_name = ast.Name("_getiter_")
+_print_target_name = ast.Name("_print")
+_write_name = ast.Name("_write_")
+
+# Constants.
+_None_const = ast.Const(None)
+_write_const = ast.Const("write")
+
+_printed_expr = stmtNode("_print()").expr
+_print_target_node = stmtNode("_print = _print_()")
+
+class FuncInfo:
+ print_used = False
+ printed_used = False
+
+class RestrictionMutator:
+
+ def __init__(self):
+ self.warnings = []
+ self.errors = []
+ self.used_names = {}
+ self.funcinfo = FuncInfo()
+
+ def error(self, node, info):
+ """Records a security error discovered during compilation."""
+ lineno = getattr(node, 'lineno', None)
+ if lineno is not None and lineno > 0:
+ self.errors.append('Line %d: %s' % (lineno, info))
+ else:
+ self.errors.append(info)
+
+ def checkName(self, node, name):
+ """Verifies that a name being assigned is safe.
+
+ This is to prevent people from doing things like:
+
+ __metatype__ = mytype (opens up metaclasses, a big unknown
+ in terms of security)
+ __path__ = foo (could this confuse the import machinery?)
+ _getattr = somefunc (not very useful, but could open a hole)
+
+ Note that assigning a variable is not the only way to assign
+ a name. def _badname, class _badname, import foo as _badname,
+ and perhaps other statements assign names. Special case:
+ '_' is allowed.
+ """
+ if name.startswith("_") and name != "_":
+ # Note: "_" *is* allowed.
+ self.error(node, '"%s" is an invalid variable name because'
+ ' it starts with "_"' % name)
+ if name == "printed":
+ self.error(node, '"printed" is a reserved name.')
+
+ def checkAttrName(self, node):
+ """Verifies that an attribute name does not start with _.
+
+ As long as guards (security proxies) have underscored names,
+ this underscore protection is important regardless of the
+ security policy. Special case: '_' is allowed.
+ """
+ name = node.attrname
+ if name.startswith("_") and name != "_":
+ # Note: "_" *is* allowed.
+ self.error(node, '"%s" is an invalid attribute name '
+ 'because it starts with "_".' % name)
+
+ def prepBody(self, body):
+ """Insert code for print at the beginning of the code suite."""
+
+ if self.funcinfo.print_used or self.funcinfo.printed_used:
+ # Add code at top for creating _print_target
+ body.insert(0, _print_target_node)
+ if not self.funcinfo.printed_used:
+ self.warnings.append(
+ "Prints, but never reads 'printed' variable.")
+ elif not self.funcinfo.print_used:
+ self.warnings.append(
+ "Doesn't print, but reads 'printed' variable.")
+
+ def visitFunction(self, node, walker):
+ """Checks and mutates a function definition.
+
+ Checks the name of the function and the argument names using
+ checkName(). It also calls prepBody() to prepend code to the
+ beginning of the code suite.
+ """
+ self.checkName(node, node.name)
+ for argname in node.argnames:
+ if isinstance(argname, str):
+ self.checkName(node, argname)
+ else:
+ for name in argname:
+ self.checkName(node, name)
+ walker.visitSequence(node.defaults)
+
+ former_funcinfo = self.funcinfo
+ self.funcinfo = FuncInfo()
+ node = walker.defaultVisitNode(node, exclude=('defaults',))
+ self.prepBody(node.code.nodes)
+ self.funcinfo = former_funcinfo
+ return node
+
+ def visitLambda(self, node, walker):
+ """Checks and mutates an anonymous function definition.
+
+ Checks the argument names using checkName(). It also calls
+ prepBody() to prepend code to the beginning of the code suite.
+ """
+ for argname in node.argnames:
+ self.checkName(node, argname)
+ return walker.defaultVisitNode(node)
+
+ def visitPrint(self, node, walker):
+ """Checks and mutates a print statement.
+
+ Adds a target to all print statements. 'print foo' becomes
+ 'print >> _print, foo', where _print is the default print
+ target defined for this scope.
+
+ Alternatively, if the untrusted code provides its own target,
+ we have to check the 'write' method of the target.
+ 'print >> ob, foo' becomes
+ 'print >> (_getattr(ob, 'write') and ob), foo'.
+ Otherwise, it would be possible to call the write method of
+ templates and scripts; 'write' happens to be the name of the
+ method that changes them.
+ """
+ node = walker.defaultVisitNode(node)
+ self.funcinfo.print_used = True
+ if node.dest is None:
+ node.dest = _print_target_name
+ else:
+ # Pre-validate access to the "write" attribute.
+ # "print >> ob, x" becomes
+ # "print >> (_getattr(ob, 'write') and ob), x"
+ node.dest = ast.And([
+ ast.CallFunc(_getattr_name, [node.dest, _write_const]),
+ node.dest])
+ return node
+
+ visitPrintnl = visitPrint
+
+ def visitName(self, node, walker):
+ """Prevents access to protected names as defined by checkName().
+
+ Also converts use of the name 'printed' to an expression.
+ """
+ if node.name == 'printed':
+ # Replace name lookup with an expression.
+ self.funcinfo.printed_used = True
+ return _printed_expr
+ self.checkName(node, node.name)
+ self.used_names[node.name] = True
+ return node
+
+ def visitCallFunc(self, node, walker):
+ """Checks calls with *-args and **-args.
+
+ That's a way of spelling apply(), and needs to use our safe
+ _apply_ instead.
+ """
+ walked = walker.defaultVisitNode(node)
+ if node.star_args is None and node.dstar_args is None:
+ # This is not an extended function call
+ return walked
+ # Otherwise transform foo(a, b, c, d=e, f=g, *args, **kws) into a call
+ # of _apply_(foo, a, b, c, d=e, f=g, *args, **kws). The interesting
+ # thing here is that _apply_() is defined with just *args and **kws,
+ # so it gets Python to collapse all the myriad ways to call functions
+ # into one manageable form.
+ #
+ # From there, _apply_() digs out the first argument of *args (it's the
+ # function to call), wraps args and kws in guarded accessors, then
+ # calls the function, returning the value.
+ # Transform foo(...) to _apply(foo, ...)
+ walked.args.insert(0, walked.node)
+ walked.node = _apply_name
+ return walked
+
+ def visitAssName(self, node, walker):
+ """Checks a name assignment using checkName()."""
+ self.checkName(node, node.name)
+ return node
+
+ def visitFor(self, node, walker):
+ # convert
+ # for x in expr:
+ # to
+ # for x in _getiter(expr):
+ #
+ # Note that visitListCompFor is the same thing. Exactly the same
+ # transformation is needed to convert
+ # [... for x in expr ...]
+ # to
+ # [... for x in _getiter(expr) ...]
+ node = walker.defaultVisitNode(node)
+ node.list = ast.CallFunc(_getiter_name, [node.list])
+ return node
+
+ visitListCompFor = visitFor
+
+ def visitGetattr(self, node, walker):
+ """Converts attribute access to a function call.
+
+ 'foo.bar' becomes '_getattr(foo, "bar")'.
+
+ Also prevents augmented assignment of attributes, which would
+ be difficult to support correctly.
+ """
+ self.checkAttrName(node)
+ node = walker.defaultVisitNode(node)
+ if getattr(node, 'in_aug_assign', False):
+ # We're in an augmented assignment
+ # We might support this later...
+ self.error(node, 'Augmented assignment of '
+ 'attributes is not allowed.')
+ return ast.CallFunc(_getattr_name,
+ [node.expr, ast.Const(node.attrname)])
+
+ def visitSubscript(self, node, walker):
+ """Checks all kinds of subscripts.
+
+ 'foo[bar] += baz' is disallowed.
+ 'a = foo[bar, baz]' becomes 'a = _getitem(foo, (bar, baz))'.
+ 'a = foo[bar]' becomes 'a = _getitem(foo, bar)'.
+ 'a = foo[bar:baz]' becomes 'a = _getitem(foo, slice(bar, baz))'.
+ 'a = foo[:baz]' becomes 'a = _getitem(foo, slice(None, baz))'.
+ 'a = foo[bar:]' becomes 'a = _getitem(foo, slice(bar, None))'.
+ 'del foo[bar]' becomes 'del _write(foo)[bar]'.
+ 'foo[bar] = a' becomes '_write(foo)[bar] = a'.
+
+ The _write function returns a security proxy.
+ """
+ node = walker.defaultVisitNode(node)
+ if node.flags == OP_APPLY:
+ # Set 'subs' to the node that represents the subscript or slice.
+ if getattr(node, 'in_aug_assign', False):
+ # We're in an augmented assignment
+ # We might support this later...
+ self.error(node, 'Augmented assignment of '
+ 'object items and slices is not allowed.')
+ if hasattr(node, 'subs'):
+ # Subscript.
+ subs = node.subs
+ if len(subs) > 1:
+ # example: ob[1,2]
+ subs = ast.Tuple(subs)
+ else:
+ # example: ob[1]
+ subs = subs[0]
+ else:
+ # Slice.
+ # example: obj[0:2]
+ lower = node.lower
+ if lower is None:
+ lower = _None_const
+ upper = node.upper
+ if upper is None:
+ upper = _None_const
+ subs = ast.Sliceobj([lower, upper])
+ return ast.CallFunc(_getitem_name, [node.expr, subs])
+ elif node.flags in (OP_DELETE, OP_ASSIGN):
+ # set or remove subscript or slice
+ node.expr = ast.CallFunc(_write_name, [node.expr])
+ return node
+
+ visitSlice = visitSubscript
+
+ def visitAssAttr(self, node, walker):
+ """Checks and mutates attribute assignment.
+
+ 'a.b = c' becomes '_write(a).b = c'.
+ The _write function returns a security proxy.
+ """
+ self.checkAttrName(node)
+ node = walker.defaultVisitNode(node)
+ node.expr = ast.CallFunc(_write_name, [node.expr])
+ return node
+
+ def visitExec(self, node, walker):
+ self.error(node, 'Exec statements are not allowed.')
+
+ def visitYield(self, node, walker):
+ self.error(node, 'Yield statements are not allowed.')
+
+ def visitClass(self, node, walker):
+ """Checks the name of a class using checkName().
+
+ Should classes be allowed at all? They don't cause security
+ issues, but they aren't very useful either since untrusted
+ code can't assign instance attributes.
+ """
+ self.checkName(node, node.name)
+ return walker.defaultVisitNode(node)
+
+ def visitModule(self, node, walker):
+ """Adds prep code at module scope.
+
+ Zope doesn't make use of this. The body of Python scripts is
+ always at function scope.
+ """
+ node = walker.defaultVisitNode(node)
+ self.prepBody(node.node.nodes)
+ return node
+
+ def visitAugAssign(self, node, walker):
+ """Makes a note that augmented assignment is in use.
+
+ Note that although augmented assignment of attributes and
+ subscripts is disallowed, augmented assignment of names (such
+ as 'n += 1') is allowed.
+
+ This could be a problem if untrusted code got access to a
+ mutable database object that supports augmented assignment.
+ """
+ node.node.in_aug_assign = True
+ return walker.defaultVisitNode(node)
+
+ def visitImport(self, node, walker):
+ """Checks names imported using checkName()."""
+ for name, asname in node.names:
+ self.checkName(node, name)
+ if asname:
+ self.checkName(node, asname)
+ return node
+
diff --git a/lib/kross/python/scripts/RestrictedPython/SelectCompiler.py b/lib/kross/python/scripts/RestrictedPython/SelectCompiler.py
new file mode 100644
index 00000000..5f9da698
--- /dev/null
+++ b/lib/kross/python/scripts/RestrictedPython/SelectCompiler.py
@@ -0,0 +1,28 @@
+##############################################################################
+#
+# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Compiler selector.
+
+$Id: SelectCompiler.py 24763 2004-05-17 05:59:28Z philikon $
+"""
+
+# Use the compiler from the standard library.
+import compiler
+from compiler import ast
+from compiler.transformer import parse
+from compiler.consts import OP_ASSIGN, OP_DELETE, OP_APPLY
+
+from RCompile import \
+ compile_restricted, \
+ compile_restricted_function, \
+ compile_restricted_exec, \
+ compile_restricted_eval
diff --git a/lib/kross/python/scripts/RestrictedPython/Utilities.py b/lib/kross/python/scripts/RestrictedPython/Utilities.py
new file mode 100644
index 00000000..87eef69b
--- /dev/null
+++ b/lib/kross/python/scripts/RestrictedPython/Utilities.py
@@ -0,0 +1,77 @@
+##############################################################################
+#
+# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+
+__version__='$Revision: 1.7 $'[11:-2]
+
+import string, math, random
+import DocumentTemplate.sequence
+
+utility_builtins = {}
+
+utility_builtins['string'] = string
+utility_builtins['math'] = math
+utility_builtins['random'] = random
+utility_builtins['whrandom'] = random
+utility_builtins['sequence'] = DocumentTemplate.sequence
+
+try:
+ import DateTime
+ utility_builtins['DateTime']= DateTime.DateTime
+except: pass
+
+def same_type(arg1, *args):
+ '''Compares the class or type of two or more objects.'''
+ t = getattr(arg1, '__class__', type(arg1))
+ for arg in args:
+ if getattr(arg, '__class__', type(arg)) is not t:
+ return 0
+ return 1
+utility_builtins['same_type'] = same_type
+
+def test(*args):
+ l=len(args)
+ for i in range(1, l, 2):
+ if args[i-1]: return args[i]
+
+ if l%2: return args[-1]
+utility_builtins['test'] = test
+
+def reorder(s, with=None, without=()):
+ # s, with, and without are sequences treated as sets.
+ # The result is subtract(intersect(s, with), without),
+ # unless with is None, in which case it is subtract(s, without).
+ if with is None: with=s
+ d={}
+ tt=type(())
+ for i in s:
+ if type(i) is tt and len(i)==2: k, v = i
+ else: k= v = i
+ d[k]=v
+ r=[]
+ a=r.append
+ h=d.has_key
+
+ for i in without:
+ if type(i) is tt and len(i)==2: k, v = i
+ else: k= v = i
+ if h(k): del d[k]
+
+ for i in with:
+ if type(i) is tt and len(i)==2: k, v = i
+ else: k= v = i
+ if h(k):
+ a((k,d[k]))
+ del d[k]
+
+ return r
+utility_builtins['reorder'] = reorder
diff --git a/lib/kross/python/scripts/RestrictedPython/__init__.py b/lib/kross/python/scripts/RestrictedPython/__init__.py
new file mode 100644
index 00000000..0c70947e
--- /dev/null
+++ b/lib/kross/python/scripts/RestrictedPython/__init__.py
@@ -0,0 +1,19 @@
+##############################################################################
+#
+# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+'''
+RestrictedPython package.
+$Id: __init__.py 24763 2004-05-17 05:59:28Z philikon $
+'''
+
+from SelectCompiler import *
+from PrintCollector import PrintCollector
diff --git a/lib/kross/python/scripts/gui.py b/lib/kross/python/scripts/gui.py
new file mode 100755
index 00000000..8891714a
--- /dev/null
+++ b/lib/kross/python/scripts/gui.py
@@ -0,0 +1,396 @@
+"""
+Python script for a GUI-dialog.
+
+Description:
+Python script to provide an abstract GUI for other python scripts. That
+way we've all the GUI-related code within one single file and are
+able to easily modify GUI-stuff in a central place.
+
+Author:
+Sebastian Sauer <mail@dipe.org>
+
+Copyright:
+Published as-is without any warranties.
+"""
+
+def getHome():
+ """ Return the homedirectory. """
+ import os
+ try:
+ home = os.getenv("HOME")
+ if not home:
+ import pwd
+ user = os.getenv("USER") or os.getenv("LOGNAME")
+ if not user:
+ pwent = pwd.getpwuid(os.getuid())
+ else:
+ pwent = pwd.getpwnam(user)
+ home = pwent[6]
+ return home
+ except (KeyError, ImportError):
+ return os.curdir
+
+class TkDialog:
+ """ This class is used to wrap Tkinter into a more abstract interface."""
+
+ def __init__(self, title):
+ import Tkinter
+ self.root = Tkinter.Tk()
+ self.root.title(title)
+ self.root.deiconify()
+
+ mainframe = self.Frame(self, self.root)
+ self.widget = mainframe.widget
+
+ class Widget:
+ def __init__(self, dialog, parent):
+ self.dialog = dialog
+ self.parent = parent
+ #def setVisible(self, visibled): pass
+ #def setEnabled(self, enabled): pass
+
+ class Frame(Widget):
+ def __init__(self, dialog, parent):
+ #TkDialog.Widget.__init__(self, dialog, parent)
+ import Tkinter
+ self.widget = Tkinter.Frame(parent)
+ self.widget.pack()
+
+ class Label(Widget):
+ def __init__(self, dialog, parent, caption):
+ #TkDialog.Widget.__init__(self, dialog, parent)
+ import Tkinter
+ self.widget = Tkinter.Label(parent, text=caption)
+ self.widget.pack(side=Tkinter.TOP)
+
+ class CheckBox(Widget):
+ def __init__(self, dialog, parent, caption, checked = True):
+ #TkDialog.Widget.__init__(self, dialog, parent)
+ import Tkinter
+ self.checkstate = Tkinter.IntVar()
+ self.checkstate.set(checked)
+ self.widget = Tkinter.Checkbutton(parent, text=caption, variable=self.checkstate)
+ self.widget.pack(side=Tkinter.TOP)
+ def isChecked(self):
+ return self.checkstate.get()
+
+ class List(Widget):
+ def __init__(self, dialog, parent, caption, items):
+ #TkDialog.Widget.__init__(self, dialog, parent)
+ import Tkinter
+
+ listframe = Tkinter.Frame(parent)
+ listframe.pack()
+
+ Tkinter.Label(listframe, text=caption).pack(side=Tkinter.LEFT)
+
+ self.items = items
+ self.variable = Tkinter.StringVar()
+ itemlist = apply(Tkinter.OptionMenu, (listframe, self.variable) + tuple( items ))
+ itemlist.pack(side=Tkinter.LEFT)
+ def get(self):
+ return self.variable.get()
+ def set(self, index):
+ self.variable.set( self.items[index] )
+
+ class Button(Widget):
+ def __init__(self, dialog, parent, caption, commandmethod):
+ #TkDialog.Widget.__init__(self, dialog, parent)
+ import Tkinter
+ self.widget = Tkinter.Button(parent, text=caption, command=self.doCommand)
+ self.commandmethod = commandmethod
+ self.widget.pack(side=Tkinter.LEFT)
+ def doCommand(self):
+ try:
+ self.commandmethod()
+ except:
+ #TODO why the heck we arn't able to redirect exceptions?
+ import traceback
+ import StringIO
+ fp = StringIO.StringIO()
+ traceback.print_exc(file=fp)
+ import tkMessageBox
+ tkMessageBox.showerror("Exception", fp.getvalue())
+ #self.dialog.root.destroy()
+
+ class Edit(Widget):
+ def __init__(self, dialog, parent, caption, text):
+ #TkDialog.Widget.__init__(self, dialog, parent)
+ import Tkinter
+ self.widget = Tkinter.Frame(parent)
+ self.widget.pack()
+ label = Tkinter.Label(self.widget, text=caption)
+ label.pack(side=Tkinter.LEFT)
+ self.entrytext = Tkinter.StringVar()
+ self.entrytext.set(text)
+ self.entry = Tkinter.Entry(self.widget, width=36, textvariable=self.entrytext)
+ self.entry.pack(side=Tkinter.LEFT)
+ def get(self):
+ return self.entrytext.get()
+
+ class FileChooser(Edit):
+ def __init__(self, dialog, parent, caption, initialfile = None, filetypes = None):
+ TkDialog.Edit.__init__(self, dialog, parent, caption, initialfile)
+ import Tkinter
+
+ self.initialfile = initialfile
+ self.entrytext.set(initialfile)
+
+ btn = Tkinter.Button(self.widget, text="...", command=self.browse)
+ btn.pack(side=Tkinter.LEFT)
+
+ if filetypes:
+ self.filetypes = filetypes
+ else:
+ self.filetypes = (('All files', '*'),)
+
+ def browse(self):
+ import os
+ text = self.entrytext.get()
+ d = os.path.dirname(text) or os.path.dirname(self.initialfile)
+ f = os.path.basename(text) or os.path.basename(self.initialfile)
+
+ import tkFileDialog
+ file = tkFileDialog.asksaveasfilename(
+ initialdir=d,
+ initialfile=f,
+ #defaultextension='.html',
+ filetypes=self.filetypes
+ )
+ if file:
+ self.entrytext.set( file )
+
+ class MessageBox:
+ def __init__(self, dialog, typename, caption, message):
+ self.widget = dialog.widget
+ self.typename = typename
+ self.caption = str(caption)
+ self.message = str(message)
+ def show(self):
+ import tkMessageBox
+ if self.typename == "okcancel":
+ return tkMessageBox.askokcancel(self.caption, self.message,icon=tkmessageBox.QESTION)
+ else:
+ tkMessageBox.showinfo(self.caption, self.message)
+ return True
+
+ def show(self):
+ self.root.mainloop()
+
+ def close(self):
+ self.root.destroy()
+
+class QtDialog:
+ """ This class is used to wrap pyQt/pyKDE into a more abstract interface."""
+
+ def __init__(self, title):
+ import qt
+
+ class Dialog(qt.QDialog):
+ def __init__(self, parent = None, name = None, modal = 0, fl = 0):
+ qt.QDialog.__init__(self, parent, name, modal, fl)
+ qt.QDialog.accept = self.accept
+ self.layout = qt.QVBoxLayout(self)
+ self.layout.setSpacing(6)
+ self.layout.setMargin(11)
+
+ class Label(qt.QLabel):
+ def __init__(self, dialog, parent, caption):
+ qt.QLabel.__init__(self, parent)
+ self.setText("<qt>%s</qt>" % caption.replace("\n","<br>"))
+
+ class Frame(qt.QHBox):
+ def __init__(self, dialog, parent):
+ qt.QHBox.__init__(self, parent)
+ self.widget = self
+ self.setSpacing(6)
+
+ class Edit(qt.QHBox):
+ def __init__(self, dialog, parent, caption, text):
+ qt.QHBox.__init__(self, parent)
+ self.setSpacing(6)
+ label = qt.QLabel(caption, self)
+ self.edit = qt.QLineEdit(self)
+ self.edit.setText( str(text) )
+ self.setStretchFactor(self.edit, 1)
+ label.setBuddy(self.edit)
+ def get(self):
+ return self.edit.text()
+
+ class Button(qt.QPushButton):
+ #def __init__(self, *args):
+ def __init__(self, dialog, parent, caption, commandmethod):
+ #apply(qt.QPushButton.__init__, (self,) + args)
+ qt.QPushButton.__init__(self, parent)
+ self.commandmethod = commandmethod
+ self.setText(caption)
+ qt.QObject.connect(self, qt.SIGNAL("clicked()"), self.commandmethod)
+
+
+ class CheckBox(qt.QCheckBox):
+ def __init__(self, dialog, parent, caption, checked = True):
+ #TkDialog.Widget.__init__(self, dialog, parent)
+ qt.QCheckBox.__init__(self, parent)
+ self.setText(caption)
+ self.setChecked(checked)
+ #def isChecked(self):
+ # return self.isChecked()
+
+ class List(qt.QHBox):
+ def __init__(self, dialog, parent, caption, items):
+ qt.QHBox.__init__(self, parent)
+ self.setSpacing(6)
+ label = qt.QLabel(caption, self)
+ self.combo = qt.QComboBox(self)
+ self.setStretchFactor(self.combo, 1)
+ label.setBuddy(self.combo)
+ for item in items:
+ self.combo.insertItem( str(item) )
+ def get(self):
+ return self.combo.currentText()
+ def set(self, index):
+ self.combo.setCurrentItem(index)
+
+ class FileChooser(qt.QHBox):
+ def __init__(self, dialog, parent, caption, initialfile = None, filetypes = None):
+ #apply(qt.QHBox.__init__, (self,) + args)
+ qt.QHBox.__init__(self, parent)
+ self.setMinimumWidth(400)
+
+ self.initialfile = initialfile
+ self.filetypes = filetypes
+
+ self.setSpacing(6)
+ label = qt.QLabel(caption, self)
+ self.edit = qt.QLineEdit(self)
+ self.edit.setText(self.initialfile)
+ self.setStretchFactor(self.edit, 1)
+ label.setBuddy(self.edit)
+
+ browsebutton = Button(dialog, self, "...", self.browseButtonClicked)
+ #qt.QObject.connect(browsebutton, qt.SIGNAL("clicked()"), self.browseButtonClicked)
+
+ def get(self):
+ return self.edit.text()
+
+ def browseButtonClicked(self):
+ filtermask = ""
+ import types
+ if isinstance(self.filetypes, types.TupleType):
+ for ft in self.filetypes:
+ if len(ft) == 1:
+ filtermask += "%s\n" % (ft[0])
+ if len(ft) == 2:
+ filtermask += "%s|%s (%s)\n" % (ft[1],ft[0],ft[1])
+ if filtermask == "":
+ filtermask = "All files (*.*)"
+ else:
+ filtermask = filtermask[:-1]
+
+ filename = None
+ try:
+ print "QtDialog.FileChooser.browseButtonClicked() kfile.KFileDialog"
+ # try to use the kfile module included in pykde
+ import kfile
+ filename = kfile.KFileDialog.getOpenFileName(self.initialfile, filtermask, self, "Save to file")
+ except:
+ print "QtDialog.FileChooser.browseButtonClicked() qt.QFileDialog"
+ # fallback to Qt filedialog
+ filename = qt.QFileDialog.getOpenFileName(self.initialfile, filtermask, self, "Save to file")
+ if filename != None and filename != "":
+ self.edit.setText(filename)
+
+ class MessageBox:
+ def __init__(self, dialog, typename, caption, message):
+ self.widget = dialog.widget
+ self.typename = typename
+ self.caption = str(caption)
+ self.message = str(message)
+ def show(self):
+ result = 1
+ if self.typename == "okcancel":
+ result = qt.QMessageBox.question(self.widget, self.caption, self.message, "&Ok", "&Cancel", "", 1)
+ else:
+ qt.QMessageBox.information(self.widget, self.caption, self.message, "&Ok")
+ result = 0
+ if result == 0:
+ return True
+ return False
+
+ self.app = qt.qApp
+ self.dialog = Dialog(self.app.mainWidget(), "Dialog", 1, qt.Qt.WDestructiveClose)
+ self.dialog.setCaption(title)
+
+ self.widget = qt.QVBox(self.dialog)
+ self.widget.setSpacing(6)
+ self.dialog.layout.addWidget(self.widget)
+
+ self.Frame = Frame
+ self.Label = Label
+ self.Edit = Edit
+ self.Button = Button
+ self.CheckBox = CheckBox
+ self.List = List
+ self.FileChooser = FileChooser
+ self.MessageBox = MessageBox
+
+ def show(self):
+ import qt
+ qt.QApplication.setOverrideCursor(qt.Qt.arrowCursor)
+ self.dialog.exec_loop()
+ qt.QApplication.restoreOverrideCursor()
+
+ def close(self):
+ print "QtDialog.close()"
+ self.dialog.close()
+ #self.dialog.deleteLater()
+
+class Dialog:
+ """ Central class that provides abstract GUI-access to the outer world. """
+
+ def __init__(self, title):
+ self.dialog = None
+
+ try:
+ print "Trying to import PyQt..."
+ self.dialog = QtDialog(title)
+ print "PyQt is our toolkit!"
+ except:
+ try:
+ print "Failed to import PyQt. Trying to import TkInter..."
+ self.dialog = TkDialog(title)
+ print "Falling back to TkInter as our toolkit!"
+ except:
+ raise "Failed to import GUI-toolkit. Please install the PyQt or the Tkinter python module."
+
+ self.widget = self.dialog.widget
+
+ def show(self):
+ self.dialog.show()
+
+ def close(self):
+ self.dialog.close()
+
+ def addFrame(self, parentwidget):
+ return self.dialog.Frame(self.dialog, parentwidget.widget)
+
+ def addLabel(self, parentwidget, caption):
+ return self.dialog.Label(self.dialog, parentwidget.widget, caption)
+
+ def addCheckBox(self, parentwidget, caption, checked = True):
+ return self.dialog.CheckBox(self.dialog, parentwidget.widget, caption, checked)
+
+ def addButton(self, parentwidget, caption, commandmethod):
+ return self.dialog.Button(self.dialog, parentwidget.widget, caption, commandmethod)
+
+ def addEdit(self, parentwidget, caption, text):
+ return self.dialog.Edit(self.dialog, parentwidget.widget, caption, text)
+
+ def addFileChooser(self, parentwidget, caption, initialfile = None, filetypes = None):
+ return self.dialog.FileChooser(self.dialog, parentwidget.widget, caption, initialfile, filetypes)
+
+ def addList(self, parentwidget, caption, items):
+ return self.dialog.List(self.dialog, parentwidget.widget, caption, items)
+
+ def showMessageBox(self, typename, caption, message):
+ return self.dialog.MessageBox(self.dialog, typename, caption, message)