external_libraries/pycxx-6.2.2/Src/Python3/cxx_extensions.cxx

   1 //-----------------------------------------------------------------------------
   2 //
   3 // Copyright (c) 1998 - 2007, The Regents of the University of California
   4 // Produced at the Lawrence Livermore National Laboratory
   5 // All rights reserved.
   6 //
   7 // This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
   8 // full copyright notice is contained in the file COPYRIGHT located at the root
   9 // of the PyCXX distribution.
  10 //
  11 // Redistribution  and  use  in  source  and  binary  forms,  with  or  without
  12 // modification, are permitted provided that the following conditions are met:
  13 //
  14 //  - Redistributions of  source code must  retain the above  copyright notice,
  15 //    this list of conditions and the disclaimer below.
  16 //  - Redistributions in binary form must reproduce the above copyright notice,
  17 //    this  list of  conditions  and  the  disclaimer (as noted below)  in  the
  18 //    documentation and/or materials provided with the distribution.
  19 //  - Neither the name of the UC/LLNL nor  the names of its contributors may be
  20 //    used to  endorse or  promote products derived from  this software without
  21 //    specific prior written permission.
  22 //
  23 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT  HOLDERS AND CONTRIBUTORS "AS IS"
  24 // AND ANY EXPRESS OR  IMPLIED WARRANTIES, INCLUDING,  BUT NOT  LIMITED TO, THE
  25 // IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS FOR A PARTICULAR  PURPOSE
  26 // ARE  DISCLAIMED.  IN  NO  EVENT  SHALL  THE  REGENTS  OF  THE  UNIVERSITY OF
  27 // CALIFORNIA, THE U.S.  DEPARTMENT  OF  ENERGY OR CONTRIBUTORS BE  LIABLE  FOR
  28 // ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR CONSEQUENTIAL
  29 // DAMAGES (INCLUDING, BUT NOT  LIMITED TO, PROCUREMENT OF  SUBSTITUTE GOODS OR
  30 // SERVICES; LOSS OF  USE, DATA, OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER
  31 // CAUSED  AND  ON  ANY  THEORY  OF  LIABILITY,  WHETHER  IN  CONTRACT,  STRICT
  32 // LIABILITY, OR TORT  (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING IN ANY  WAY
  33 // OUT OF THE  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  34 // DAMAGE.
  35 //
  36 //-----------------------------------------------------------------------------
  37 #include "CXX/Extensions.hxx"
  38 #include "CXX/Exception.hxx"
  39
  40 #include <assert.h>
  41
  42 #ifdef PYCXX_DEBUG
  43 //
  44 //  Functions useful when debugging PyCXX
  45 //
  46 void bpt( void )
  47 {
  48 }
  49
  50 void printRefCount( PyObject *obj )
  51 {
  52     std::cout << "RefCount of 0x" << std::hex << reinterpret_cast< unsigned int >( obj ) << std::dec << " is " << Py_REFCNT( obj ) << std::endl;
  53 }
  54 #endif
  55
  56 namespace Py
  57 {
  58
  59 void Object::validate()
  60 {
  61     // release pointer if not the right type
  62     if( !accepts( p ) )
  63     {
  64 #if defined( _CPPRTTI ) || defined( __GNUG__ )
  65         std::string s( "PyCXX: Error creating object of type " );
  66         s += (typeid( *this )).name();
  67
  68         if( p != NULL )
  69         {
  70             String from_repr = repr();
  71             s += " from ";
  72             s += from_repr.as_std_string();
  73         }
  74         else
  75         {
  76             s += " from (nil)";
  77         }
  78 #endif
  79         release();
  80         if( PyErr_Occurred() )
  81         { // Error message already set
  82             throw Exception();
  83         }
  84         // Better error message if RTTI available
  85 #if defined( _CPPRTTI ) || defined( __GNUG__ )
  86         throw TypeError( s );
  87 #else
  88         throw TypeError( "PyCXX: type error." );
  89 #endif
  90     }
  91 }
  92
  93 //================================================================================
  94 //
  95 //    Implementation of MethodTable
  96 //
  97 //================================================================================
  98
  99 PyMethodDef MethodTable::method( const char *method_name, PyCFunction f, int flags, const char *doc )
 100 {
 101     PyMethodDef m;
 102     m.ml_name = const_cast<char *>( method_name );
 103     m.ml_meth = f;
 104     m.ml_flags = flags;
 105     m.ml_doc = const_cast<char *>( doc );
 106     return m;
 107 }
 108
 109 MethodTable::MethodTable()
 110 {
 111     t.push_back( method( 0, 0, 0, 0 ) );
 112     mt = NULL;
 113 }
 114
 115 MethodTable::~MethodTable()
 116 {
 117     delete [] mt;
 118 }
 119
 120 void MethodTable::add( const char *method_name, PyCFunction f, const char *doc, int flag )
 121 {
 122     if( !mt )
 123     {
 124         t.insert( t.end()-1, method( method_name, f, flag, doc ) );
 125     }
 126     else
 127     {
 128         throw RuntimeError( "Too late to add a module method!" );
 129     }
 130 }
 131
 132 PyMethodDef *MethodTable::table()
 133 {
 134     if( !mt )
 135     {
 136         Py_ssize_t t1size = t.size();
 137         mt = new PyMethodDef[ t1size ];
 138         int j = 0;
 139         for( std::vector<PyMethodDef>::iterator i = t.begin(); i != t.end(); i++ )
 140         {
 141             mt[ j++ ] = *i;
 142         }
 143     }
 144     return mt;
 145 }
 146
 147 //================================================================================
 148 //
 149 //    Implementation of ExtensionModule
 150 //
 151 //================================================================================
 152 ExtensionModuleBase::ExtensionModuleBase( const char *name )
 153 : m_module_name( name )
 154 , m_full_module_name( __Py_PackageContext() != NULL ? std::string( __Py_PackageContext() ) : m_module_name )
 155 , m_method_table()
 156 //m_module_def
 157 , m_module( NULL )
 158 {}
 159
 160 ExtensionModuleBase::~ExtensionModuleBase()
 161 {}
 162
 163 const std::string &ExtensionModuleBase::name() const
 164 {
 165     return m_module_name;
 166 }
 167
 168 const std::string &ExtensionModuleBase::fullName() const
 169 {
 170     return m_full_module_name;
 171 }
 172
 173 class ExtensionModuleBasePtr : public PythonExtension<ExtensionModuleBasePtr>
 174 {
 175 public:
 176     ExtensionModuleBasePtr( ExtensionModuleBase *_module )
 177     : module( _module )
 178     {}
 179
 180     virtual ~ExtensionModuleBasePtr()
 181     {}
 182
 183     ExtensionModuleBase *module;
 184 };
 185
 186 void ExtensionModuleBase::initialize( const char *module_doc )
 187 {
 188     memset( &m_module_def, 0, sizeof( m_module_def ) );
 189
 190     m_module_def.m_name = const_cast<char *>( m_module_name.c_str() );
 191     m_module_def.m_doc = const_cast<char *>( module_doc );
 192     m_module_def.m_methods = m_method_table.table();
 193     // where does module_ptr get passed in?
 194
 195     m_module = PyModule_Create( &m_module_def );
 196 }
 197
 198 Py::Module ExtensionModuleBase::module( void ) const
 199 {
 200     return Module( m_module );
 201 }
 202
 203 Py::Dict ExtensionModuleBase::moduleDictionary( void ) const
 204 {
 205     return module().getDict();
 206 }
 207
 208 //================================================================================
 209 //
 210 //    Implementation of PythonType
 211 //
 212 //================================================================================
 213 extern "C"
 214 {
 215     static void standard_dealloc( PyObject *p );
 216     //
 217     // All the following functions redirect the call from Python
 218     // onto the matching virtual function in PythonExtensionBase
 219     //
 220     static int print_handler( PyObject *, FILE *, int );
 221     static PyObject *getattr_handler( PyObject *, char * );
 222     static int setattr_handler( PyObject *, char *, PyObject * );
 223     static PyObject *getattro_handler( PyObject *, PyObject * );
 224     static int setattro_handler( PyObject *, PyObject *, PyObject * );
 225     static PyObject *rich_compare_handler( PyObject *, PyObject *, int );
 226     static PyObject *repr_handler( PyObject * );
 227     static PyObject *str_handler( PyObject * );
 228     static long hash_handler( PyObject * );
 229     static PyObject *call_handler( PyObject *, PyObject *, PyObject * );
 230     static PyObject *iter_handler( PyObject * );
 231     static PyObject *iternext_handler( PyObject * );
 232
 233     // Sequence methods
 234     static Py_ssize_t sequence_length_handler( PyObject * );
 235     static PyObject *sequence_concat_handler( PyObject *,PyObject * );
 236     static PyObject *sequence_repeat_handler( PyObject *, Py_ssize_t );
 237     static PyObject *sequence_item_handler( PyObject *, Py_ssize_t );
 238     static int sequence_ass_item_handler( PyObject *, Py_ssize_t, PyObject * );
 239
 240     // Mapping
 241     static Py_ssize_t mapping_length_handler( PyObject * );
 242     static PyObject *mapping_subscript_handler( PyObject *, PyObject * );
 243     static int mapping_ass_subscript_handler( PyObject *, PyObject *, PyObject * );
 244
 245     // Numeric methods
 246     static PyObject *number_negative_handler( PyObject * );
 247     static PyObject *number_positive_handler( PyObject * );
 248     static PyObject *number_absolute_handler( PyObject * );
 249     static PyObject *number_invert_handler( PyObject * );
 250     static PyObject *number_int_handler( PyObject * );
 251     static PyObject *number_float_handler( PyObject * );
 252     static PyObject *number_add_handler( PyObject *, PyObject * );
 253     static PyObject *number_subtract_handler( PyObject *, PyObject * );
 254     static PyObject *number_multiply_handler( PyObject *, PyObject * );
 255     static PyObject *number_remainder_handler( PyObject *, PyObject * );
 256     static PyObject *number_divmod_handler( PyObject *, PyObject * );
 257     static PyObject *number_lshift_handler( PyObject *, PyObject * );
 258     static PyObject *number_rshift_handler( PyObject *, PyObject * );
 259     static PyObject *number_and_handler( PyObject *, PyObject * );
 260     static PyObject *number_xor_handler( PyObject *, PyObject * );
 261     static PyObject *number_or_handler( PyObject *, PyObject * );
 262     static PyObject *number_power_handler( PyObject *, PyObject *, PyObject * );
 263
 264     // Buffer
 265     // QQQ
 266 }
 267
 268 extern "C" void standard_dealloc( PyObject *p )
 269 {
 270     PyMem_DEL( p );
 271 }
 272
 273 bool PythonType::readyType()
 274 {
 275     return PyType_Ready( table ) >= 0;
 276 }
 277
 278 PythonType &PythonType::supportSequenceType()
 279 {
 280     if( !sequence_table )
 281     {
 282         sequence_table = new PySequenceMethods;
 283         memset( sequence_table, 0, sizeof( PySequenceMethods ) );   // ensure new fields are 0
 284         table->tp_as_sequence = sequence_table;
 285         sequence_table->sq_length = sequence_length_handler;
 286         sequence_table->sq_concat = sequence_concat_handler;
 287         sequence_table->sq_repeat = sequence_repeat_handler;
 288         sequence_table->sq_item = sequence_item_handler;
 289
 290         sequence_table->sq_ass_item = sequence_ass_item_handler;    // BAS setup seperately?
 291         // QQQ sq_inplace_concat
 292         // QQQ sq_inplace_repeat
 293     }
 294     return *this;
 295 }
 296
 297 PythonType &PythonType::supportMappingType()
 298 {
 299     if( !mapping_table )
 300     {
 301         mapping_table = new PyMappingMethods;
 302         memset( mapping_table, 0, sizeof( PyMappingMethods ) );   // ensure new fields are 0
 303         table->tp_as_mapping = mapping_table;
 304         mapping_table->mp_length = mapping_length_handler;
 305         mapping_table->mp_subscript = mapping_subscript_handler;
 306         mapping_table->mp_ass_subscript = mapping_ass_subscript_handler;    // BAS setup seperately?
 307     }
 308     return *this;
 309 }
 310
 311 PythonType &PythonType::supportNumberType()
 312 {
 313     if( !number_table )
 314     {
 315         number_table = new PyNumberMethods;
 316         memset( number_table, 0, sizeof( PyNumberMethods ) );   // ensure new fields are 0
 317         table->tp_as_number = number_table;
 318         number_table->nb_add = number_add_handler;
 319         number_table->nb_subtract = number_subtract_handler;
 320         number_table->nb_multiply = number_multiply_handler;
 321         number_table->nb_remainder = number_remainder_handler;
 322         number_table->nb_divmod = number_divmod_handler;
 323         number_table->nb_power = number_power_handler;
 324         number_table->nb_negative = number_negative_handler;
 325         number_table->nb_positive = number_positive_handler;
 326         number_table->nb_absolute = number_absolute_handler;
 327         number_table->nb_invert = number_invert_handler;
 328         number_table->nb_lshift = number_lshift_handler;
 329         number_table->nb_rshift = number_rshift_handler;
 330         number_table->nb_and = number_and_handler;
 331         number_table->nb_xor = number_xor_handler;
 332         number_table->nb_or = number_or_handler;
 333         number_table->nb_int = number_int_handler;
 334         number_table->nb_float = number_float_handler;
 335
 336         // QQQ lots of new methods to add
 337     }
 338     return *this;
 339 }
 340
 341 PythonType &PythonType::supportBufferType()
 342 {
 343     if( !buffer_table )
 344     {
 345         buffer_table = new PyBufferProcs;
 346         memset( buffer_table, 0, sizeof( PyBufferProcs ) );   // ensure new fields are 0
 347         table->tp_as_buffer = buffer_table;
 348         // QQQ bf_getbuffer
 349         // QQQ bf_releasebuffer
 350     }
 351     return *this;
 352 }
 353
 354 // if you define one sequence method you must define
 355 // all of them except the assigns
 356
 357 PythonType::PythonType( size_t basic_size, int itemsize, const char *default_name )
 358 : table( new PyTypeObject )
 359 , sequence_table( NULL )
 360 , mapping_table( NULL )
 361 , number_table( NULL )
 362 , buffer_table( NULL )
 363 {
 364     // PyTypeObject is defined in <python-sources>/Include/object.h
 365
 366     memset( table, 0, sizeof( PyTypeObject ) );   // ensure new fields are 0
 367     *reinterpret_cast<PyObject *>( table ) = py_object_initializer;
 368     // QQQ table->ob_type = _Type_Type();
 369     // QQQ table->ob_size = 0;
 370     table->tp_name = const_cast<char *>( default_name );
 371     table->tp_basicsize = basic_size;
 372     table->tp_itemsize = itemsize;
 373
 374     // Methods to implement standard operations
 375     table->tp_dealloc = (destructor)standard_dealloc;
 376     table->tp_print = 0;
 377     table->tp_getattr = 0;
 378     table->tp_setattr = 0;
 379     table->tp_repr = 0;
 380
 381     // Method suites for standard classes
 382     table->tp_as_number = 0;
 383     table->tp_as_sequence = 0;
 384     table->tp_as_mapping =  0;
 385
 386     // More standard operations (here for binary compatibility)
 387     table->tp_hash = 0;
 388     table->tp_call = 0;
 389     table->tp_str = 0;
 390     table->tp_getattro = 0;
 391     table->tp_setattro = 0;
 392
 393     // Functions to access object as input/output buffer
 394     table->tp_as_buffer = 0;
 395
 396     // Flags to define presence of optional/expanded features
 397     table->tp_flags = Py_TPFLAGS_DEFAULT;
 398
 399     // Documentation string
 400     table->tp_doc = 0;
 401
 402     table->tp_traverse = 0;
 403
 404     // delete references to contained objects
 405     table->tp_clear = 0;
 406
 407     // Assigned meaning in release 2.1
 408     // rich comparisons
 409     table->tp_richcompare = 0;
 410     // weak reference enabler
 411     table->tp_weaklistoffset = 0;
 412
 413     // Iterators
 414     table->tp_iter = 0;
 415     table->tp_iternext = 0;
 416
 417     // Attribute descriptor and subclassing stuff
 418     table->tp_methods = 0;
 419     table->tp_members = 0;
 420     table->tp_getset = 0;
 421     table->tp_base = 0;
 422     table->tp_dict = 0;
 423     table->tp_descr_get = 0;
 424     table->tp_descr_set = 0;
 425     table->tp_dictoffset = 0;
 426     table->tp_init = 0;
 427     table->tp_alloc = 0;
 428     table->tp_new = 0;
 429     table->tp_free = 0;     // Low-level free-memory routine
 430     table->tp_is_gc = 0;    // For PyObject_IS_GC
 431     table->tp_bases = 0;
 432     table->tp_mro = 0;      // method resolution order
 433     table->tp_cache = 0;
 434     table->tp_subclasses = 0;
 435     table->tp_weaklist = 0;
 436     table->tp_del = 0;
 437
 438     // Type attribute cache version tag. Added in version 2.6
 439     table->tp_version_tag = 0;
 440
 441 #ifdef COUNT_ALLOCS
 442     table->tp_alloc = 0;
 443     table->tp_free = 0;
 444     table->tp_maxalloc = 0;
 445     table->tp_orev = 0;
 446     table->tp_next = 0;
 447 #endif
 448 }
 449
 450 PythonType::~PythonType()
 451 {
 452     delete table;
 453     delete sequence_table;
 454     delete mapping_table;
 455     delete number_table;
 456     delete buffer_table;
 457 }
 458
 459 PyTypeObject *PythonType::type_object() const
 460 {
 461     return table;
 462 }
 463
 464 PythonType &PythonType::name( const char *nam )
 465 {
 466     table->tp_name = const_cast<char *>( nam );
 467     return *this;
 468 }
 469
 470 const char *PythonType::getName() const
 471 {
 472     return table->tp_name;
 473 }
 474
 475 PythonType &PythonType::doc( const char *d )
 476 {
 477     table->tp_doc = const_cast<char *>( d );
 478     return *this;
 479 }
 480
 481 const char *PythonType::getDoc() const
 482 {
 483     return table->tp_doc;
 484 }
 485
 486 PythonType &PythonType::set_tp_dealloc( void (*tp_dealloc)( PyObject *self ) )
 487 {
 488     table->tp_dealloc = tp_dealloc;
 489     return *this;
 490 }
 491
 492 PythonType &PythonType::set_tp_init( int (*tp_init)( PyObject *self, PyObject *args, PyObject *kwds ) )
 493 {
 494     table->tp_init = tp_init;
 495     return *this;
 496 }
 497
 498 PythonType &PythonType::set_tp_new( PyObject *(*tp_new)( PyTypeObject *subtype, PyObject *args, PyObject *kwds ) )
 499 {
 500     table->tp_new = tp_new;
 501     return *this;
 502 }
 503
 504 PythonType &PythonType::set_methods( PyMethodDef *methods )
 505 {
 506     table->tp_methods = methods;
 507     return *this;
 508 }
 509
 510 PythonType &PythonType::supportClass()
 511 {
 512     table->tp_flags |= Py_TPFLAGS_BASETYPE;
 513     return *this;
 514 }
 515
 516 #ifdef PYCXX_PYTHON_2TO3
 517 PythonType &PythonType::supportPrint()
 518 {
 519     table->tp_print = print_handler;
 520     return *this;
 521 }
 522 #endif
 523
 524 PythonType &PythonType::supportGetattr()
 525 {
 526     table->tp_getattr = getattr_handler;
 527     return *this;
 528 }
 529
 530 PythonType &PythonType::supportSetattr()
 531 {
 532     table->tp_setattr = setattr_handler;
 533     return *this;
 534 }
 535
 536 PythonType &PythonType::supportGetattro()
 537 {
 538     table->tp_getattro = getattro_handler;
 539     return *this;
 540 }
 541
 542 PythonType &PythonType::supportSetattro()
 543 {
 544     table->tp_setattro = setattro_handler;
 545     return *this;
 546 }
 547
 548 #ifdef PYCXX_PYTHON_2TO3
 549 PythonType &PythonType::supportCompare( void )
 550 {
 551     return *this;
 552 }
 553 #endif
 554
 555
 556 PythonType &PythonType::supportRichCompare()
 557 {
 558     table->tp_richcompare = rich_compare_handler;
 559     return *this;
 560 }
 561
 562 PythonType &PythonType::supportRepr()
 563 {
 564     table->tp_repr = repr_handler;
 565     return *this;
 566 }
 567
 568 PythonType &PythonType::supportStr()
 569 {
 570     table->tp_str = str_handler;
 571     return *this;
 572 }
 573
 574 PythonType &PythonType::supportHash()
 575 {
 576     table->tp_hash = hash_handler;
 577     return *this;
 578 }
 579
 580 PythonType &PythonType::supportCall()
 581 {
 582     table->tp_call = call_handler;
 583     return *this;
 584 }
 585
 586 PythonType &PythonType::supportIter()
 587 {
 588     table->tp_iter = iter_handler;
 589     table->tp_iternext = iternext_handler;
 590     return *this;
 591 }
 592
 593 //--------------------------------------------------------------------------------
 594 //
 595 //    Handlers
 596 //
 597 //--------------------------------------------------------------------------------
 598 PythonExtensionBase *getPythonExtensionBase( PyObject *self )
 599 {
 600     if( self->ob_type->tp_flags&Py_TPFLAGS_BASETYPE )
 601     {
 602         PythonClassInstance *instance = reinterpret_cast<PythonClassInstance *>( self );
 603         return instance->m_pycxx_object;
 604     }
 605     else
 606     {
 607         return static_cast<PythonExtensionBase *>( self );
 608     }
 609 }
 610
 611 #ifdef PYCXX_PYTHON_2TO3
 612 extern "C" int print_handler( PyObject *self, FILE *fp, int flags )
 613 {
 614     try
 615     {
 616         PythonExtensionBase *p = getPythonExtensionBase( self );
 617         return p->print( fp, flags );
 618     }
 619     catch( Py::Exception & )
 620     {
 621         return -1;    // indicate error
 622     }
 623 }
 624 #endif
 625
 626 extern "C" PyObject *getattr_handler( PyObject *self, char *name )
 627 {
 628     try
 629     {
 630         PythonExtensionBase *p = getPythonExtensionBase( self );
 631         return new_reference_to( p->getattr( name ) );
 632     }
 633     catch( Py::Exception & )
 634     {
 635         return NULL;    // indicate error
 636     }
 637 }
 638
 639 extern "C" int setattr_handler( PyObject *self, char *name, PyObject *value )
 640 {
 641     try
 642     {
 643         PythonExtensionBase *p = getPythonExtensionBase( self );
 644         return p->setattr( name, Py::Object( value ) );
 645     }
 646     catch( Py::Exception & )
 647     {
 648         return -1;    // indicate error
 649     }
 650 }
 651
 652 extern "C" PyObject *getattro_handler( PyObject *self, PyObject *name )
 653 {
 654     try
 655     {
 656         PythonExtensionBase *p = getPythonExtensionBase( self );
 657         return new_reference_to( p->getattro( Py::String( name ) ) );
 658     }
 659     catch( Py::Exception & )
 660     {
 661         return NULL;    // indicate error
 662     }
 663 }
 664
 665 extern "C" int setattro_handler( PyObject *self, PyObject *name, PyObject *value )
 666 {
 667     try
 668     {
 669         PythonExtensionBase *p = getPythonExtensionBase( self );
 670         return p->setattro( Py::String( name ), Py::Object( value ) );
 671     }
 672     catch( Py::Exception & )
 673     {
 674         return -1;    // indicate error
 675     }
 676 }
 677
 678 extern "C" PyObject *rich_compare_handler( PyObject *self, PyObject *other, int op )
 679 {
 680     try
 681     {
 682         PythonExtensionBase *p = getPythonExtensionBase( self );
 683         return new_reference_to( p->rich_compare( Py::Object( other ), op ) );
 684     }
 685     catch( Py::Exception & )
 686     {
 687         return NULL;    // indicate error
 688     }
 689 }
 690
 691 extern "C" PyObject *repr_handler( PyObject *self )
 692 {
 693     try
 694     {
 695         PythonExtensionBase *p = getPythonExtensionBase( self );
 696         return new_reference_to( p->repr() );
 697     }
 698     catch( Py::Exception & )
 699     {
 700         return NULL;    // indicate error
 701     }
 702 }
 703
 704 extern "C" PyObject *str_handler( PyObject *self )
 705 {
 706     try
 707     {
 708         PythonExtensionBase *p = getPythonExtensionBase( self );
 709         return new_reference_to( p->str() );
 710     }
 711     catch( Py::Exception & )
 712     {
 713         return NULL;    // indicate error
 714     }
 715 }
 716
 717 extern "C" long hash_handler( PyObject *self )
 718 {
 719     try
 720     {
 721         PythonExtensionBase *p = getPythonExtensionBase( self );
 722         return p->hash();
 723     }
 724     catch( Py::Exception & )
 725     {
 726         return -1;    // indicate error
 727     }
 728 }
 729
 730 extern "C" PyObject *call_handler( PyObject *self, PyObject *args, PyObject *kw )
 731 {
 732     try
 733     {
 734         PythonExtensionBase *p = getPythonExtensionBase( self );
 735         if( kw != NULL )
 736             return new_reference_to( p->call( Py::Object( args ), Py::Object( kw ) ) );
 737         else
 738             return new_reference_to( p->call( Py::Object( args ), Py::Object() ) );
 739     }
 740     catch( Py::Exception & )
 741     {
 742         return NULL;    // indicate error
 743     }
 744 }
 745
 746 extern "C" PyObject *iter_handler( PyObject *self )
 747 {
 748     try
 749     {
 750         PythonExtensionBase *p = getPythonExtensionBase( self );
 751         return new_reference_to( p->iter() );
 752     }
 753     catch( Py::Exception & )
 754     {
 755         return NULL;    // indicate error
 756     }
 757 }
 758
 759 extern "C" PyObject *iternext_handler( PyObject *self )
 760 {
 761     try
 762     {
 763         PythonExtensionBase *p = getPythonExtensionBase( self );
 764         return p->iternext();  // might be a NULL ptr on end of iteration
 765     }
 766     catch( Py::Exception & )
 767     {
 768         return NULL;    // indicate error
 769     }
 770 }
 771
 772
 773 // Sequence methods
 774 extern "C" Py_ssize_t sequence_length_handler( PyObject *self )
 775 {
 776     try
 777     {
 778         PythonExtensionBase *p = getPythonExtensionBase( self );
 779         return p->sequence_length();
 780     }
 781     catch( Py::Exception & )
 782     {
 783         return -1;    // indicate error
 784     }
 785 }
 786
 787 extern "C" PyObject *sequence_concat_handler( PyObject *self, PyObject *other )
 788 {
 789     try
 790     {
 791         PythonExtensionBase *p = getPythonExtensionBase( self );
 792         return new_reference_to( p->sequence_concat( Py::Object( other ) ) );
 793     }
 794     catch( Py::Exception & )
 795     {
 796         return NULL;    // indicate error
 797     }
 798 }
 799
 800 extern "C" PyObject *sequence_repeat_handler( PyObject *self, Py_ssize_t count )
 801 {
 802     try
 803     {
 804         PythonExtensionBase *p = getPythonExtensionBase( self );
 805         return new_reference_to( p->sequence_repeat( count ) );
 806     }
 807     catch( Py::Exception & )
 808     {
 809         return NULL;    // indicate error
 810     }
 811 }
 812
 813 extern "C" PyObject *sequence_item_handler( PyObject *self, Py_ssize_t index )
 814 {
 815     try
 816     {
 817         PythonExtensionBase *p = getPythonExtensionBase( self );
 818         return new_reference_to( p->sequence_item( index ) );
 819     }
 820     catch( Py::Exception & )
 821     {
 822         return NULL;    // indicate error
 823     }
 824 }
 825
 826 extern "C" int sequence_ass_item_handler( PyObject *self, Py_ssize_t index, PyObject *value )
 827 {
 828     try
 829     {
 830         PythonExtensionBase *p = getPythonExtensionBase( self );
 831         return p->sequence_ass_item( index, Py::Object( value ) );
 832     }
 833     catch( Py::Exception & )
 834     {
 835         return -1;    // indicate error
 836     }
 837 }
 838
 839 // Mapping
 840 extern "C" Py_ssize_t mapping_length_handler( PyObject *self )
 841 {
 842     try
 843     {
 844         PythonExtensionBase *p = getPythonExtensionBase( self );
 845         return p->mapping_length();
 846     }
 847     catch( Py::Exception & )
 848     {
 849         return -1;    // indicate error
 850     }
 851 }
 852
 853 extern "C" PyObject *mapping_subscript_handler( PyObject *self, PyObject *key )
 854 {
 855     try
 856     {
 857         PythonExtensionBase *p = getPythonExtensionBase( self );
 858         return new_reference_to( p->mapping_subscript( Py::Object( key ) ) );
 859     }
 860     catch( Py::Exception & )
 861     {
 862         return NULL;    // indicate error
 863     }
 864 }
 865
 866 extern "C" int mapping_ass_subscript_handler( PyObject *self, PyObject *key, PyObject *value )
 867 {
 868     try
 869     {
 870         PythonExtensionBase *p = getPythonExtensionBase( self );
 871         return p->mapping_ass_subscript( Py::Object( key ), Py::Object( value ) );
 872     }
 873     catch( Py::Exception & )
 874     {
 875         return -1;    // indicate error
 876     }
 877 }
 878
 879 // Number
 880 extern "C" PyObject *number_negative_handler( PyObject *self )
 881 {
 882     try
 883     {
 884         PythonExtensionBase *p = getPythonExtensionBase( self );
 885         return new_reference_to( p->number_negative() );
 886     }
 887     catch( Py::Exception & )
 888     {
 889         return NULL;    // indicate error
 890     }
 891 }
 892
 893 extern "C" PyObject *number_positive_handler( PyObject *self )
 894 {
 895     try
 896     {
 897         PythonExtensionBase *p = getPythonExtensionBase( self );
 898         return new_reference_to( p->number_positive() );
 899     }
 900     catch( Py::Exception & )
 901     {
 902         return NULL;    // indicate error
 903     }
 904 }
 905
 906 extern "C" PyObject *number_absolute_handler( PyObject *self )
 907 {
 908     try
 909     {
 910         PythonExtensionBase *p = getPythonExtensionBase( self );
 911         return new_reference_to( p->number_absolute() );
 912     }
 913     catch( Py::Exception & )
 914     {
 915         return NULL;    // indicate error
 916     }
 917 }
 918
 919 extern "C" PyObject *number_invert_handler( PyObject *self )
 920 {
 921     try
 922     {
 923         PythonExtensionBase *p = getPythonExtensionBase( self );
 924         return new_reference_to( p->number_invert() );
 925     }
 926     catch( Py::Exception & )
 927     {
 928         return NULL;    // indicate error
 929     }
 930 }
 931
 932 extern "C" PyObject *number_int_handler( PyObject *self )
 933 {
 934     try
 935     {
 936         PythonExtensionBase *p = getPythonExtensionBase( self );
 937         return new_reference_to( p->number_int() );
 938     }
 939     catch( Py::Exception & )
 940     {
 941         return NULL;    // indicate error
 942     }
 943 }
 944
 945 extern "C" PyObject *number_float_handler( PyObject *self )
 946 {
 947     try
 948     {
 949         PythonExtensionBase *p = getPythonExtensionBase( self );
 950         return new_reference_to( p->number_float() );
 951     }
 952     catch( Py::Exception & )
 953     {
 954         return NULL;    // indicate error
 955     }
 956 }
 957
 958 extern "C" PyObject *number_add_handler( PyObject *self, PyObject *other )
 959 {
 960     try
 961     {
 962         PythonExtensionBase *p = getPythonExtensionBase( self );
 963         return new_reference_to( p->number_add( Py::Object( other ) ) );
 964     }
 965     catch( Py::Exception & )
 966     {
 967         return NULL;    // indicate error
 968     }
 969 }
 970
 971 extern "C" PyObject *number_subtract_handler( PyObject *self, PyObject *other )
 972 {
 973     try
 974     {
 975         PythonExtensionBase *p = getPythonExtensionBase( self );
 976         return new_reference_to( p->number_subtract( Py::Object( other ) ) );
 977     }
 978     catch( Py::Exception & )
 979     {
 980         return NULL;    // indicate error
 981     }
 982 }
 983
 984 extern "C" PyObject *number_multiply_handler( PyObject *self, PyObject *other )
 985 {
 986     try
 987     {
 988         PythonExtensionBase *p = getPythonExtensionBase( self );
 989         return new_reference_to( p->number_multiply( Py::Object( other ) ) );
 990     }
 991     catch( Py::Exception & )
 992     {
 993         return NULL;    // indicate error
 994     }
 995 }
 996
 997 extern "C" PyObject *number_remainder_handler( PyObject *self, PyObject *other )
 998 {
 999     try
1000     {
1001         PythonExtensionBase *p = getPythonExtensionBase( self );
1002         return new_reference_to( p->number_remainder( Py::Object( other ) ) );
1003     }
1004     catch( Py::Exception & )
1005     {
1006         return NULL;    // indicate error
1007     }
1008 }
1009
1010 extern "C" PyObject *number_divmod_handler( PyObject *self, PyObject *other )
1011 {
1012     try
1013     {
1014         PythonExtensionBase *p = getPythonExtensionBase( self );
1015         return new_reference_to( p->number_divmod( Py::Object( other ) ) );
1016     }
1017     catch( Py::Exception & )
1018     {
1019         return NULL;    // indicate error
1020     }
1021 }
1022
1023 extern "C" PyObject *number_lshift_handler( PyObject *self, PyObject *other )
1024 {
1025     try
1026     {
1027         PythonExtensionBase *p = getPythonExtensionBase( self );
1028         return new_reference_to( p->number_lshift( Py::Object( other ) ) );
1029     }
1030     catch( Py::Exception & )
1031     {
1032         return NULL;    // indicate error
1033     }
1034 }
1035
1036 extern "C" PyObject *number_rshift_handler( PyObject *self, PyObject *other )
1037 {
1038     try
1039     {
1040         PythonExtensionBase *p = getPythonExtensionBase( self );
1041         return new_reference_to( p->number_rshift( Py::Object( other ) ) );
1042     }
1043     catch( Py::Exception & )
1044     {
1045         return NULL;    // indicate error
1046     }
1047 }
1048
1049 extern "C" PyObject *number_and_handler( PyObject *self, PyObject *other )
1050 {
1051     try
1052     {
1053         PythonExtensionBase *p = getPythonExtensionBase( self );
1054         return new_reference_to( p->number_and( Py::Object( other ) ) );
1055     }
1056     catch( Py::Exception & )
1057     {
1058         return NULL;    // indicate error
1059     }
1060 }
1061
1062 extern "C" PyObject *number_xor_handler( PyObject *self, PyObject *other )
1063 {
1064     try
1065     {
1066         PythonExtensionBase *p = getPythonExtensionBase( self );
1067         return new_reference_to( p->number_xor( Py::Object( other ) ) );
1068     }
1069     catch( Py::Exception & )
1070     {
1071         return NULL;    // indicate error
1072     }
1073 }
1074
1075 extern "C" PyObject *number_or_handler( PyObject *self, PyObject *other )
1076 {
1077     try
1078     {
1079         PythonExtensionBase *p = getPythonExtensionBase( self );
1080         return new_reference_to( p->number_or( Py::Object( other ) ) );
1081     }
1082     catch( Py::Exception & )
1083     {
1084         return NULL;    // indicate error
1085     }
1086 }
1087
1088 extern "C" PyObject *number_power_handler( PyObject *self, PyObject *x1, PyObject *x2 )
1089 {
1090     try
1091     {
1092         PythonExtensionBase *p = getPythonExtensionBase( self );
1093         return new_reference_to( p->number_power( Py::Object( x1 ), Py::Object( x2 ) ) );
1094     }
1095     catch( Py::Exception & )
1096     {
1097         return NULL;    // indicate error
1098     }
1099 }
1100
1101 // Buffer
1102
1103 //================================================================================
1104 //
1105 //    Implementation of PythonExtensionBase
1106 //
1107 //================================================================================
1108 #define missing_method( method ) \
1109     throw RuntimeError( "Extension object missing implement of " #method );
1110
1111 PythonExtensionBase::PythonExtensionBase()
1112 {
1113     ob_refcnt = 0;
1114 }
1115
1116 PythonExtensionBase::~PythonExtensionBase()
1117 {
1118     assert( ob_refcnt == 0 );
1119 }
1120
1121 Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name )
1122 {
1123     Py::TupleN args;
1124     return  self().callMemberFunction( fn_name, args );
1125 }
1126
1127 Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name,
1128                                             const Py::Object &arg1 )
1129 {
1130     Py::TupleN args( arg1 );
1131     return  self().callMemberFunction( fn_name, args );
1132 }
1133
1134 Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name,
1135                                             const Py::Object &arg1, const Py::Object &arg2 )
1136 {
1137     Py::TupleN args( arg1, arg2 );
1138     return self().callMemberFunction( fn_name, args );
1139 }
1140
1141 Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name,
1142                                             const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3 )
1143 {
1144     Py::TupleN args( arg1, arg2, arg3 );
1145     return self().callMemberFunction( fn_name, args );
1146 }
1147
1148 Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name,
1149                                             const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3,
1150                                             const Py::Object &arg4 )
1151 {
1152     Py::TupleN args( arg1, arg2, arg3, arg4 );
1153     return self().callMemberFunction( fn_name, args );
1154 }
1155
1156 Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name,
1157                                             const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3,
1158                                             const Py::Object &arg4, const Py::Object &arg5 )
1159 {
1160     Py::TupleN args( arg1, arg2, arg3, arg4, arg5 );
1161     return self().callMemberFunction( fn_name, args );
1162 }
1163
1164 Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name,
1165                                             const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3,
1166                                             const Py::Object &arg4, const Py::Object &arg5, const Py::Object &arg6 )
1167 {
1168     Py::TupleN args( arg1, arg2, arg3, arg4, arg5, arg6 );
1169     return self().callMemberFunction( fn_name, args );
1170 }
1171
1172 Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name,
1173                                             const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3,
1174                                             const Py::Object &arg4, const Py::Object &arg5, const Py::Object &arg6,
1175                                             const Py::Object &arg7 )
1176 {
1177     Py::TupleN args( arg1, arg2, arg3, arg4, arg5, arg6, arg7 );
1178     return self().callMemberFunction( fn_name, args );
1179 }
1180
1181 Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name,
1182                                             const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3,
1183                                             const Py::Object &arg4, const Py::Object &arg5, const Py::Object &arg6,
1184                                             const Py::Object &arg7, const Py::Object &arg8 )
1185 {
1186     Py::TupleN args( arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 );
1187     return self().callMemberFunction( fn_name, args );
1188 }
1189
1190 Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name,
1191                                             const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3,
1192                                             const Py::Object &arg4, const Py::Object &arg5, const Py::Object &arg6,
1193                                             const Py::Object &arg7, const Py::Object &arg8, const Py::Object &arg9 )
1194 {
1195     Py::TupleN args( arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 );
1196     return self().callMemberFunction( fn_name, args );
1197 }
1198
1199 void PythonExtensionBase::reinit( Tuple &args, Dict &kwds )
1200 {
1201     throw RuntimeError( "Must not call __init__ twice on this class" );
1202 }
1203
1204
1205 Py::Object PythonExtensionBase::genericGetAttro( const Py::String &name )
1206 {
1207     return asObject( PyObject_GenericGetAttr( selfPtr(), name.ptr() ) );
1208 }
1209
1210 int PythonExtensionBase::genericSetAttro( const Py::String &name, const Py::Object &value )
1211 {
1212     return PyObject_GenericSetAttr( selfPtr(), name.ptr(), value.ptr() );
1213 }
1214
1215 #ifdef PYCXX_PYTHON_2TO3
1216 int PythonExtensionBase::print( FILE *, int )
1217 {
1218     missing_method( print );
1219     return -1;
1220 }
1221 #endif
1222
1223 Py::Object PythonExtensionBase::getattr( const char * )
1224 {
1225     missing_method( getattr );
1226     return Py::None();
1227 }
1228
1229 int PythonExtensionBase::setattr( const char *, const Py::Object & )
1230 {
1231     missing_method( setattr );
1232     return -1;
1233 }
1234
1235 Py::Object PythonExtensionBase::getattro( const Py::String &name )
1236 {
1237     return asObject( PyObject_GenericGetAttr( selfPtr(), name.ptr() ) );
1238 }
1239
1240 int PythonExtensionBase::setattro( const Py::String &name, const Py::Object &value )
1241 {
1242     return PyObject_GenericSetAttr( selfPtr(), name.ptr(), value.ptr() );
1243 }
1244
1245
1246 int PythonExtensionBase::compare( const Py::Object & )
1247 {
1248     missing_method( compare );
1249     return -1;
1250 }
1251
1252 Py::Object PythonExtensionBase::rich_compare( const Py::Object &, int )
1253 {
1254     missing_method( rich_compare );
1255     return Py::None();
1256 }
1257
1258 Py::Object PythonExtensionBase::repr()
1259 {
1260     missing_method( repr );
1261     return Py::None();
1262 }
1263
1264 Py::Object PythonExtensionBase::str()
1265 {
1266     missing_method( str );
1267     return Py::None();
1268 }
1269
1270 long PythonExtensionBase::hash()
1271 {
1272     missing_method( hash );
1273     return -1; }
1274
1275
1276 Py::Object PythonExtensionBase::call( const Py::Object &, const Py::Object & )
1277 {
1278     missing_method( call );
1279     return Py::None();
1280 }
1281
1282 Py::Object PythonExtensionBase::iter()
1283 {
1284     missing_method( iter );
1285     return Py::None();
1286 }
1287
1288 PyObject *PythonExtensionBase::iternext()
1289 {
1290     missing_method( iternext );
1291     return NULL; }
1292
1293
1294
1295 // Sequence methods
1296 int PythonExtensionBase::sequence_length()
1297 {
1298     missing_method( sequence_length );
1299     return -1; }
1300
1301
1302 Py::Object PythonExtensionBase::sequence_concat( const Py::Object & )
1303 {
1304     missing_method( sequence_concat );
1305     return Py::None();
1306 }
1307
1308 Py::Object PythonExtensionBase::sequence_repeat( Py_ssize_t )
1309 {
1310     missing_method( sequence_repeat );
1311     return Py::None();
1312 }
1313
1314 Py::Object PythonExtensionBase::sequence_item( Py_ssize_t )
1315 {
1316     missing_method( sequence_item );
1317     return Py::None();
1318 }
1319
1320 int PythonExtensionBase::sequence_ass_item( Py_ssize_t, const Py::Object & )
1321 {
1322     missing_method( sequence_ass_item );
1323     return -1;
1324 }
1325
1326
1327 // Mapping
1328 int PythonExtensionBase::mapping_length()
1329 {
1330     missing_method( mapping_length );
1331     return -1;
1332 }
1333
1334
1335 Py::Object PythonExtensionBase::mapping_subscript( const Py::Object & )
1336 {
1337     missing_method( mapping_subscript );
1338     return Py::None();
1339 }
1340
1341 int PythonExtensionBase::mapping_ass_subscript( const Py::Object &, const Py::Object & )
1342 {
1343     missing_method( mapping_ass_subscript );
1344     return -1;
1345 }
1346
1347 Py::Object PythonExtensionBase::number_negative()
1348 {
1349     missing_method( number_negative );
1350     return Py::None();
1351 }
1352
1353 Py::Object PythonExtensionBase::number_positive()
1354 {
1355     missing_method( number_positive );
1356     return Py::None();
1357 }
1358
1359 Py::Object PythonExtensionBase::number_absolute()
1360 {
1361     missing_method( number_absolute );
1362     return Py::None();
1363 }
1364
1365 Py::Object PythonExtensionBase::number_invert()
1366 {
1367     missing_method( number_invert );
1368     return Py::None();
1369 }
1370
1371 Py::Object PythonExtensionBase::number_int()
1372 {
1373     missing_method( number_int );
1374     return Py::None();
1375 }
1376
1377 Py::Object PythonExtensionBase::number_float()
1378 {
1379     missing_method( number_float );
1380     return Py::None();
1381 }
1382
1383 Py::Object PythonExtensionBase::number_long()
1384 {
1385     missing_method( number_long );
1386     return Py::None();
1387 }
1388
1389 Py::Object PythonExtensionBase::number_add( const Py::Object & )
1390 {
1391     missing_method( number_add );
1392     return Py::None();
1393 }
1394
1395 Py::Object PythonExtensionBase::number_subtract( const Py::Object & )
1396 {
1397     missing_method( number_subtract );
1398     return Py::None();
1399 }
1400
1401 Py::Object PythonExtensionBase::number_multiply( const Py::Object & )
1402 {
1403     missing_method( number_multiply );
1404     return Py::None();
1405 }
1406
1407 Py::Object PythonExtensionBase::number_remainder( const Py::Object & )
1408 {
1409     missing_method( number_remainder );
1410     return Py::None();
1411 }
1412
1413 Py::Object PythonExtensionBase::number_divmod( const Py::Object & )
1414 {
1415     missing_method( number_divmod );
1416     return Py::None();
1417 }
1418
1419 Py::Object PythonExtensionBase::number_lshift( const Py::Object & )
1420 {
1421     missing_method( number_lshift );
1422     return Py::None();
1423 }
1424
1425 Py::Object PythonExtensionBase::number_rshift( const Py::Object & )
1426 {
1427     missing_method( number_rshift );
1428     return Py::None();
1429 }
1430
1431 Py::Object PythonExtensionBase::number_and( const Py::Object & )
1432 {
1433     missing_method( number_and );
1434     return Py::None();
1435 }
1436
1437 Py::Object PythonExtensionBase::number_xor( const Py::Object & )
1438 {
1439     missing_method( number_xor );
1440     return Py::None();
1441 }
1442
1443 Py::Object PythonExtensionBase::number_or( const Py::Object & )
1444 {
1445     missing_method( number_or );
1446     return Py::None();
1447 }
1448
1449 Py::Object PythonExtensionBase::number_power( const Py::Object &, const Py::Object & )
1450 {
1451     missing_method( number_power );
1452     return Py::None();
1453 }
1454
1455
1456 // Buffer
1457 // QQQ
1458
1459 //--------------------------------------------------------------------------------
1460 //
1461 //    Method call handlers for
1462 //        PythonExtensionBase
1463 //        ExtensionModuleBase
1464 //
1465 //--------------------------------------------------------------------------------
1466 // Note: Python calls noargs as varargs buts args==NULL
1467 extern "C" PyObject *method_noargs_call_handler( PyObject *_self_and_name_tuple, PyObject * )
1468 {
1469     try
1470     {
1471         Tuple self_and_name_tuple( _self_and_name_tuple );
1472
1473         PyObject *self_in_cobject = self_and_name_tuple[0].ptr();
1474         void *self_as_void = PyCObject_AsVoidPtr( self_in_cobject );
1475         if( self_as_void == NULL )
1476             return NULL;
1477
1478         ExtensionModuleBase *self = static_cast<ExtensionModuleBase *>( self_as_void );
1479
1480         Object result( self->invoke_method_noargs( PyCObject_AsVoidPtr( self_and_name_tuple[1].ptr() ) ) );
1481
1482         return new_reference_to( result.ptr() );
1483     }
1484     catch( Exception & )
1485     {
1486         return 0;
1487     }
1488 }
1489
1490 extern "C" PyObject *method_varargs_call_handler( PyObject *_self_and_name_tuple, PyObject *_args )
1491 {
1492     try
1493     {
1494         Tuple self_and_name_tuple( _self_and_name_tuple );
1495
1496         PyObject *self_in_cobject = self_and_name_tuple[0].ptr();
1497         void *self_as_void = PyCObject_AsVoidPtr( self_in_cobject );
1498         if( self_as_void == NULL )
1499             return NULL;
1500
1501         ExtensionModuleBase *self = static_cast<ExtensionModuleBase *>( self_as_void );
1502         Tuple args( _args );
1503         Object result
1504                 (
1505                 self->invoke_method_varargs
1506                     (
1507                     PyCObject_AsVoidPtr( self_and_name_tuple[1].ptr() ),
1508                     args
1509                     )
1510                 );
1511
1512         return new_reference_to( result.ptr() );
1513     }
1514     catch( Exception & )
1515     {
1516         return 0;
1517     }
1518 }
1519
1520 extern "C" PyObject *method_keyword_call_handler( PyObject *_self_and_name_tuple, PyObject *_args, PyObject *_keywords )
1521 {
1522     try
1523     {
1524         Tuple self_and_name_tuple( _self_and_name_tuple );
1525
1526         PyObject *self_in_cobject = self_and_name_tuple[0].ptr();
1527         void *self_as_void = PyCObject_AsVoidPtr( self_in_cobject );
1528         if( self_as_void == NULL )
1529             return NULL;
1530
1531         ExtensionModuleBase *self = static_cast<ExtensionModuleBase *>( self_as_void );
1532
1533         Tuple args( _args );
1534
1535         if( _keywords == NULL )
1536         {
1537             Dict keywords;    // pass an empty dict
1538
1539             Object result
1540                 (
1541                 self->invoke_method_keyword
1542                     (
1543                     PyCObject_AsVoidPtr( self_and_name_tuple[1].ptr() ),
1544                     args,
1545                     keywords
1546                     )
1547                 );
1548
1549             return new_reference_to( result.ptr() );
1550         }
1551         else
1552         {
1553             Dict keywords( _keywords ); // make dict
1554
1555             Object result
1556                     (
1557                     self->invoke_method_keyword
1558                         (
1559                         PyCObject_AsVoidPtr( self_and_name_tuple[1].ptr() ),
1560                         args,
1561                         keywords
1562                         )
1563                     );
1564
1565             return new_reference_to( result.ptr() );
1566         }
1567     }
1568     catch( Exception & )
1569     {
1570         return 0;
1571     }
1572 }
1573
1574 extern "C" void do_not_dealloc( void * )
1575 {}
1576
1577
1578 //--------------------------------------------------------------------------------
1579 //
1580 //    ExtensionExceptionType
1581 //
1582 //--------------------------------------------------------------------------------
1583 ExtensionExceptionType::ExtensionExceptionType()
1584     : Py::Object()
1585 {
1586 }
1587
1588 void ExtensionExceptionType::init( ExtensionModuleBase &module, const std::string& name )
1589 {
1590     std::string module_name( module.fullName() );
1591     module_name += ".";
1592     module_name += name;
1593
1594     set( PyErr_NewException( const_cast<char *>( module_name.c_str() ), NULL, NULL ), true );
1595 }
1596
1597 void ExtensionExceptionType::init( ExtensionModuleBase &module, const std::string& name, ExtensionExceptionType &parent )
1598  {
1599      std::string module_name( module.fullName() );
1600      module_name += ".";
1601      module_name += name;
1602
1603     set( PyErr_NewException( const_cast<char *>( module_name.c_str() ), parent.ptr(), NULL ), true );
1604 }
1605
1606 ExtensionExceptionType::~ExtensionExceptionType()
1607 {
1608 }
1609
1610 Exception::Exception( ExtensionExceptionType &exception, const std::string& reason )
1611 {
1612     PyErr_SetString( exception.ptr(), reason.c_str() );
1613 }
1614
1615 Exception::Exception( ExtensionExceptionType &exception, Object &reason )
1616 {
1617     PyErr_SetObject( exception.ptr(), reason.ptr() );
1618 }
1619
1620 Exception::Exception( PyObject *exception, Object &reason )
1621 {
1622     PyErr_SetObject( exception, reason.ptr() );
1623 }
1624
1625 #if 1
1626 //------------------------------------------------------------
1627 // compare operators
1628 bool operator!=( const Long &a, const Long &b )
1629 {
1630     return a.as_long() != b.as_long();
1631 }
1632
1633 bool operator!=( const Long &a, int b )
1634 {
1635     return a.as_long() != b;
1636 }
1637
1638 bool operator!=( const Long &a, long b )
1639 {
1640     return a.as_long() != b;
1641 }
1642
1643 bool operator!=( int a, const Long &b )
1644 {
1645     return a != b.as_long();
1646 }
1647
1648 bool operator!=( long a, const Long &b )
1649 {
1650     return a != b.as_long();
1651 }
1652
1653 //------------------------------
1654 bool operator==( const Long &a, const Long &b )
1655 {
1656     return a.as_long() == b.as_long();
1657 }
1658
1659 bool operator==( const Long &a, int b )
1660 {
1661     return a.as_long() == b;
1662 }
1663
1664 bool operator==( const Long &a, long b )
1665 {
1666     return a.as_long() == b;
1667 }
1668
1669 bool operator==( int a, const Long &b )
1670 {
1671     return a == b.as_long();
1672 }
1673
1674 bool operator==( long a, const Long &b )
1675 {
1676     return a == b.as_long();
1677 }
1678
1679 //------------------------------
1680 bool operator>( const Long &a, const Long &b )
1681 {
1682     return a.as_long() > b.as_long();
1683 }
1684
1685 bool operator>( const Long &a, int b )
1686 {
1687     return a.as_long() > b;
1688 }
1689
1690 bool operator>( const Long &a, long b )
1691 {
1692     return a.as_long() > b;
1693 }
1694
1695 bool operator>( int a, const Long &b )
1696 {
1697     return a > b.as_long();
1698 }
1699
1700 bool operator>( long a, const Long &b )
1701 {
1702     return a > b.as_long();
1703 }
1704
1705 //------------------------------
1706 bool operator>=( const Long &a, const Long &b )
1707 {
1708     return a.as_long() >= b.as_long();
1709 }
1710
1711 bool operator>=( const Long &a, int b )
1712 {
1713     return a.as_long() >= b;
1714 }
1715
1716 bool operator>=( const Long &a, long b )
1717 {
1718     return a.as_long() >= b;
1719 }
1720
1721 bool operator>=( int a, const Long &b )
1722 {
1723     return a >= b.as_long();
1724 }
1725
1726 bool operator>=( long a, const Long &b )
1727 {
1728     return a >= b.as_long();
1729 }
1730
1731 //------------------------------
1732 bool operator<( const Long &a, const Long &b )
1733 {
1734     return a.as_long() < b.as_long();
1735 }
1736
1737 bool operator<( const Long &a, int b )
1738 {
1739     return a.as_long() < b;
1740 }
1741
1742 bool operator<( const Long &a, long b )
1743 {
1744     return a.as_long() < b;
1745 }
1746
1747 bool operator<( int a, const Long &b )
1748 {
1749     return a < b.as_long();
1750 }
1751
1752 bool operator<( long a, const Long &b )
1753 {
1754     return a < b.as_long();
1755 }
1756
1757 //------------------------------
1758 bool operator<=( const Long &a, const Long &b )
1759 {
1760     return a.as_long() <= b.as_long();
1761 }
1762
1763 bool operator<=( int a, const Long &b )
1764 {
1765     return a <= b.as_long();
1766 }
1767
1768 bool operator<=( long a, const Long &b )
1769 {
1770     return a <= b.as_long();
1771 }
1772
1773 bool operator<=( const Long &a, int b )
1774 {
1775     return a.as_long() <= b;
1776 }
1777
1778 bool operator<=( const Long &a, long b )
1779 {
1780     return a.as_long() <= b;
1781 }
1782
1783 #ifdef HAVE_LONG_LONG
1784 //------------------------------
1785 bool operator!=( const Long &a, PY_LONG_LONG b )
1786 {
1787     return a.as_long_long() != b;
1788 }
1789
1790 bool operator!=( PY_LONG_LONG a, const Long &b )
1791 {
1792     return a != b.as_long_long();
1793 }
1794
1795 //------------------------------
1796 bool operator==( const Long &a, PY_LONG_LONG b )
1797 {
1798     return a.as_long_long() == b;
1799 }
1800
1801 bool operator==( PY_LONG_LONG a, const Long &b )
1802 {
1803     return a == b.as_long_long();
1804 }
1805
1806 //------------------------------
1807 bool operator>( const Long &a, PY_LONG_LONG b )
1808 {
1809     return a.as_long_long() > b;
1810 }
1811
1812 bool operator>( PY_LONG_LONG a, const Long &b )
1813 {
1814     return a > b.as_long_long();
1815 }
1816
1817 //------------------------------
1818 bool operator>=( const Long &a, PY_LONG_LONG b )
1819 {
1820     return a.as_long_long() >= b;
1821 }
1822
1823 bool operator>=( PY_LONG_LONG a, const Long &b )
1824 {
1825     return a >= b.as_long_long();
1826 }
1827
1828 //------------------------------
1829 bool operator<( const Long &a, PY_LONG_LONG b )
1830 {
1831     return a.as_long_long() < b;
1832 }
1833
1834 bool operator<( PY_LONG_LONG a, const Long &b )
1835 {
1836     return a < b.as_long_long();
1837 }
1838
1839 //------------------------------
1840 bool operator<=( const Long &a, PY_LONG_LONG b )
1841 {
1842     return a.as_long_long() <= b;
1843 }
1844
1845 bool operator<=( PY_LONG_LONG a, const Long &b )
1846 {
1847     return a <= b.as_long_long();
1848 }
1849 #endif
1850 #endif
1851
1852 //------------------------------------------------------------
1853 // compare operators
1854 bool operator!=( const Float &a, const Float &b )
1855 {
1856     return a.as_double() != b.as_double();
1857 }
1858
1859 bool operator!=( const Float &a, double b )
1860 {
1861     return a.as_double() != b;
1862 }
1863
1864 bool operator!=( double a, const Float &b )
1865 {
1866     return a != b.as_double();
1867 }
1868
1869 //------------------------------
1870 bool operator==( const Float &a, const Float &b )
1871 {
1872     return a.as_double() == b.as_double();
1873 }
1874
1875 bool operator==( const Float &a, double b )
1876 {
1877     return a.as_double() == b;
1878 }
1879
1880 bool operator==( double a, const Float &b )
1881 {
1882     return a == b.as_double();
1883 }
1884
1885 //------------------------------
1886 bool operator>( const Float &a, const Float &b )
1887 {
1888     return a.as_double() > b.as_double();
1889 }
1890
1891 bool operator>( const Float &a, double b )
1892 {
1893     return a.as_double() > b;
1894 }
1895
1896 bool operator>( double a, const Float &b )
1897 {
1898     return a > b.as_double();
1899 }
1900
1901 //------------------------------
1902 bool operator>=( const Float &a, const Float &b )
1903 {
1904     return a.as_double() >= b.as_double();
1905 }
1906
1907 bool operator>=( const Float &a, double b )
1908 {
1909     return a.as_double() >= b;
1910 }
1911
1912 bool operator>=( double a, const Float &b )
1913 {
1914     return a >= b.as_double();
1915 }
1916
1917 //------------------------------
1918 bool operator<( const Float &a, const Float &b )
1919 {
1920     return a.as_double() < b.as_double();
1921 }
1922
1923 bool operator<( const Float &a, double b )
1924 {
1925     return a.as_double() < b;
1926 }
1927
1928 bool operator<( double a, const Float &b )
1929 {
1930     return a < b.as_double();
1931 }
1932
1933 //------------------------------
1934 bool operator<=( const Float &a, const Float &b )
1935 {
1936     return a.as_double() <= b.as_double();
1937 }
1938
1939 bool operator<=( double a, const Float &b )
1940 {
1941     return a <= b.as_double();
1942 }
1943
1944 bool operator<=( const Float &a, double b )
1945 {
1946     return a.as_double() <= b;
1947 }
1948
1949 }    // end of namespace Py