+ unify DLL export defines to namespace names
git-svn-id: https://free-cad.svn.sourceforge.net/svnroot/free-cad/trunk@5000 e8eeb9e2-ec13-0410-a4a9-efa5cf37419d
This commit is contained in:
wmayer
132
src/CXX/Python2/Config.hxx
Normal file
132
src/CXX/Python2/Config.hxx
Normal file
@@ -0,0 +1,132 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __PyCXX_config_hh__
|
||||
#define __PyCXX_config_hh__
|
||||
|
||||
//
|
||||
// Microsoft VC++ 6.0 has no traits
|
||||
//
|
||||
#if defined( _MSC_VER )
|
||||
|
||||
# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 1
|
||||
|
||||
#elif defined( __GNUC__ )
|
||||
# if __GNUC__ >= 3
|
||||
# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 1
|
||||
# else
|
||||
# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 0
|
||||
#endif
|
||||
|
||||
//
|
||||
// Assume all other compilers do
|
||||
//
|
||||
#else
|
||||
|
||||
// Macros to deal with deficiencies in compilers
|
||||
# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 1
|
||||
#endif
|
||||
|
||||
#if STANDARD_LIBRARY_HAS_ITERATOR_TRAITS
|
||||
# define random_access_iterator_parent(itemtype) std::iterator<std::random_access_iterator_tag,itemtype,int>
|
||||
#else
|
||||
# define random_access_iterator_parent(itemtype) std::random_access_iterator<itemtype, int>
|
||||
#endif
|
||||
|
||||
//
|
||||
// Which C++ standard is in use?
|
||||
//
|
||||
#if defined( _MSC_VER )
|
||||
# if _MSC_VER <= 1200
|
||||
// MSVC++ 6.0
|
||||
# define PYCXX_ISO_CPP_LIB 0
|
||||
# define STR_STREAM <strstream>
|
||||
# define TEMPLATE_TYPENAME class
|
||||
# else
|
||||
# define PYCXX_ISO_CPP_LIB 1
|
||||
# define STR_STREAM <sstream>
|
||||
# define TEMPLATE_TYPENAME typename
|
||||
# endif
|
||||
#elif defined( __GNUC__ )
|
||||
# if __GNUC__ >= 3
|
||||
# define PYCXX_ISO_CPP_LIB 1
|
||||
# define STR_STREAM <sstream>
|
||||
# define TEMPLATE_TYPENAME typename
|
||||
# else
|
||||
# define PYCXX_ISO_CPP_LIB 0
|
||||
# define STR_STREAM <strstream>
|
||||
# define TEMPLATE_TYPENAME class
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if PYCXX_ISO_CPP_LIB
|
||||
# define STR_STREAM <sstream>
|
||||
# define OSTRSTREAM ostringstream
|
||||
# define EXPLICIT_TYPENAME typename
|
||||
# define EXPLICIT_CLASS class
|
||||
# define TEMPLATE_TYPENAME typename
|
||||
#else
|
||||
# define STR_STREAM <strstream>
|
||||
# define OSTRSTREAM ostrstream
|
||||
# define EXPLICIT_TYPENAME
|
||||
# define EXPLICIT_CLASS
|
||||
# define TEMPLATE_TYPENAME class
|
||||
#endif
|
||||
|
||||
// before 2.5 Py_ssize_t was missing
|
||||
#ifndef PY_MAJOR_VERSION
|
||||
#error not defined PY_MAJOR_VERSION
|
||||
#endif
|
||||
#if PY_MAJOR_VERSION < 2 || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 5)
|
||||
typedef int Py_ssize_t;
|
||||
#endif
|
||||
|
||||
// export macro
|
||||
#if defined( _MSC_VER )
|
||||
# pragma warning( disable : 4251 )
|
||||
#endif
|
||||
#if defined( _MSC_VER ) || defined( __MINGW32__ )
|
||||
# ifdef PYCXX_DLL
|
||||
# define PYCXX_EXPORT __declspec(dllexport)
|
||||
# else
|
||||
# define PYCXX_EXPORT __declspec(dllimport)
|
||||
# endif
|
||||
#else
|
||||
# define PYCXX_EXPORT
|
||||
#endif
|
||||
|
||||
#endif // __PyCXX_config_hh__
|
||||
17
src/CXX/Python2/CxxDebug.hxx
Normal file
17
src/CXX/Python2/CxxDebug.hxx
Normal file
@@ -0,0 +1,17 @@
|
||||
//
|
||||
// CxxDebug.hxx
|
||||
//
|
||||
// Copyright (c) 2008 Barry A. Scott
|
||||
//
|
||||
#ifndef __CXX_Debug_hxx
|
||||
#define __CXX_Debug_hxx
|
||||
|
||||
//
|
||||
// Functions useful when debugging PyCXX
|
||||
//
|
||||
#ifdef PYCXX_DEBUG
|
||||
extern void bpt();
|
||||
extern void printRefCount( PyObject *obj );
|
||||
#endif
|
||||
|
||||
#endif
|
||||
249
src/CXX/Python2/Exception.hxx
Normal file
249
src/CXX/Python2/Exception.hxx
Normal file
@@ -0,0 +1,249 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __CXX_Exception_h
|
||||
#define __CXX_Exception_h
|
||||
|
||||
#include "CXX/WrapPython.h"
|
||||
#include "CXX/Version.hxx"
|
||||
#include "CXX/Config.hxx"
|
||||
#include "CXX/IndirectPythonInterface.hxx"
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
|
||||
// This mimics the Python structure, in order to minimize confusion
|
||||
namespace Py
|
||||
{
|
||||
class ExtensionExceptionType;
|
||||
|
||||
class Object;
|
||||
|
||||
class PYCXX_EXPORT Exception
|
||||
{
|
||||
public:
|
||||
Exception( ExtensionExceptionType &exception, const std::string& reason );
|
||||
Exception( ExtensionExceptionType &exception, Object &reason );
|
||||
|
||||
explicit Exception ()
|
||||
{}
|
||||
|
||||
Exception (const std::string& reason)
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_RuntimeError(), reason.c_str());
|
||||
}
|
||||
|
||||
Exception (PyObject* exception, const std::string& reason)
|
||||
{
|
||||
PyErr_SetString (exception, reason.c_str());
|
||||
}
|
||||
|
||||
Exception (PyObject* exception, Object &reason);
|
||||
|
||||
void clear() // clear the error
|
||||
// technically but not philosophically const
|
||||
{
|
||||
PyErr_Clear();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// Abstract
|
||||
class PYCXX_EXPORT StandardError: public Exception
|
||||
{
|
||||
protected:
|
||||
explicit StandardError()
|
||||
{}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT LookupError: public StandardError
|
||||
{
|
||||
protected:
|
||||
explicit LookupError()
|
||||
{}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT ArithmeticError: public StandardError
|
||||
{
|
||||
protected:
|
||||
explicit ArithmeticError()
|
||||
{}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT EnvironmentError: public StandardError
|
||||
{
|
||||
protected:
|
||||
explicit EnvironmentError()
|
||||
{}
|
||||
};
|
||||
|
||||
// Concrete
|
||||
|
||||
class PYCXX_EXPORT TypeError: public StandardError
|
||||
{
|
||||
public:
|
||||
TypeError (const std::string& reason)
|
||||
: StandardError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_TypeError(),reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT IndexError: public LookupError
|
||||
{
|
||||
public:
|
||||
IndexError (const std::string& reason)
|
||||
: LookupError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_IndexError(), reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT AttributeError: public StandardError
|
||||
{
|
||||
public:
|
||||
AttributeError (const std::string& reason)
|
||||
: StandardError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_AttributeError(), reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT NameError: public StandardError
|
||||
{
|
||||
public:
|
||||
NameError (const std::string& reason)
|
||||
: StandardError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_NameError(), reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT RuntimeError: public StandardError
|
||||
{
|
||||
public:
|
||||
RuntimeError (const std::string& reason)
|
||||
: StandardError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_RuntimeError(), reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT SystemError: public StandardError
|
||||
{
|
||||
public:
|
||||
SystemError (const std::string& reason)
|
||||
: StandardError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_SystemError(),reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT KeyError: public LookupError
|
||||
{
|
||||
public:
|
||||
KeyError (const std::string& reason)
|
||||
: LookupError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_KeyError(),reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class PYCXX_EXPORT ValueError: public StandardError
|
||||
{
|
||||
public:
|
||||
ValueError (const std::string& reason)
|
||||
: StandardError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_ValueError(), reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT OverflowError: public ArithmeticError
|
||||
{
|
||||
public:
|
||||
OverflowError (const std::string& reason)
|
||||
: ArithmeticError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_OverflowError(), reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT ZeroDivisionError: public ArithmeticError
|
||||
{
|
||||
public:
|
||||
ZeroDivisionError (const std::string& reason)
|
||||
: ArithmeticError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_ZeroDivisionError(), reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT FloatingPointError: public ArithmeticError
|
||||
{
|
||||
public:
|
||||
FloatingPointError (const std::string& reason)
|
||||
: ArithmeticError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_FloatingPointError(), reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT MemoryError: public StandardError
|
||||
{
|
||||
public:
|
||||
MemoryError (const std::string& reason)
|
||||
: StandardError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_MemoryError(), reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT SystemExit: public StandardError
|
||||
{
|
||||
public:
|
||||
SystemExit (const std::string& reason)
|
||||
: StandardError()
|
||||
{
|
||||
PyErr_SetString (Py::_Exc_SystemExit(),reason.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
}// Py
|
||||
|
||||
#endif
|
||||
208
src/CXX/Python2/ExtensionModule.hxx
Normal file
208
src/CXX/Python2/ExtensionModule.hxx
Normal file
@@ -0,0 +1,208 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __CXX_ExtensionModule__h
|
||||
#define __CXX_ExtensionModule__h
|
||||
|
||||
namespace Py
|
||||
{
|
||||
class PYCXX_EXPORT 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_noargs( void *method_def ) = 0;
|
||||
virtual Object invoke_method_keyword( void *method_def, const Tuple &_args, const Dict &_keywords ) = 0;
|
||||
virtual Object invoke_method_varargs( void *method_def, const Tuple &_args ) = 0;
|
||||
|
||||
const std::string &name() const;
|
||||
const std::string &fullName() const;
|
||||
|
||||
// what is returned from PyInit_<module> function
|
||||
Object moduleObject( void ) const;
|
||||
|
||||
protected:
|
||||
// Initialize the module
|
||||
void initialize( const char *module_doc );
|
||||
|
||||
const std::string m_module_name;
|
||||
const std::string m_full_module_name;
|
||||
MethodTable m_method_table;
|
||||
#if PY3
|
||||
PyModuleDef m_module_def;
|
||||
#endif
|
||||
PyObject *m_module;
|
||||
|
||||
private:
|
||||
//
|
||||
// prevent the compiler generating these unwanted functions
|
||||
//
|
||||
ExtensionModuleBase( const ExtensionModuleBase & ); //unimplemented
|
||||
void operator=( const ExtensionModuleBase & ); //unimplemented
|
||||
};
|
||||
|
||||
// Note: Python calls noargs as varargs buts args==NULL
|
||||
extern "C" PYCXX_EXPORT PyObject *method_noargs_call_handler( PyObject *_self_and_name_tuple, PyObject * );
|
||||
extern "C" PYCXX_EXPORT PyObject *method_varargs_call_handler( PyObject *_self_and_name_tuple, PyObject *_args );
|
||||
extern "C" PYCXX_EXPORT PyObject *method_keyword_call_handler( PyObject *_self_and_name_tuple, PyObject *_args, PyObject *_keywords );
|
||||
|
||||
extern "C" PYCXX_EXPORT 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_noargs_function_t)();
|
||||
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_noargs_method( const char *name, method_noargs_function_t function, const char *doc="" )
|
||||
{
|
||||
method_map_t &mm = methods();
|
||||
mm[ std::string( name ) ] = new MethodDefExt<T>( name, function, method_noargs_call_handler, doc );
|
||||
}
|
||||
|
||||
static void add_varargs_method( const char *name, method_varargs_function_t function, const char *doc="" )
|
||||
{
|
||||
method_map_t &mm = methods();
|
||||
mm[ std::string( name ) ] = new MethodDefExt<T>( name, function, method_varargs_call_handler, doc );
|
||||
}
|
||||
|
||||
static void add_keyword_method( const char *name, method_keyword_function_t function, const char *doc="" )
|
||||
{
|
||||
method_map_t &mm = methods();
|
||||
mm[ std::string( name ) ] = new MethodDefExt<T>( name, function, method_keyword_call_handler, doc );
|
||||
}
|
||||
|
||||
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::const_iterator i = mm.begin();
|
||||
EXPLICIT_TYPENAME method_map_t::const_iterator i_end = mm.end();
|
||||
for ( ; i != i_end; ++i )
|
||||
{
|
||||
MethodDefExt<T> *method_def = (*i).second;
|
||||
|
||||
static PyObject *self = PyCObject_FromVoidPtr( this, do_not_dealloc );
|
||||
|
||||
Tuple args( 2 );
|
||||
args[0] = Object( self );
|
||||
args[1] = Object( PyCObject_FromVoidPtr( method_def, do_not_dealloc ) );
|
||||
|
||||
PyObject *func = PyCFunction_New
|
||||
(
|
||||
&method_def->ext_meth_def,
|
||||
new_reference_to( args )
|
||||
);
|
||||
|
||||
method_def->py_method = Object( func, true );
|
||||
|
||||
dict[ (*i).first ] = method_def->py_method;
|
||||
}
|
||||
}
|
||||
|
||||
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_noargs( void *method_def )
|
||||
{
|
||||
// cast up to the derived class, method_def and call
|
||||
T *self = static_cast<T *>( this );
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>( method_def );
|
||||
|
||||
return (self->*meth_def->ext_noargs_function)();
|
||||
}
|
||||
|
||||
// this invoke function must be called from within a try catch block
|
||||
virtual Object invoke_method_varargs( void *method_def, const Tuple &args )
|
||||
{
|
||||
// cast up to the derived class, method_def and call
|
||||
T *self = static_cast<T *>( this );
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>( method_def );
|
||||
|
||||
return (self->*meth_def->ext_varargs_function)( args );
|
||||
}
|
||||
|
||||
// this invoke function must be called from within a try catch block
|
||||
virtual Object invoke_method_keyword( void *method_def, const Tuple &args, const Dict &keywords )
|
||||
{
|
||||
// cast up to the derived class, method_def and call
|
||||
T *self = static_cast<T *>( this );
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>( method_def );
|
||||
|
||||
return (self->*meth_def->ext_keyword_function)( args, keywords );
|
||||
}
|
||||
|
||||
private:
|
||||
//
|
||||
// prevent the compiler generating these unwanted functions
|
||||
//
|
||||
ExtensionModule( const ExtensionModule<T> & ); //unimplemented
|
||||
void operator=( const ExtensionModule<T> & ); //unimplemented
|
||||
};
|
||||
} // Namespace Py
|
||||
|
||||
|
||||
// End of __CXX_ExtensionModule__h
|
||||
#endif
|
||||
397
src/CXX/Python2/ExtensionOldType.hxx
Normal file
397
src/CXX/Python2/ExtensionOldType.hxx
Normal file
@@ -0,0 +1,397 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __CXX_ExtensionOldType__h
|
||||
#define __CXX_ExtensionOldType__h
|
||||
|
||||
namespace Py
|
||||
{
|
||||
template<TEMPLATE_TYPENAME T> class PythonExtension
|
||||
: public PythonExtensionBase
|
||||
{
|
||||
public:
|
||||
static PyTypeObject *type_object()
|
||||
{
|
||||
return behaviors().type_object();
|
||||
}
|
||||
|
||||
static bool check( PyObject *p )
|
||||
{
|
||||
// is p like me?
|
||||
return p->ob_type == type_object();
|
||||
}
|
||||
|
||||
static bool 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 );
|
||||
}
|
||||
|
||||
PyObject *selfPtr()
|
||||
{
|
||||
return this;
|
||||
}
|
||||
|
||||
Object self()
|
||||
{
|
||||
return asObject( this );
|
||||
}
|
||||
|
||||
protected:
|
||||
explicit PythonExtension()
|
||||
: PythonExtensionBase()
|
||||
{
|
||||
PyObject_Init( this, type_object() );
|
||||
|
||||
// every object must support getattr
|
||||
behaviors().supportGetattr();
|
||||
}
|
||||
|
||||
virtual ~PythonExtension()
|
||||
{}
|
||||
|
||||
static PythonType &behaviors()
|
||||
{
|
||||
static PythonType* p;
|
||||
if( p == NULL )
|
||||
{
|
||||
#if defined( _CPPRTTI ) || defined( __GNUG__ )
|
||||
const char *default_name =( typeid( T ) ).name();
|
||||
#else
|
||||
const char *default_name = "unknown";
|
||||
#endif
|
||||
p = new PythonType( sizeof( T ), 0, default_name );
|
||||
p->set_tp_dealloc( extension_object_deallocator );
|
||||
}
|
||||
|
||||
return *p;
|
||||
}
|
||||
|
||||
typedef Object (T::*method_noargs_function_t)();
|
||||
typedef Object (T::*method_varargs_function_t)( const Tuple &args );
|
||||
typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws );
|
||||
typedef std::map<std::string, MethodDefExt<T> *> method_map_t;
|
||||
|
||||
// support the default attributes, __name__, __doc__ and methods
|
||||
virtual Object getattr_default( const char *_name )
|
||||
{
|
||||
std::string name( _name );
|
||||
|
||||
if( name == "__name__" && type_object()->tp_name != NULL )
|
||||
{
|
||||
return Py::String( type_object()->tp_name );
|
||||
}
|
||||
|
||||
if( name == "__doc__" && type_object()->tp_doc != NULL )
|
||||
{
|
||||
return Py::String( type_object()->tp_doc );
|
||||
}
|
||||
|
||||
// trying to fake out being a class for help()
|
||||
// else if( name == "__bases__" )
|
||||
// {
|
||||
// return Py::Tuple( 0 );
|
||||
// }
|
||||
// else if( name == "__module__" )
|
||||
// {
|
||||
// return Py::Nothing();
|
||||
// }
|
||||
// else if( name == "__dict__" )
|
||||
// {
|
||||
// return Py::Dict();
|
||||
// }
|
||||
|
||||
return getattr_methods( _name );
|
||||
}
|
||||
|
||||
// turn a name into function object
|
||||
virtual Object getattr_methods( const char *_name )
|
||||
{
|
||||
std::string name( _name );
|
||||
|
||||
method_map_t &mm = methods();
|
||||
|
||||
// see if name exists and get entry with method
|
||||
EXPLICIT_TYPENAME method_map_t::const_iterator i = mm.find( name );
|
||||
if( i == mm.end() )
|
||||
{
|
||||
if( name == "__methods__" )
|
||||
{
|
||||
List methods;
|
||||
|
||||
i = mm.begin();
|
||||
EXPLICIT_TYPENAME method_map_t::const_iterator i_end = mm.end();
|
||||
|
||||
for( ; i != i_end; ++i )
|
||||
methods.append( String( (*i).first ) );
|
||||
|
||||
return methods;
|
||||
}
|
||||
|
||||
throw AttributeError( name );
|
||||
}
|
||||
|
||||
MethodDefExt<T> *method_def = i->second;
|
||||
|
||||
Tuple self( 2 );
|
||||
|
||||
self[0] = Object( this );
|
||||
self[1] = Object( PyCObject_FromVoidPtr( method_def, do_not_dealloc ) );
|
||||
|
||||
PyObject *func = PyCFunction_New( &method_def->ext_meth_def, self.ptr() );
|
||||
|
||||
return Object(func, true);
|
||||
}
|
||||
|
||||
// check that all methods added are unique
|
||||
static void check_unique_method_name( const char *name )
|
||||
{
|
||||
method_map_t &mm = methods();
|
||||
EXPLICIT_TYPENAME method_map_t::const_iterator i;
|
||||
i = mm.find( name );
|
||||
if( i != mm.end() )
|
||||
throw AttributeError( name );
|
||||
}
|
||||
|
||||
static void add_noargs_method( const char *name, method_noargs_function_t function, const char *doc="" )
|
||||
{
|
||||
check_unique_method_name( name );
|
||||
method_map_t &mm = methods();
|
||||
mm[ std::string( name ) ] = new MethodDefExt<T>( name, function, method_noargs_call_handler, doc );
|
||||
}
|
||||
|
||||
static void add_varargs_method( const char *name, method_varargs_function_t function, const char *doc="" )
|
||||
{
|
||||
check_unique_method_name( name );
|
||||
method_map_t &mm = methods();
|
||||
mm[ std::string( name ) ] = new MethodDefExt<T>( name, function, method_varargs_call_handler, doc );
|
||||
}
|
||||
|
||||
static void add_keyword_method( const char *name, method_keyword_function_t function, const char *doc="" )
|
||||
{
|
||||
check_unique_method_name( name );
|
||||
method_map_t &mm = methods();
|
||||
mm[ std::string( name ) ] = new MethodDefExt<T>( name, function, method_keyword_call_handler, doc );
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
// Note: Python calls noargs as varargs buts args==NULL
|
||||
static PyObject *method_noargs_call_handler( PyObject *_self_and_name_tuple, PyObject * )
|
||||
{
|
||||
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 );
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>(
|
||||
PyCObject_AsVoidPtr( self_and_name_tuple[1].ptr() ) );
|
||||
Object result;
|
||||
|
||||
// Adding try & catch in case of STL debug-mode exceptions.
|
||||
#ifdef _STLP_DEBUG
|
||||
try
|
||||
{
|
||||
result = (self->*meth_def->ext_noargs_function)();
|
||||
}
|
||||
catch( std::__stl_debug_exception )
|
||||
{
|
||||
// throw cxx::RuntimeError( sErrMsg );
|
||||
throw RuntimeError( "Error message not set yet." );
|
||||
}
|
||||
#else
|
||||
result = (self->*meth_def->ext_noargs_function)();
|
||||
#endif // _STLP_DEBUG
|
||||
|
||||
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 );
|
||||
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>(
|
||||
PyCObject_AsVoidPtr( self_and_name_tuple[1].ptr() ) );
|
||||
Tuple args( _args );
|
||||
|
||||
Object result;
|
||||
|
||||
// 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 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 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 );
|
||||
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>(
|
||||
PyCObject_AsVoidPtr( self_and_name_tuple[1].ptr() ) );
|
||||
|
||||
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 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 )
|
||||
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_ExtensionOldType__h
|
||||
#endif
|
||||
403
src/CXX/Python2/ExtensionType.hxx
Normal file
403
src/CXX/Python2/ExtensionType.hxx
Normal file
@@ -0,0 +1,403 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __CXX_ExtensionClass__h
|
||||
#define __CXX_ExtensionClass__h
|
||||
|
||||
#define PYCXX_NOARGS_METHOD_NAME( NAME ) _callNoArgsMethod__##NAME
|
||||
#define PYCXX_VARARGS_METHOD_NAME( NAME ) _callVarArgsMethod__##NAME
|
||||
#define PYCXX_KEYWORDS_METHOD_NAME( NAME ) _callKeywordsMethod__##NAME
|
||||
|
||||
#define PYCXX_NOARGS_METHOD_DECL( CLS, NAME ) \
|
||||
static PyObject *PYCXX_NOARGS_METHOD_NAME( NAME )( PyObject *_self, PyObject *, PyObject * ) \
|
||||
{ \
|
||||
try \
|
||||
{ \
|
||||
Py::PythonClassInstance *self_python = reinterpret_cast< Py::PythonClassInstance * >( _self ); \
|
||||
CLS *self = reinterpret_cast< CLS * >( self_python->m_pycxx_object ); \
|
||||
Py::Object r( (self->NAME)() ); \
|
||||
return Py::new_reference_to( r.ptr() ); \
|
||||
} \
|
||||
catch( Py::Exception & ) \
|
||||
{ \
|
||||
return 0; \
|
||||
} \
|
||||
}
|
||||
#define PYCXX_VARARGS_METHOD_DECL( CLS, NAME ) \
|
||||
static PyObject *PYCXX_VARARGS_METHOD_NAME( NAME )( PyObject *_self, PyObject *_a, PyObject * ) \
|
||||
{ \
|
||||
try \
|
||||
{ \
|
||||
Py::PythonClassInstance *self_python = reinterpret_cast< Py::PythonClassInstance * >( _self ); \
|
||||
CLS *self = reinterpret_cast< CLS * >( self_python->m_pycxx_object ); \
|
||||
Py::Tuple a( _a ); \
|
||||
Py::Object r( (self->NAME)( a ) ); \
|
||||
return Py::new_reference_to( r.ptr() ); \
|
||||
} \
|
||||
catch( Py::Exception & ) \
|
||||
{ \
|
||||
return 0; \
|
||||
} \
|
||||
}
|
||||
#define PYCXX_KEYWORDS_METHOD_DECL( CLS, NAME ) \
|
||||
static PyObject *PYCXX_KEYWORDS_METHOD_NAME( NAME )( PyObject *_self, PyObject *_a, PyObject *_k ) \
|
||||
{ \
|
||||
try \
|
||||
{ \
|
||||
Py::PythonClassInstance *self_python = reinterpret_cast< Py::PythonClassInstance * >( _self ); \
|
||||
CLS *self = reinterpret_cast< CLS * >( self_python->m_pycxx_object ); \
|
||||
Py::Tuple a( _a ); \
|
||||
Py::Dict k; \
|
||||
if( _k != NULL ) \
|
||||
k = _k; \
|
||||
Py::Object r( (self->NAME)( a, k ) ); \
|
||||
return Py::new_reference_to( r.ptr() ); \
|
||||
} \
|
||||
catch( Py::Exception & ) \
|
||||
{ \
|
||||
return 0; \
|
||||
} \
|
||||
}
|
||||
|
||||
// need to support METH_STATIC and METH_CLASS
|
||||
|
||||
#define PYCXX_ADD_NOARGS_METHOD( PYNAME, NAME, docs ) \
|
||||
add_method( #PYNAME, (PyCFunction)PYCXX_NOARGS_METHOD_NAME( NAME ), METH_NOARGS, docs )
|
||||
#define PYCXX_ADD_VARARGS_METHOD( PYNAME, NAME, docs ) \
|
||||
add_method( #PYNAME, (PyCFunction)PYCXX_VARARGS_METHOD_NAME( NAME ), METH_VARARGS, docs )
|
||||
#define PYCXX_ADD_KEYWORDS_METHOD( PYNAME, NAME, docs ) \
|
||||
add_method( #PYNAME, (PyCFunction)PYCXX_KEYWORDS_METHOD_NAME( NAME ), METH_VARARGS | METH_KEYWORDS, docs )
|
||||
|
||||
namespace Py
|
||||
{
|
||||
extern PythonExtensionBase *getPythonExtensionBase( PyObject *self );
|
||||
|
||||
struct PythonClassInstance
|
||||
{
|
||||
PyObject_HEAD
|
||||
PythonExtensionBase *m_pycxx_object;
|
||||
};
|
||||
|
||||
|
||||
class PYCXX_EXPORT ExtensionClassMethodsTable
|
||||
{
|
||||
public:
|
||||
ExtensionClassMethodsTable()
|
||||
: m_methods_table( new PyMethodDef[ METHOD_TABLE_SIZE_INCREMENT ] )
|
||||
, m_methods_used( 0 )
|
||||
, m_methods_size( METHOD_TABLE_SIZE_INCREMENT )
|
||||
{
|
||||
}
|
||||
|
||||
~ExtensionClassMethodsTable()
|
||||
{
|
||||
delete m_methods_table;
|
||||
}
|
||||
|
||||
// check that all methods added are unique
|
||||
void check_unique_method_name( const char *_name )
|
||||
{
|
||||
std::string name( _name );
|
||||
for( int i=0; i<m_methods_used; i++ )
|
||||
{
|
||||
if( name == m_methods_table[i].ml_name )
|
||||
{
|
||||
throw AttributeError( name );
|
||||
}
|
||||
}
|
||||
}
|
||||
PyMethodDef *add_method( const char *name, PyCFunction function, int flags, const char *doc )
|
||||
{
|
||||
check_unique_method_name( name );
|
||||
|
||||
// see if there is enough space for one more method
|
||||
if( m_methods_used == (m_methods_size-1) )
|
||||
{
|
||||
PyMethodDef *old_mt = m_methods_table;
|
||||
m_methods_size += METHOD_TABLE_SIZE_INCREMENT;
|
||||
PyMethodDef *new_mt = new PyMethodDef[ m_methods_size ];
|
||||
for( int i=0; i<m_methods_used; i++ )
|
||||
{
|
||||
new_mt[ i ] = old_mt[ i ];
|
||||
}
|
||||
delete[] old_mt;
|
||||
m_methods_table = new_mt;
|
||||
}
|
||||
|
||||
// add method into the table
|
||||
PyMethodDef *p = &m_methods_table[ m_methods_used ];
|
||||
p->ml_name = const_cast<char *>( name );
|
||||
p->ml_meth = function;
|
||||
p->ml_flags = flags;
|
||||
p->ml_doc = const_cast<char *>( doc );
|
||||
|
||||
m_methods_used++;
|
||||
p++;
|
||||
|
||||
// add the sentinel marking the table end
|
||||
p->ml_name = NULL;
|
||||
p->ml_meth = NULL;
|
||||
p->ml_flags = 0;
|
||||
p->ml_doc = NULL;
|
||||
|
||||
return m_methods_table;
|
||||
}
|
||||
|
||||
private:
|
||||
enum {METHOD_TABLE_SIZE_INCREMENT = 1};
|
||||
PyMethodDef *m_methods_table;
|
||||
int m_methods_used;
|
||||
int m_methods_size;
|
||||
};
|
||||
|
||||
template<TEMPLATE_TYPENAME T> class PythonClass
|
||||
: public PythonExtensionBase
|
||||
{
|
||||
protected:
|
||||
explicit PythonClass( PythonClassInstance *self, Tuple &args, Dict &kwds )
|
||||
: PythonExtensionBase()
|
||||
, m_class_instance( self )
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~PythonClass()
|
||||
{}
|
||||
|
||||
static ExtensionClassMethodsTable &methodTable()
|
||||
{
|
||||
static ExtensionClassMethodsTable *method_table;
|
||||
if( method_table == NULL )
|
||||
method_table = new ExtensionClassMethodsTable;
|
||||
return *method_table;
|
||||
}
|
||||
|
||||
static void add_method( const char *name, PyCFunction function, int flags, const char *doc=NULL )
|
||||
{
|
||||
behaviors().set_methods( methodTable().add_method( name, function, flags, doc ) );
|
||||
}
|
||||
|
||||
static PythonType &behaviors()
|
||||
{
|
||||
static PythonType *p;
|
||||
if( p == NULL )
|
||||
{
|
||||
#if defined( _CPPRTTI ) || defined( __GNUG__ )
|
||||
const char *default_name = (typeid( T )).name();
|
||||
#else
|
||||
const char *default_name = "unknown";
|
||||
#endif
|
||||
p = new PythonType( sizeof( T ), 0, default_name );
|
||||
p->set_tp_new( extension_object_new );
|
||||
p->set_tp_init( extension_object_init );
|
||||
p->set_tp_dealloc( extension_object_deallocator );
|
||||
// we are a class
|
||||
p->supportClass();
|
||||
|
||||
// always support get and set attr
|
||||
p->supportGetattro();
|
||||
p->supportSetattro();
|
||||
}
|
||||
|
||||
return *p;
|
||||
}
|
||||
|
||||
static PyObject *extension_object_new( PyTypeObject *subtype, PyObject *args, PyObject *kwds )
|
||||
{
|
||||
#ifdef PYCXX_DEBUG
|
||||
std::cout << "extension_object_new()" << std::endl;
|
||||
#endif
|
||||
PythonClassInstance *o = reinterpret_cast<PythonClassInstance *>( subtype->tp_alloc( subtype, 0 ) );
|
||||
if( o == NULL )
|
||||
return NULL;
|
||||
|
||||
o->m_pycxx_object = NULL;
|
||||
|
||||
PyObject *self = reinterpret_cast<PyObject *>( o );
|
||||
#ifdef PYCXX_DEBUG
|
||||
std::cout << "extension_object_new() => self=0x" << std::hex << reinterpret_cast< unsigned int >( self ) << std::dec << std::endl;
|
||||
#endif
|
||||
return self;
|
||||
}
|
||||
|
||||
static int extension_object_init( PyObject *_self, PyObject *args_, PyObject *kwds_ )
|
||||
{
|
||||
try
|
||||
{
|
||||
Py::Tuple args( args_ );
|
||||
Py::Dict kwds;
|
||||
if( kwds_ != NULL )
|
||||
kwds = kwds_;
|
||||
|
||||
PythonClassInstance *self = reinterpret_cast<PythonClassInstance *>( _self );
|
||||
#ifdef PYCXX_DEBUG
|
||||
std::cout << "extension_object_init( self=0x" << std::hex << reinterpret_cast< unsigned int >( self ) << std::dec << " )" << std::endl;
|
||||
std::cout << " self->m_pycxx_object=0x" << std::hex << reinterpret_cast< unsigned int >( self->m_pycxx_object ) << std::dec << std::endl;
|
||||
#endif
|
||||
|
||||
if( self->m_pycxx_object == NULL )
|
||||
{
|
||||
self->m_pycxx_object = new T( self, args, kwds );
|
||||
#ifdef PYCXX_DEBUG
|
||||
std::cout << " self->m_pycxx_object=0x" << std::hex << reinterpret_cast< unsigned int >( self->m_pycxx_object ) << std::dec << std::endl;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef PYCXX_DEBUG
|
||||
std::cout << " reinit - self->m_pycxx_object=0x" << std::hex << reinterpret_cast< unsigned int >( self->m_pycxx_object ) << std::dec << std::endl;
|
||||
#endif
|
||||
self->m_pycxx_object->reinit( args, kwds );
|
||||
}
|
||||
}
|
||||
catch( Exception & )
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void extension_object_deallocator( PyObject *_self )
|
||||
{
|
||||
PythonClassInstance *self = reinterpret_cast< PythonClassInstance * >( _self );
|
||||
#ifdef PYCXX_DEBUG
|
||||
std::cout << "extension_object_deallocator( self=0x" << std::hex << reinterpret_cast< unsigned int >( self ) << std::dec << " )" << std::endl;
|
||||
std::cout << " self->m_pycxx_object=0x" << std::hex << reinterpret_cast< unsigned int >( self->m_pycxx_object ) << std::dec << std::endl;
|
||||
#endif
|
||||
delete self->m_pycxx_object;
|
||||
_self->ob_type->tp_free( _self );
|
||||
}
|
||||
|
||||
public:
|
||||
static PyTypeObject *type_object()
|
||||
{
|
||||
return behaviors().type_object();
|
||||
}
|
||||
|
||||
static Object type()
|
||||
{
|
||||
return Object( reinterpret_cast<PyObject *>( behaviors().type_object() ) );
|
||||
}
|
||||
|
||||
static bool check( PyObject *p )
|
||||
{
|
||||
// is p like me?
|
||||
return p->ob_type == type_object();
|
||||
}
|
||||
|
||||
static bool check( const Object &ob )
|
||||
{
|
||||
return check( ob.ptr() );
|
||||
}
|
||||
|
||||
virtual PyObject *selfPtr()
|
||||
{
|
||||
return reinterpret_cast<PyObject *>( m_class_instance );
|
||||
}
|
||||
|
||||
virtual Object self()
|
||||
{
|
||||
return Object( reinterpret_cast<PyObject *>( m_class_instance ) );
|
||||
}
|
||||
|
||||
protected:
|
||||
private:
|
||||
PythonClassInstance *m_class_instance;
|
||||
|
||||
private:
|
||||
//
|
||||
// prevent the compiler generating these unwanted functions
|
||||
//
|
||||
explicit PythonClass( const PythonClass<T> &other );
|
||||
void operator=( const PythonClass<T> &rhs );
|
||||
};
|
||||
|
||||
//
|
||||
// ExtensionObject<T> is an Object that will accept only T's.
|
||||
//
|
||||
template<TEMPLATE_TYPENAME T>
|
||||
class PythonClassObject: public Object
|
||||
{
|
||||
public:
|
||||
|
||||
explicit PythonClassObject( PyObject *pyob )
|
||||
: Object( pyob )
|
||||
{
|
||||
validate();
|
||||
}
|
||||
|
||||
PythonClassObject( const PythonClassObject<T> &other )
|
||||
: Object( *other )
|
||||
{
|
||||
validate();
|
||||
}
|
||||
|
||||
PythonClassObject( const Object &other )
|
||||
: Object( *other )
|
||||
{
|
||||
validate();
|
||||
}
|
||||
|
||||
PythonClassObject &operator=( const Object &rhs )
|
||||
{
|
||||
*this = *rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
PythonClassObject &operator=( PyObject *rhsp )
|
||||
{
|
||||
if( ptr() != rhsp )
|
||||
set( rhsp );
|
||||
return *this;
|
||||
}
|
||||
|
||||
virtual bool accepts( PyObject *pyob ) const
|
||||
{
|
||||
return( pyob && T::check( pyob ) );
|
||||
}
|
||||
|
||||
//
|
||||
// Obtain a pointer to the PythonExtension object
|
||||
//
|
||||
T *getCxxObject( void )
|
||||
{
|
||||
return dynamic_cast< T * >( getPythonExtensionBase( ptr() ) );
|
||||
}
|
||||
};
|
||||
} // Namespace Py
|
||||
|
||||
// End of __CXX_ExtensionClass__h
|
||||
#endif
|
||||
177
src/CXX/Python2/ExtensionTypeBase.hxx
Normal file
177
src/CXX/Python2/ExtensionTypeBase.hxx
Normal file
@@ -0,0 +1,177 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __CXX_ExtensionTypeBase__h
|
||||
#define __CXX_ExtensionTypeBase__h
|
||||
|
||||
namespace Py
|
||||
{
|
||||
// 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 PYCXX_EXPORT PythonExtensionBase : public PyObject
|
||||
{
|
||||
public:
|
||||
PythonExtensionBase();
|
||||
virtual ~PythonExtensionBase();
|
||||
|
||||
public:
|
||||
// object
|
||||
virtual void reinit( Tuple &args, Dict &kwds );
|
||||
|
||||
// object basics
|
||||
#if defined( PYCXX_PYTHON_2TO3 ) || !defined( PY3 )
|
||||
virtual int print( FILE *, int );
|
||||
#endif
|
||||
virtual Object getattr( const char * );
|
||||
virtual int setattr( const char *, const Object & );
|
||||
virtual Object getattro( const String & );
|
||||
Object genericGetAttro( const String & );
|
||||
virtual int setattro( const String &, const Object & );
|
||||
int genericSetAttro( const String &, const Object & );
|
||||
virtual int compare( const Object & );
|
||||
virtual Object rich_compare( const Object &, int );
|
||||
virtual Object repr();
|
||||
virtual Object str();
|
||||
virtual long hash();
|
||||
virtual Object call( const Object &, const Object & );
|
||||
virtual Object iter();
|
||||
virtual PyObject *iternext();
|
||||
|
||||
// Sequence methods
|
||||
virtual int sequence_length();
|
||||
virtual Object sequence_concat( const Object & );
|
||||
virtual Object sequence_repeat( Py_ssize_t );
|
||||
virtual Object sequence_item( Py_ssize_t );
|
||||
virtual Object sequence_slice( Py_ssize_t, Py_ssize_t );
|
||||
virtual int sequence_ass_item( Py_ssize_t, const Object & );
|
||||
virtual int sequence_ass_slice( Py_ssize_t, Py_ssize_t, const Object & );
|
||||
|
||||
// Mapping
|
||||
virtual int mapping_length();
|
||||
virtual Object mapping_subscript( const Object & );
|
||||
virtual int mapping_ass_subscript( const Object &, const Object & );
|
||||
|
||||
// Number
|
||||
virtual int number_nonzero();
|
||||
virtual Object number_negative();
|
||||
virtual Object number_positive();
|
||||
virtual Object number_absolute();
|
||||
virtual Object number_invert();
|
||||
virtual Object number_int();
|
||||
virtual Object number_float();
|
||||
virtual Object number_long();
|
||||
virtual Object number_oct();
|
||||
virtual Object number_hex();
|
||||
virtual Object number_add( const Object & );
|
||||
virtual Object number_subtract( const Object & );
|
||||
virtual Object number_multiply( const Object & );
|
||||
virtual Object number_divide( const Object & );
|
||||
virtual Object number_remainder( const Object & );
|
||||
virtual Object number_divmod( const Object & );
|
||||
virtual Object number_lshift( const Object & );
|
||||
virtual Object number_rshift( const Object & );
|
||||
virtual Object number_and( const Object & );
|
||||
virtual Object number_xor( const Object & );
|
||||
virtual Object number_or( const Object & );
|
||||
virtual Object number_power( const Object &, const Object & );
|
||||
|
||||
// Buffer
|
||||
virtual Py_ssize_t buffer_getreadbuffer( Py_ssize_t, void** );
|
||||
virtual Py_ssize_t buffer_getwritebuffer( Py_ssize_t, void** );
|
||||
virtual Py_ssize_t buffer_getsegcount( Py_ssize_t* );
|
||||
|
||||
public:
|
||||
// helper functions to call function fn_name with 0 to 9 args
|
||||
Object callOnSelf( const std::string &fn_name );
|
||||
Object callOnSelf( const std::string &fn_name,
|
||||
const Object &arg1 );
|
||||
Object callOnSelf( const std::string &fn_name,
|
||||
const Object &arg1, const Object &arg2 );
|
||||
Object callOnSelf( const std::string &fn_name,
|
||||
const Object &arg1, const Object &arg2, const Object &arg3 );
|
||||
Object callOnSelf( const std::string &fn_name,
|
||||
const Object &arg1, const Object &arg2, const Object &arg3,
|
||||
const Object &arg4 );
|
||||
Object callOnSelf( const std::string &fn_name,
|
||||
const Object &arg1, const Object &arg2, const Object &arg3,
|
||||
const Object &arg4, const Object &arg5 );
|
||||
Object callOnSelf( const std::string &fn_name,
|
||||
const Object &arg1, const Object &arg2, const Object &arg3,
|
||||
const Object &arg4, const Object &arg5, const Object &arg6 );
|
||||
Object callOnSelf( const std::string &fn_name,
|
||||
const Object &arg1, const Object &arg2, const Object &arg3,
|
||||
const Object &arg4, const Object &arg5, const Object &arg6,
|
||||
const Object &arg7 );
|
||||
Object callOnSelf( const std::string &fn_name,
|
||||
const Object &arg1, const Object &arg2, const Object &arg3,
|
||||
const Object &arg4, const Object &arg5, const Object &arg6,
|
||||
const Object &arg7, const Object &arg8 );
|
||||
Object callOnSelf( const std::string &fn_name,
|
||||
const Object &arg1, const Object &arg2, const Object &arg3,
|
||||
const Object &arg4, const Object &arg5, const Object &arg6,
|
||||
const Object &arg7, const Object &arg8, const Object &arg9 );
|
||||
|
||||
public:
|
||||
virtual PyObject *selfPtr() = 0;
|
||||
virtual Object self() = 0;
|
||||
|
||||
private:
|
||||
void missing_method( void );
|
||||
static PyObject *method_call_handler( PyObject *self, PyObject *args );
|
||||
};
|
||||
|
||||
} // Namespace Py
|
||||
|
||||
// End of __CXX_ExtensionTypeBase__h
|
||||
#endif
|
||||
189
src/CXX/Python2/Extensions.hxx
Normal file
189
src/CXX/Python2/Extensions.hxx
Normal file
@@ -0,0 +1,189 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __CXX_Extensions__h
|
||||
#define __CXX_Extensions__h
|
||||
|
||||
|
||||
#ifdef _MSC_VER
|
||||
// disable warning C4786: symbol greater than 255 character,
|
||||
// okay to ignore
|
||||
#pragma warning( disable: 4786 )
|
||||
#endif
|
||||
|
||||
#include "CXX/WrapPython.h"
|
||||
#include "CXX/Version.hxx"
|
||||
#include "CXX/Python2/Config.hxx"
|
||||
#include "CXX/Python2/CxxDebug.hxx"
|
||||
#include "CXX/Python2/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 PYCXX_EXPORT ExtensionExceptionType : public Object
|
||||
{
|
||||
public:
|
||||
ExtensionExceptionType();
|
||||
virtual ~ExtensionExceptionType();
|
||||
|
||||
// call init to create the type
|
||||
void init( ExtensionModuleBase &module, const std::string &name, ExtensionExceptionType &parent );
|
||||
void init( ExtensionModuleBase &module, const std::string &name );
|
||||
};
|
||||
|
||||
class PYCXX_EXPORT 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
|
||||
|
||||
// Note: Python calls noargs as varargs buts args==NULL
|
||||
extern "C" typedef PyObject *(*method_noargs_call_handler_t)( PyObject *_self, PyObject * );
|
||||
extern "C" typedef PyObject *(*method_varargs_call_handler_t)( PyObject *_self, PyObject *_args );
|
||||
extern "C" 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_noargs_function_t)();
|
||||
typedef Object (T::*method_varargs_function_t)( const Tuple &args );
|
||||
typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws );
|
||||
|
||||
// NOARGS
|
||||
MethodDefExt
|
||||
(
|
||||
const char *_name,
|
||||
method_noargs_function_t _function,
|
||||
method_noargs_call_handler_t _handler,
|
||||
const char *_doc
|
||||
)
|
||||
{
|
||||
ext_meth_def.ml_name = const_cast<char *>( _name );
|
||||
ext_meth_def.ml_meth = reinterpret_cast<method_varargs_call_handler_t>( _handler );
|
||||
ext_meth_def.ml_flags = METH_NOARGS;
|
||||
ext_meth_def.ml_doc = const_cast<char *>( _doc );
|
||||
|
||||
ext_noargs_function = _function;
|
||||
ext_varargs_function = NULL;
|
||||
ext_keyword_function = NULL;
|
||||
}
|
||||
|
||||
// VARARGS
|
||||
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 = reinterpret_cast<method_varargs_call_handler_t>( _handler );
|
||||
ext_meth_def.ml_flags = METH_VARARGS;
|
||||
ext_meth_def.ml_doc = const_cast<char *>( _doc );
|
||||
|
||||
ext_noargs_function = NULL;
|
||||
ext_varargs_function = _function;
|
||||
ext_keyword_function = NULL;
|
||||
}
|
||||
|
||||
// VARARGS + KEYWORD
|
||||
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 = reinterpret_cast<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_noargs_function = NULL;
|
||||
ext_varargs_function = NULL;
|
||||
ext_keyword_function = _function;
|
||||
}
|
||||
|
||||
~MethodDefExt()
|
||||
{}
|
||||
|
||||
PyMethodDef ext_meth_def;
|
||||
method_noargs_function_t ext_noargs_function;
|
||||
method_varargs_function_t ext_varargs_function;
|
||||
method_keyword_function_t ext_keyword_function;
|
||||
Object py_method;
|
||||
};
|
||||
} // Namespace Py
|
||||
|
||||
#include "CXX/Python2/ExtensionModule.hxx"
|
||||
#include "CXX/Python2/PythonType.hxx"
|
||||
#include "CXX/Python2/ExtensionTypeBase.hxx"
|
||||
#include "CXX/Python2/ExtensionOldType.hxx"
|
||||
#include "CXX/Python2/ExtensionType.hxx"
|
||||
|
||||
// End of CXX_Extensions.h
|
||||
#endif
|
||||
597
src/CXX/Python2/IndirectPythonInterface.cxx
Normal file
597
src/CXX/Python2/IndirectPythonInterface.cxx
Normal file
@@ -0,0 +1,597 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "CXX/IndirectPythonInterface.hxx"
|
||||
|
||||
namespace Py
|
||||
{
|
||||
bool _Buffer_Check( PyObject *op ) { return (op)->ob_type == _Buffer_Type(); }
|
||||
bool _CFunction_Check( PyObject *op ) { return (op)->ob_type == _CFunction_Type(); }
|
||||
bool _Class_Check( PyObject *op ) { return (op)->ob_type == _Class_Type(); }
|
||||
bool _CObject_Check( PyObject *op ) { return (op)->ob_type == _CObject_Type(); }
|
||||
bool _Complex_Check( PyObject *op ) { return (op)->ob_type == _Complex_Type(); }
|
||||
bool _Dict_Check( PyObject *op ) { return (op)->ob_type == _Dict_Type(); }
|
||||
bool _File_Check( PyObject *op ) { return (op)->ob_type == _File_Type(); }
|
||||
bool _Float_Check( PyObject *op ) { return (op)->ob_type == _Float_Type(); }
|
||||
bool _Function_Check( PyObject *op ) { return (op)->ob_type == _Function_Type(); }
|
||||
bool _Instance_Check( PyObject *op ) { return (op)->ob_type == _Instance_Type(); }
|
||||
bool _Boolean_Check( PyObject *op ) { return (op)->ob_type == _Bool_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 PyObject *ptr__PyFalse = NULL;
|
||||
static PyObject *ptr__PyTrue = 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__PyFalse = GetPyObject_As_PyObjectPointer( "_Py_ZeroStruct" );
|
||||
ptr__PyTrue = GetPyObject_As_PyObjectPointer( "_Py_TrueStruct" );
|
||||
|
||||
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; }
|
||||
|
||||
PyObject * _False() { return ptr__PyFalse; }
|
||||
PyObject * _True() { return ptr__PyTrue; }
|
||||
|
||||
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 * _Bool_Type() { return ptr__Bool_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; }
|
||||
|
||||
PyObject * _False() { return Py_False; }
|
||||
PyObject * _True() { return Py_True; }
|
||||
|
||||
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 * _Bool_Type() { return &PyBool_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
|
||||
}
|
||||
199
src/CXX/Python2/IndirectPythonInterface.hxx
Normal file
199
src/CXX/Python2/IndirectPythonInterface.hxx
Normal file
@@ -0,0 +1,199 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __CXX_INDIRECT_PYTHON_INTERFACE__HXX__
|
||||
#define __CXX_INDIRECT_PYTHON_INTERFACE__HXX__
|
||||
|
||||
#include "CXX/WrapPython.h"
|
||||
#include "CXX/Config.hxx"
|
||||
|
||||
namespace Py
|
||||
{
|
||||
bool InitialisePythonIndirectInterface();
|
||||
|
||||
//
|
||||
// Wrap Exception variables as function calls
|
||||
//
|
||||
PYCXX_EXPORT PyObject * _Exc_Exception();
|
||||
PYCXX_EXPORT PyObject * _Exc_StandardError();
|
||||
PYCXX_EXPORT PyObject * _Exc_ArithmeticError();
|
||||
PYCXX_EXPORT PyObject * _Exc_LookupError();
|
||||
|
||||
PYCXX_EXPORT PyObject * _Exc_AssertionError();
|
||||
PYCXX_EXPORT PyObject * _Exc_AttributeError();
|
||||
PYCXX_EXPORT PyObject * _Exc_EOFError();
|
||||
PYCXX_EXPORT PyObject * _Exc_FloatingPointError();
|
||||
PYCXX_EXPORT PyObject * _Exc_EnvironmentError();
|
||||
PYCXX_EXPORT PyObject * _Exc_IOError();
|
||||
PYCXX_EXPORT PyObject * _Exc_OSError();
|
||||
PYCXX_EXPORT PyObject * _Exc_ImportError();
|
||||
PYCXX_EXPORT PyObject * _Exc_IndexError();
|
||||
PYCXX_EXPORT PyObject * _Exc_KeyError();
|
||||
PYCXX_EXPORT PyObject * _Exc_KeyboardInterrupt();
|
||||
PYCXX_EXPORT PyObject * _Exc_MemoryError();
|
||||
PYCXX_EXPORT PyObject * _Exc_NameError();
|
||||
PYCXX_EXPORT PyObject * _Exc_OverflowError();
|
||||
PYCXX_EXPORT PyObject * _Exc_RuntimeError();
|
||||
PYCXX_EXPORT PyObject * _Exc_NotImplementedError();
|
||||
PYCXX_EXPORT PyObject * _Exc_SyntaxError();
|
||||
PYCXX_EXPORT PyObject * _Exc_SystemError();
|
||||
PYCXX_EXPORT PyObject * _Exc_SystemExit();
|
||||
PYCXX_EXPORT PyObject * _Exc_TypeError();
|
||||
PYCXX_EXPORT PyObject * _Exc_ValueError();
|
||||
PYCXX_EXPORT PyObject * _Exc_ZeroDivisionError();
|
||||
#ifdef MS_WINDOWS
|
||||
PYCXX_EXPORT PyObject * _Exc_WindowsError();
|
||||
#endif
|
||||
|
||||
PYCXX_EXPORT PyObject * _Exc_MemoryErrorInst();
|
||||
|
||||
#if PY_MAJOR_VERSION >= 2
|
||||
PYCXX_EXPORT PyObject * _Exc_IndentationError();
|
||||
PYCXX_EXPORT PyObject * _Exc_TabError();
|
||||
PYCXX_EXPORT PyObject * _Exc_UnboundLocalError();
|
||||
PYCXX_EXPORT PyObject * _Exc_UnicodeError();
|
||||
#endif
|
||||
|
||||
//
|
||||
// Wrap Object variables as function calls
|
||||
//
|
||||
PYCXX_EXPORT PyObject * _None();
|
||||
|
||||
PYCXX_EXPORT PyObject * _False();
|
||||
PYCXX_EXPORT PyObject * _True();
|
||||
|
||||
//
|
||||
// Wrap Type variables as function calls
|
||||
//
|
||||
PYCXX_EXPORT PyTypeObject * _List_Type();
|
||||
PYCXX_EXPORT bool _List_Check( PyObject *o );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Buffer_Type();
|
||||
PYCXX_EXPORT bool _Buffer_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Class_Type();
|
||||
PYCXX_EXPORT bool _Class_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Instance_Type();
|
||||
PYCXX_EXPORT bool _Instance_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Method_Type();
|
||||
PYCXX_EXPORT bool _Method_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _CObject_Type();
|
||||
PYCXX_EXPORT bool _CObject_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Complex_Type();
|
||||
PYCXX_EXPORT bool _Complex_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Dict_Type();
|
||||
PYCXX_EXPORT bool _Dict_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _File_Type();
|
||||
PYCXX_EXPORT bool _File_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Float_Type();
|
||||
PYCXX_EXPORT bool _Float_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Frame_Type();
|
||||
PYCXX_EXPORT bool _Frame_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Function_Type();
|
||||
PYCXX_EXPORT bool _Function_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Bool_Type();
|
||||
PYCXX_EXPORT bool _Boolean_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Int_Type();
|
||||
PYCXX_EXPORT bool _Int_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _List_Type();
|
||||
PYCXX_EXPORT bool _List_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Long_Type();
|
||||
PYCXX_EXPORT bool _Long_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _CFunction_Type();
|
||||
PYCXX_EXPORT bool _CFunction_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Module_Type();
|
||||
PYCXX_EXPORT bool _Module_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Type_Type();
|
||||
PYCXX_EXPORT bool _Type_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Range_Type();
|
||||
PYCXX_EXPORT bool _Range_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Slice_Type();
|
||||
PYCXX_EXPORT bool _Slice_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _String_Type();
|
||||
PYCXX_EXPORT bool _String_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Unicode_Type();
|
||||
PYCXX_EXPORT bool _Unicode_Check( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _TraceBack_Type();
|
||||
PYCXX_EXPORT bool _TraceBack_Check( PyObject *v );
|
||||
|
||||
PYCXX_EXPORT PyTypeObject * _Tuple_Type();
|
||||
PYCXX_EXPORT bool _Tuple_Check( PyObject *op );
|
||||
|
||||
#if PY_MAJOR_VERSION >= 2
|
||||
PYCXX_EXPORT PyTypeObject * _Unicode_Type();
|
||||
PYCXX_EXPORT bool _Unicode_Check( PyObject *op );
|
||||
#endif
|
||||
|
||||
PYCXX_EXPORT int &_Py_DebugFlag();
|
||||
PYCXX_EXPORT int &_Py_InteractiveFlag();
|
||||
PYCXX_EXPORT int &_Py_OptimizeFlag();
|
||||
PYCXX_EXPORT int &_Py_NoSiteFlag();
|
||||
PYCXX_EXPORT int &_Py_TabcheckFlag();
|
||||
PYCXX_EXPORT int &_Py_VerboseFlag();
|
||||
|
||||
#if PY_MAJOR_VERSION >= 2
|
||||
PYCXX_EXPORT int &_Py_UnicodeFlag();
|
||||
#endif
|
||||
|
||||
PYCXX_EXPORT void _XINCREF( PyObject *op );
|
||||
PYCXX_EXPORT void _XDECREF( PyObject *op );
|
||||
|
||||
PYCXX_EXPORT char *__Py_PackageContext();
|
||||
}
|
||||
|
||||
#endif // __CXX_INDIRECT_PYTHON_INTERFACE__HXX__
|
||||
3486
src/CXX/Python2/Objects.hxx
Normal file
3486
src/CXX/Python2/Objects.hxx
Normal file
File diff suppressed because it is too large
Load Diff
117
src/CXX/Python2/PythonType.hxx
Normal file
117
src/CXX/Python2/PythonType.hxx
Normal file
@@ -0,0 +1,117 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __CXX_PythonType__h
|
||||
#define __CXX_PythonType__h
|
||||
|
||||
namespace Py
|
||||
{
|
||||
class PYCXX_EXPORT PythonType
|
||||
{
|
||||
public:
|
||||
// if you define one sequence method you must define
|
||||
// all of them except the assigns
|
||||
|
||||
PythonType( size_t base_size, int itemsize, const char *default_name );
|
||||
virtual ~PythonType();
|
||||
|
||||
const char *getName() const;
|
||||
const char *getDoc() const;
|
||||
|
||||
PyTypeObject *type_object() const;
|
||||
PythonType &name( const char *nam );
|
||||
PythonType &doc( const char *d );
|
||||
|
||||
PythonType &supportClass( void );
|
||||
#if !defined( PY3 )
|
||||
PythonType &dealloc( void (*f)( PyObject* ) );
|
||||
#endif
|
||||
#if defined( PYCXX_PYTHON_2TO3 ) || !defined( PY3 )
|
||||
PythonType &supportPrint( void );
|
||||
#endif
|
||||
PythonType &supportGetattr( void );
|
||||
PythonType &supportSetattr( void );
|
||||
PythonType &supportGetattro( void );
|
||||
PythonType &supportSetattro( void );
|
||||
#if defined( PYCXX_PYTHON_2TO3 ) || !defined( PY3 )
|
||||
PythonType &supportCompare( void );
|
||||
#endif
|
||||
PythonType &supportRichCompare( void );
|
||||
PythonType &supportRepr( void );
|
||||
PythonType &supportStr( void );
|
||||
PythonType &supportHash( void );
|
||||
PythonType &supportCall( void );
|
||||
PythonType &supportIter( void );
|
||||
|
||||
PythonType &supportSequenceType( void );
|
||||
PythonType &supportMappingType( void );
|
||||
PythonType &supportNumberType( void );
|
||||
PythonType &supportBufferType( void );
|
||||
|
||||
PythonType &set_tp_dealloc( void (*tp_dealloc)( PyObject * ) );
|
||||
PythonType &set_tp_init( int (*tp_init)( PyObject *self, PyObject *args, PyObject *kwds ) );
|
||||
PythonType &set_tp_new( PyObject *(*tp_new)( PyTypeObject *subtype, PyObject *args, PyObject *kwds ) );
|
||||
PythonType &set_methods( PyMethodDef *methods );
|
||||
|
||||
// call once all support functions have been called to ready the type
|
||||
bool readyType();
|
||||
|
||||
protected:
|
||||
void init_sequence();
|
||||
void init_mapping();
|
||||
void init_number();
|
||||
void init_buffer();
|
||||
|
||||
PyTypeObject *table;
|
||||
PySequenceMethods *sequence_table;
|
||||
PyMappingMethods *mapping_table;
|
||||
PyNumberMethods *number_table;
|
||||
PyBufferProcs *buffer_table;
|
||||
|
||||
private:
|
||||
//
|
||||
// prevent the compiler generating these unwanted functions
|
||||
//
|
||||
PythonType( const PythonType &tb ); // unimplemented
|
||||
void operator=( const PythonType &t ); // unimplemented
|
||||
|
||||
};
|
||||
|
||||
} // Namespace Py
|
||||
|
||||
// End of __CXX_PythonType__h
|
||||
#endif
|
||||
1903
src/CXX/Python2/cxx_extensions.cxx
Normal file
1903
src/CXX/Python2/cxx_extensions.cxx
Normal file
File diff suppressed because it is too large
Load Diff
49
src/CXX/Python2/cxxextensions.c
Normal file
49
src/CXX/Python2/cxxextensions.c
Normal file
@@ -0,0 +1,49 @@
|
||||
/*----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//---------------------------------------------------------------------------*/
|
||||
|
||||
#include "CXX/WrapPython.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
PyObject py_object_initializer = {PyObject_HEAD_INIT(0)};
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
174
src/CXX/Python2/cxxsupport.cxx
Normal file
174
src/CXX/Python2/cxxsupport.cxx
Normal file
@@ -0,0 +1,174 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 1998 - 2007, The Regents of the University of California
|
||||
// Produced at the Lawrence Livermore National Laboratory
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
|
||||
// full copyright notice is contained in the file COPYRIGHT located at the root
|
||||
// of the PyCXX distribution.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the disclaimer below.
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the disclaimer (as noted below) in the
|
||||
// documentation and/or materials provided with the distribution.
|
||||
// - Neither the name of the UC/LLNL nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
|
||||
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
// DAMAGE.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "CXX/Objects.hxx"
|
||||
namespace Py {
|
||||
|
||||
Py_UNICODE unicode_null_string[1] = { 0 };
|
||||
|
||||
Type Object::type () const
|
||||
{
|
||||
return Type (PyObject_Type (p), true);
|
||||
}
|
||||
|
||||
String Object::str () const
|
||||
{
|
||||
return String (PyObject_Str (p), true);
|
||||
}
|
||||
|
||||
String Object::repr () const
|
||||
{
|
||||
return String (PyObject_Repr (p), true);
|
||||
}
|
||||
|
||||
std::string Object::as_string() const
|
||||
{
|
||||
return static_cast<std::string>(str());
|
||||
}
|
||||
|
||||
List Object::dir () const
|
||||
{
|
||||
return List (PyObject_Dir (p), true);
|
||||
}
|
||||
|
||||
bool Object::isType (const Type& t) const
|
||||
{
|
||||
return type ().ptr() == t.ptr();
|
||||
}
|
||||
|
||||
Char::operator String() const
|
||||
{
|
||||
return String(ptr());
|
||||
}
|
||||
|
||||
// TMM: non-member operaters for iterators - see above
|
||||
// I've also made a bug fix in respect to the cxx code
|
||||
// (dereffed the left.seq and right.seq comparison)
|
||||
bool operator==(const Sequence::iterator& left, const Sequence::iterator& right)
|
||||
{
|
||||
return left.eql( right );
|
||||
}
|
||||
|
||||
bool operator!=(const Sequence::iterator& left, const Sequence::iterator& right)
|
||||
{
|
||||
return left.neq( right );
|
||||
}
|
||||
|
||||
bool operator< (const Sequence::iterator& left, const Sequence::iterator& right)
|
||||
{
|
||||
return left.lss( right );
|
||||
}
|
||||
|
||||
bool operator> (const Sequence::iterator& left, const Sequence::iterator& right)
|
||||
{
|
||||
return left.gtr( right );
|
||||
}
|
||||
|
||||
bool operator<=(const Sequence::iterator& left, const Sequence::iterator& right)
|
||||
{
|
||||
return left.leq( right );
|
||||
}
|
||||
|
||||
bool operator>=(const Sequence::iterator& left, const Sequence::iterator& right)
|
||||
{
|
||||
return left.geq( right );
|
||||
}
|
||||
|
||||
// now for const_iterator
|
||||
bool operator==(const Sequence::const_iterator& left, const Sequence::const_iterator& right)
|
||||
{
|
||||
return left.eql( right );
|
||||
}
|
||||
|
||||
bool operator!=(const Sequence::const_iterator& left, const Sequence::const_iterator& right)
|
||||
{
|
||||
return left.neq( right );
|
||||
}
|
||||
|
||||
bool operator< (const Sequence::const_iterator& left, const Sequence::const_iterator& right)
|
||||
{
|
||||
return left.lss( right );
|
||||
}
|
||||
|
||||
bool operator> (const Sequence::const_iterator& left, const Sequence::const_iterator& right)
|
||||
{
|
||||
return left.gtr( right );
|
||||
}
|
||||
|
||||
bool operator<=(const Sequence::const_iterator& left, const Sequence::const_iterator& right)
|
||||
{
|
||||
return left.leq( right );
|
||||
}
|
||||
|
||||
bool operator>=(const Sequence::const_iterator& left, const Sequence::const_iterator& right)
|
||||
{
|
||||
return left.geq( right );
|
||||
}
|
||||
|
||||
// For mappings:
|
||||
bool operator==(const Mapping::iterator& left, const Mapping::iterator& right)
|
||||
{
|
||||
return left.eql( right );
|
||||
}
|
||||
|
||||
bool operator!=(const Mapping::iterator& left, const Mapping::iterator& right)
|
||||
{
|
||||
return left.neq( right );
|
||||
}
|
||||
|
||||
// now for const_iterator
|
||||
bool operator==(const Mapping::const_iterator& left, const Mapping::const_iterator& right)
|
||||
{
|
||||
return left.eql( right );
|
||||
}
|
||||
|
||||
bool operator!=(const Mapping::const_iterator& left, const Mapping::const_iterator& right)
|
||||
{
|
||||
return left.neq( right );
|
||||
}
|
||||
|
||||
// TMM: 31May'01 - Added the #ifndef so I can exclude iostreams.
|
||||
#ifndef CXX_NO_IOSTREAMS
|
||||
// output
|
||||
|
||||
std::ostream& operator<< (std::ostream& os, const Object& ob)
|
||||
{
|
||||
return (os << static_cast<std::string>(ob.str()));
|
||||
}
|
||||
#endif
|
||||
|
||||
} // Py
|
||||
Reference in New Issue
Block a user