text: /*
   * File:          bHYPRE_ErrorHandler_Module.c
   * Symbol:        bHYPRE.ErrorHandler-v1.0.0
   * Symbol Type:   class
   * Babel Version: 1.0.4
   * Description:   implement a C extension type for a sidl extendable
   * 
   * WARNING: Automatically generated; changes will be lost
   * 
   */
  
  /*
   * THIS CODE IS AUTOMATICALLY GENERATED BY THE BABEL
   * COMPILER. DO NOT EDIT THIS!
   * 
   * This file contains the implementation of a Python C
   * extension type (i.e. a Python type implemented in C).
   * This extension type provides Python interface to the
   * sidl type bHYPRE.ErrorHandler.
   */
  
  
  /**
   * Symbol "bHYPRE.ErrorHandler" (version 1.0.0)
   * 
   * ErrorHandler class is an interface to the hypre error handling system.
   * Its methods help interpret the error flag ierr returned by hypre functions.
   */
  #include <Python.h>
  #include <stdlib.h>
  #include <string.h>
  #ifndef included_sidl_BaseClass_h
  #include "sidl_BaseClass.h"
  #endif
  #ifndef included_sidl_ClassInfo_h
  #include "sidl_ClassInfo.h"
  #endif
  #ifndef included_sidl_rmi_ProtocolFactory_h
  #include "sidl_rmi_ProtocolFactory.h"
  #endif
  #ifndef included_sidl_rmi_InstanceRegistry_h
  #include "sidl_rmi_InstanceRegistry.h"
  #endif
  #ifndef included_sidl_rmi_InstanceHandle_h
  #include "sidl_rmi_InstanceHandle.h"
  #endif
  #ifndef included_sidl_rmi_Invocation_h
  #include "sidl_rmi_Invocation.h"
  #endif
  #ifndef included_sidl_rmi_Response_h
  #include "sidl_rmi_Response.h"
  #endif
  #ifndef included_sidl_rmi_ServerRegistry_h
  #include "sidl_rmi_ServerRegistry.h"
  #endif
  #ifndef included_sidl_rmi_ConnectRegistry_h
  #include "sidl_rmi_ConnectRegistry.h"
  #endif
  #ifndef included_sidl_io_Serializable_h
  #include "sidl_io_Serializable.h"
  #endif
  #include "sidl_Exception.h"
  
  #ifndef NULL
  #define NULL 0
  #endif
  
  #include "sidl_thread.h"
  #ifdef HAVE_PTHREAD
  static struct sidl_recursive_mutex_t bHYPRE_ErrorHandler__mutex= SIDL_RECURSIVE_MUTEX_INITIALIZER;
  #define LOCK_STATIC_GLOBALS sidl_recursive_mutex_lock( &bHYPRE_ErrorHandler__mutex )
  #define UNLOCK_STATIC_GLOBALS sidl_recursive_mutex_unlock( &bHYPRE_ErrorHandler__mutex )
  /* #define HAVE_LOCKED_STATIC_GLOBALS (sidl_recursive_mutex_trylock( &bHYPRE_ErrorHandler__mutex )==EDEADLOCK) */
  #else
  #define LOCK_STATIC_GLOBALS
  #define UNLOCK_STATIC_GLOBALS
  /* #define HAVE_LOCKED_STATIC_GLOBALS (1) */
  #endif
  
  #define bHYPRE_ErrorHandler_INTERNAL 1
  #include "bHYPRE_ErrorHandler_Module.h"
  #ifndef included_bHYPRE_ErrorHandler_IOR_h
  #include "bHYPRE_ErrorHandler_IOR.h"
  #endif
  #include "sidlObjA.h"
  #include "sidlPyArrays.h"
  #include "Numeric/arrayobject.h"
  #ifndef included_sidl_Loader_h
  #include "sidl_Loader.h"
  #endif
  #ifndef included_sidl_header_h
  #include "sidl_header.h"
  #endif
  #ifndef included_sidl_interface_IOR_h
  #include "sidl_interface_IOR.h"
  #endif
  #include "sidl_rmi_NetworkException_Module.h"
  #include "sidl_BaseClass_Module.h"
  #include "sidl_BaseInterface_Module.h"
  #include "sidl_ClassInfo_Module.h"
  #include "sidl_RuntimeException_Module.h"
  #include "sidl_rmi_Call_Module.h"
  #include "sidl_rmi_Return_Module.h"
  #include "sidl_rmi_Ticket_Module.h"
  #include <stdlib.h>
  #include <string.h>
  #include <stdio.h>
  
  /*
   * connect_loaded is a boolean value showing if the IHConnect for this object has been loaded into the connectRegistry
   */
  
  static int connect_loaded = 0;
  
  /*
   * lang_inited is a boolean value showing if we have already imported all the nescessary modules
   */
  
  static int lang_inited = 0;
  
  #define LANG_SPECIFIC_INIT() if(!lang_inited) { \
    lang_inited = 1; \
    bHYPRE_ErrorHandler__import(); \
    sidl_BaseClass__import(); \
    sidl_BaseInterface__import(); \
    sidl_ClassInfo__import(); \
    sidl_RuntimeException__import(); \
    sidl_rmi_Ticket__import(); \
  }
  /**
   * Cast method for interface and class type conversions.
   */
  struct bHYPRE_ErrorHandler__object*
  bHYPRE_ErrorHandler__rmicast(
    void* obj, struct sidl_BaseInterface__object **_ex);
  
  /**
   * RMI connector function for the class. (no addref)
   */
  struct bHYPRE_ErrorHandler__object*
  bHYPRE_ErrorHandler__connectI(const char * url, sidl_bool ar, struct          \
    sidl_BaseInterface__object **_ex);
  
  /* Static variables to hold version of IOR */
  static const int32_t s_IOR_MAJOR_VERSION = 1;
  static const int32_t s_IOR_MINOR_VERSION = 0;
  
  /* Static variables for managing EPV initialization. */
  static int s_remote_initialized = 0;
  
  static struct bHYPRE_ErrorHandler__epv s_rem_epv__bhypre_errorhandler;
  
  static struct sidl_BaseClass__epv  s_rem_epv__sidl_baseclass;
  
  static struct sidl_BaseInterface__epv  s_rem_epv__sidl_baseinterface;
  
  
  /* REMOTE CAST: dynamic type casting for remote objects. */
  static void* remote_bHYPRE_ErrorHandler__cast(
    struct bHYPRE_ErrorHandler__object* self,
    const char* name, sidl_BaseInterface* _ex)
  {
    int
      cmp0,
      cmp1;
    void* cast = NULL;
    *_ex = NULL; /* default to no exception */
    cmp0 = strcmp(name, "sidl.BaseClass");
    if (!cmp0) {
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
      cast = ((struct sidl_BaseClass__object*)self);
      return cast;
    }
    else if (cmp0 < 0) {
      cmp1 = strcmp(name, "bHYPRE.ErrorHandler");
      if (!cmp1) {
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
        cast = ((struct bHYPRE_ErrorHandler__object*)self);
        return cast;
      }
    }
    else if (cmp0 > 0) {
      cmp1 = strcmp(name, "sidl.BaseInterface");
      if (!cmp1) {
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
        cast = &((*self).d_sidl_baseclass.d_sidl_baseinterface);
        return cast;
      }
    }
    if ((*self->d_epv->f_isType)(self,name, _ex)) {
      void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct             \
        sidl_BaseInterface__object**) = 
        (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct              \
          sidl_BaseInterface__object**)) 
        sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
      cast =  (*func)(((struct bHYPRE_ErrorHandler__remote*)self->d_data)->d_ih,\
        _ex);
    }
  
    return cast;
    EXIT:
    return NULL;
  }
  
  /* REMOTE DELETE: call the remote destructor for the object. */
  static void remote_bHYPRE_ErrorHandler__delete(
    struct bHYPRE_ErrorHandler__object* self,
    sidl_BaseInterface* _ex)
  {
    *_ex = NULL;
    free((void*) self);
  }
  
  /* REMOTE GETURL: call the getURL function for the object. */
  static char* remote_bHYPRE_ErrorHandler__getURL(
    struct bHYPRE_ErrorHandler__object* self, sidl_BaseInterface* _ex)
  {
    struct sidl_rmi_InstanceHandle__object *conn = ((struct                     \
      bHYPRE_ErrorHandler__remote*)self->d_data)->d_ih;
    *_ex = NULL;
    if(conn != NULL) {
      return sidl_rmi_InstanceHandle_getObjectURL(conn, _ex);
    }
    return NULL;
  }
  
  /* REMOTE ADDREF: For internal babel use only! Remote addRef. */
  static void remote_bHYPRE_ErrorHandler__raddRef(
    struct bHYPRE_ErrorHandler__object* self,sidl_BaseInterface* _ex)
  {
    sidl_BaseException netex = NULL;
    /* initialize a new invocation */
    sidl_BaseInterface _throwaway = NULL;
    struct sidl_rmi_InstanceHandle__object *_conn = ((struct                    \
      bHYPRE_ErrorHandler__remote*)self->d_data)->d_ih;
    sidl_rmi_Response _rsvp = NULL;
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, \
      "addRef", _ex ); SIDL_CHECK(*_ex);
    /* send actual RMI request */
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
    /* Check for exceptions */
    netex = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);
    if(netex != NULL) {
      sidl_BaseInterface throwaway_exception = NULL;
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(netex,            \
        &throwaway_exception);
      return;
    }
  
    /* cleanup and return */
    EXIT:
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv,&_throwaway); }
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp,&_throwaway); }
    return;
  }
  
  /* REMOTE ISREMOTE: returns true if this object is Remote (it is). */
  static sidl_bool
  remote_bHYPRE_ErrorHandler__isRemote(
      struct bHYPRE_ErrorHandler__object* self, 
      sidl_BaseInterface *_ex) {
    *_ex = NULL;
    return TRUE;
  }
  
  /* REMOTE METHOD STUB:_set_hooks */
  static void
  remote_bHYPRE_ErrorHandler__set_hooks(
    /* in */ struct bHYPRE_ErrorHandler__object* self ,
    /* in */ sidl_bool on,
    /* out */ struct sidl_BaseInterface__object* *_ex)
  {
    LANG_SPECIFIC_INIT();
    *_ex = NULL;
    {
      /* initialize a new invocation */
      sidl_BaseInterface _throwaway = NULL;
      sidl_BaseException _be = NULL;
      sidl_rmi_Response _rsvp = NULL;
      struct sidl_rmi_InstanceHandle__object * _conn = ((struct                 \
        bHYPRE_ErrorHandler__remote*)self->d_data)->d_ih;
      sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation(      \
        _conn, "_set_hooks", _ex ); SIDL_CHECK(*_ex);
  
      /* pack in and inout arguments */
      sidl_rmi_Invocation_packBool( _inv, "on", on, _ex);SIDL_CHECK(*_ex);
  
      /* send actual RMI request */
      _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
  
      _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
      if(_be != NULL) {
        sidl_BaseInterface throwaway_exception = NULL;
  sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE.ErrorHandler._set_hooks.", &throwaway_exception);
        *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,            \
          &throwaway_exception);
        goto EXIT;
      }
  
      /* unpack out and inout arguments */
  
      /* cleanup and return */
      EXIT:
      if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
      if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
      return;
    }
  }
  
  /* REMOTE EXEC: call the exec function for the object. */
  static void remote_bHYPRE_ErrorHandler__exec(
    struct bHYPRE_ErrorHandler__object* self,const char* methodName,
    sidl_rmi_Call inArgs,
    sidl_rmi_Return outArgs,
    sidl_BaseInterface* _ex)
  {
    *_ex = NULL;
  }
  
  /* REMOTE METHOD STUB:addRef */
  static void
  remote_bHYPRE_ErrorHandler_addRef(
    /* in */ struct bHYPRE_ErrorHandler__object* self ,
    /* out */ struct sidl_BaseInterface__object* *_ex)
  {
    LANG_SPECIFIC_INIT();
    *_ex = NULL;
    {
      struct bHYPRE_ErrorHandler__remote* r_obj = (struct                       \
        bHYPRE_ErrorHandler__remote*)self->d_data;
      LOCK_STATIC_GLOBALS;
      r_obj->d_refcount++;
      UNLOCK_STATIC_GLOBALS;
    }
  }
  
  /* REMOTE METHOD STUB:deleteRef */
  static void
  remote_bHYPRE_ErrorHandler_deleteRef(
    /* in */ struct bHYPRE_ErrorHandler__object* self ,
    /* out */ struct sidl_BaseInterface__object* *_ex)
  {
    LANG_SPECIFIC_INIT();
    *_ex = NULL;
    {
      struct bHYPRE_ErrorHandler__remote* r_obj = (struct                       \
        bHYPRE_ErrorHandler__remote*)self->d_data;
      LOCK_STATIC_GLOBALS;
      r_obj->d_refcount--;
      if(r_obj->d_refcount == 0) {
        sidl_rmi_InstanceHandle_deleteRef(r_obj->d_ih, _ex);
        free(r_obj);
        free(self);
      }
      UNLOCK_STATIC_GLOBALS;
    }
  }
  
  /* REMOTE METHOD STUB:isSame */
  static sidl_bool
  remote_bHYPRE_ErrorHandler_isSame(
    /* in */ struct bHYPRE_ErrorHandler__object* self ,
    /* in */ struct sidl_BaseInterface__object* iobj,
    /* out */ struct sidl_BaseInterface__object* *_ex)
  {
    LANG_SPECIFIC_INIT();
    *_ex = NULL;
    {
      /* initialize a new invocation */
      sidl_BaseInterface _throwaway = NULL;
      sidl_BaseException _be = NULL;
      sidl_rmi_Response _rsvp = NULL;
      sidl_bool _retval = FALSE;
      struct sidl_rmi_InstanceHandle__object * _conn = ((struct                 \
        bHYPRE_ErrorHandler__remote*)self->d_data)->d_ih;
      sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation(      \
        _conn, "isSame", _ex ); SIDL_CHECK(*_ex);
  
      /* pack in and inout arguments */
      if(iobj){
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,       \
          _ex);SIDL_CHECK(*_ex);
        sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(    \
          *_ex);
        free((void*)_url);
      } else {
        sidl_rmi_Invocation_packString( _inv, "iobj", NULL, _ex);SIDL_CHECK(    \
          *_ex);
      }
  
      /* send actual RMI request */
      _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
  
      _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
      if(_be != NULL) {
        sidl_BaseInterface throwaway_exception = NULL;
  sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE.ErrorHandler.isSame.", &throwaway_exception);
        *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,            \
          &throwaway_exception);
        goto EXIT;
      }
  
      /* extract return value */
      sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
        *_ex);
  
      /* unpack out and inout arguments */
  
      /* cleanup and return */
      EXIT:
      if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
      if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
      return _retval;
    }
  }
  
  /* REMOTE METHOD STUB:isType */
  static sidl_bool
  remote_bHYPRE_ErrorHandler_isType(
    /* in */ struct bHYPRE_ErrorHandler__object* self ,
    /* in */ const char* name,
    /* out */ struct sidl_BaseInterface__object* *_ex)
  {
    LANG_SPECIFIC_INIT();
    *_ex = NULL;
    {
      /* initialize a new invocation */
      sidl_BaseInterface _throwaway = NULL;
      sidl_BaseException _be = NULL;
      sidl_rmi_Response _rsvp = NULL;
      sidl_bool _retval = FALSE;
      struct sidl_rmi_InstanceHandle__object * _conn = ((struct                 \
        bHYPRE_ErrorHandler__remote*)self->d_data)->d_ih;
      sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation(      \
        _conn, "isType", _ex ); SIDL_CHECK(*_ex);
  
      /* pack in and inout arguments */
      sidl_rmi_Invocation_packString( _inv, "name", name, _ex);SIDL_CHECK(*_ex);
  
      /* send actual RMI request */
      _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
  
      _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
      if(_be != NULL) {
        sidl_BaseInterface throwaway_exception = NULL;
  sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE.ErrorHandler.isType.", &throwaway_exception);
        *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,            \
          &throwaway_exception);
        goto EXIT;
      }
  
      /* extract return value */
      sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
        *_ex);
  
      /* unpack out and inout arguments */
  
      /* cleanup and return */
      EXIT:
      if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
      if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
      return _retval;
    }
  }
  
  /* REMOTE METHOD STUB:getClassInfo */
  static struct sidl_ClassInfo__object*
  remote_bHYPRE_ErrorHandler_getClassInfo(
    /* in */ struct bHYPRE_ErrorHandler__object* self ,
    /* out */ struct sidl_BaseInterface__object* *_ex)
  {
    LANG_SPECIFIC_INIT();
    *_ex = NULL;
    {
      /* initialize a new invocation */
      sidl_BaseInterface _throwaway = NULL;
      sidl_BaseException _be = NULL;
      sidl_rmi_Response _rsvp = NULL;
      char*_retval_str = NULL;
      struct sidl_ClassInfo__object* _retval = 0;
      struct sidl_rmi_InstanceHandle__object * _conn = ((struct                 \
        bHYPRE_ErrorHandler__remote*)self->d_data)->d_ih;
      sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation(      \
        _conn, "getClassInfo", _ex ); SIDL_CHECK(*_ex);
  
      /* pack in and inout arguments */
  
      /* send actual RMI request */
      _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
  
      _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
      if(_be != NULL) {
        sidl_BaseInterface throwaway_exception = NULL;
  sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE.ErrorHandler.getClassInfo.", &throwaway_exception);
        *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,            \
          &throwaway_exception);
        goto EXIT;
      }
  
      /* extract return value */
      sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,           \
        _ex);SIDL_CHECK(*_ex);
      _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(   \
        *_ex);
  
      /* unpack out and inout arguments */
  
      /* cleanup and return */
      EXIT:
      if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
      if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
      return _retval;
    }
  }
  
  /* REMOTE EPV: create remote entry point vectors (EPVs). */
  static void bHYPRE_ErrorHandler__init_remote_epv(void)
  {
    /* assert( HAVE_LOCKED_STATIC_GLOBALS ); */
    struct bHYPRE_ErrorHandler__epv* epv = &s_rem_epv__bhypre_errorhandler;
    struct sidl_BaseClass__epv*      e0  = &s_rem_epv__sidl_baseclass;
    struct sidl_BaseInterface__epv*  e1  = &s_rem_epv__sidl_baseinterface;
  
    epv->f__cast             = remote_bHYPRE_ErrorHandler__cast;
    epv->f__delete           = remote_bHYPRE_ErrorHandler__delete;
    epv->f__exec             = remote_bHYPRE_ErrorHandler__exec;
    epv->f__getURL           = remote_bHYPRE_ErrorHandler__getURL;
    epv->f__raddRef          = remote_bHYPRE_ErrorHandler__raddRef;
    epv->f__isRemote         = remote_bHYPRE_ErrorHandler__isRemote;
    epv->f__set_hooks        = remote_bHYPRE_ErrorHandler__set_hooks;
    epv->f__ctor             = NULL;
    epv->f__ctor2            = NULL;
    epv->f__dtor             = NULL;
    epv->f_addRef            = remote_bHYPRE_ErrorHandler_addRef;
    epv->f_deleteRef         = remote_bHYPRE_ErrorHandler_deleteRef;
    epv->f_isSame            = remote_bHYPRE_ErrorHandler_isSame;
    epv->f_isType            = remote_bHYPRE_ErrorHandler_isType;
    epv->f_getClassInfo      = remote_bHYPRE_ErrorHandler_getClassInfo;
  
    e0->f__cast        = (void* (*)(struct sidl_BaseClass__object*,const char*, \
      sidl_BaseInterface*)) epv->f__cast;
    e0->f__delete      = (void (*)(struct sidl_BaseClass__object*,              \
      sidl_BaseInterface*)) epv->f__delete;
    e0->f__getURL      = (char* (*)(struct sidl_BaseClass__object*,             \
      sidl_BaseInterface*)) epv->f__getURL;
    e0->f__raddRef     = (void (*)(struct sidl_BaseClass__object*,              \
      sidl_BaseInterface*)) epv->f__raddRef;
    e0->f__isRemote    = (sidl_bool (*)(struct sidl_BaseClass__object*,         \
      sidl_BaseInterface*)) epv->f__isRemote;
    e0->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t,      \
      sidl_BaseInterface*)) epv->f__set_hooks;
    e0->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,  \
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct      \
      sidl_BaseInterface__object **)) epv->f__exec;
    e0->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct        \
      sidl_BaseInterface__object **)) epv->f_addRef;
    e0->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct        \
      sidl_BaseInterface__object **)) epv->f_deleteRef;
    e0->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct   \
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
      epv->f_isSame;
    e0->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const    \
      char*,struct sidl_BaseInterface__object **)) epv->f_isType;
    e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct             \
      sidl_BaseClass__object*,struct sidl_BaseInterface__object **))            \
      epv->f_getClassInfo;
  
    e1->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*))     \
      epv->f__cast;
    e1->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
    e1->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
    e1->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
    e1->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*))             \
      epv->f__isRemote;
    e1->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*))         \
      epv->f__set_hooks;
    e1->f__exec        = (void (*)(void*,const char*,struct                     \
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
      sidl_BaseInterface__object **)) epv->f__exec;
    e1->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) \
      epv->f_addRef;
    e1->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) \
      epv->f_deleteRef;
    e1->f_isSame       = (sidl_bool (*)(void*,struct                            \
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
      epv->f_isSame;
    e1->f_isType       = (sidl_bool (*)(void*,const char*,struct                \
      sidl_BaseInterface__object **)) epv->f_isType;
    e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct       \
      sidl_BaseInterface__object **)) epv->f_getClassInfo;
  
    s_remote_initialized = 1;
  }
  
  /* Create an instance that connects to an existing remote object. */
  static struct bHYPRE_ErrorHandler__object*
  bHYPRE_ErrorHandler__remoteConnect(const char *url, sidl_bool ar,             \
    sidl_BaseInterface *_ex)
  {
    struct bHYPRE_ErrorHandler__object* self;
  
    struct bHYPRE_ErrorHandler__object* s0;
    struct sidl_BaseClass__object* s1;
  
    struct bHYPRE_ErrorHandler__remote* r_obj;
    sidl_rmi_InstanceHandle instance = NULL;
    char* objectID = NULL;
    objectID = NULL;
    *_ex = NULL;
    if(url == NULL) {return NULL;}
    objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
    if(objectID) {
      sidl_BaseInterface bi = (                                                 \
        sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(       \
        objectID, _ex); SIDL_CHECK(*_ex);
      return bHYPRE_ErrorHandler__rmicast(bi,_ex);SIDL_CHECK(*_ex);
    }
    instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex );         \
      SIDL_CHECK(*_ex);
    if ( instance == NULL) { return NULL; }
    self =
      (struct bHYPRE_ErrorHandler__object*) malloc(
        sizeof(struct bHYPRE_ErrorHandler__object));
  
    r_obj =
      (struct bHYPRE_ErrorHandler__remote*) malloc(
        sizeof(struct bHYPRE_ErrorHandler__remote));
  
    r_obj->d_refcount = 1;
    r_obj->d_ih = instance;
    s0 =                               self;
    s1 =                               &s0->d_sidl_baseclass;
  
    LOCK_STATIC_GLOBALS;
    if (!s_remote_initialized) {
      bHYPRE_ErrorHandler__init_remote_epv();
    }
    UNLOCK_STATIC_GLOBALS;
  
    s1->d_sidl_baseinterface.d_epv    = &s_rem_epv__sidl_baseinterface;
    s1->d_sidl_baseinterface.d_object = (void*) self;
  
    s1->d_data = (void*) r_obj;
    s1->d_epv  = &s_rem_epv__sidl_baseclass;
  
    s0->d_data = (void*) r_obj;
    s0->d_epv  = &s_rem_epv__bhypre_errorhandler;
  
    self->d_data = (void*) r_obj;
  
    return self;
    EXIT:
    return NULL;
  }
  /* Create an instance that uses an already existing  */
  /* InstanceHandle to connect to an existing remote object. */
  static struct bHYPRE_ErrorHandler__object*
  bHYPRE_ErrorHandler__IHConnect(sidl_rmi_InstanceHandle instance,              \
    sidl_BaseInterface *_ex)
  {
    struct bHYPRE_ErrorHandler__object* self;
  
    struct bHYPRE_ErrorHandler__object* s0;
    struct sidl_BaseClass__object* s1;
  
    struct bHYPRE_ErrorHandler__remote* r_obj;
    self =
      (struct bHYPRE_ErrorHandler__object*) malloc(
        sizeof(struct bHYPRE_ErrorHandler__object));
  
    r_obj =
      (struct bHYPRE_ErrorHandler__remote*) malloc(
        sizeof(struct bHYPRE_ErrorHandler__remote));
  
    r_obj->d_refcount = 1;
    r_obj->d_ih = instance;
    s0 =                               self;
    s1 =                               &s0->d_sidl_baseclass;
  
    LOCK_STATIC_GLOBALS;
    if (!s_remote_initialized) {
      bHYPRE_ErrorHandler__init_remote_epv();
    }
    UNLOCK_STATIC_GLOBALS;
  
    s1->d_sidl_baseinterface.d_epv    = &s_rem_epv__sidl_baseinterface;
    s1->d_sidl_baseinterface.d_object = (void*) self;
  
    s1->d_data = (void*) r_obj;
    s1->d_epv  = &s_rem_epv__sidl_baseclass;
  
    s0->d_data = (void*) r_obj;
    s0->d_epv  = &s_rem_epv__bhypre_errorhandler;
  
    self->d_data = (void*) r_obj;
  
    sidl_rmi_InstanceHandle_addRef(instance,_ex);SIDL_CHECK(*_ex);
    return self;
    EXIT:
    return NULL;
  }
  /* REMOTE: generate remote instance given URL string. */
  static struct bHYPRE_ErrorHandler__object*
  bHYPRE_ErrorHandler__remoteCreate(const char *url, sidl_BaseInterface *_ex)
  {
    sidl_BaseInterface _throwaway_exception = NULL;
    struct bHYPRE_ErrorHandler__object* self;
  
    struct bHYPRE_ErrorHandler__object* s0;
    struct sidl_BaseClass__object* s1;
  
    struct bHYPRE_ErrorHandler__remote* r_obj;
    sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance( \
      url, "bHYPRE.ErrorHandler", _ex ); SIDL_CHECK(*_ex);
    if ( instance == NULL) { return NULL; }
    self =
      (struct bHYPRE_ErrorHandler__object*) malloc(
        sizeof(struct bHYPRE_ErrorHandler__object));
  
    r_obj =
      (struct bHYPRE_ErrorHandler__remote*) malloc(
        sizeof(struct bHYPRE_ErrorHandler__remote));
  
    r_obj->d_refcount = 1;
    r_obj->d_ih = instance;
    s0 =                               self;
    s1 =                               &s0->d_sidl_baseclass;
  
    LOCK_STATIC_GLOBALS;
    if (!s_remote_initialized) {
      bHYPRE_ErrorHandler__init_remote_epv();
    }
    UNLOCK_STATIC_GLOBALS;
  
    s1->d_sidl_baseinterface.d_epv    = &s_rem_epv__sidl_baseinterface;
    s1->d_sidl_baseinterface.d_object = (void*) self;
  
    s1->d_data = (void*) r_obj;
    s1->d_epv  = &s_rem_epv__sidl_baseclass;
  
    s0->d_data = (void*) r_obj;
    s0->d_epv  = &s_rem_epv__bhypre_errorhandler;
  
    self->d_data = (void*) r_obj;
  
    return self;
    EXIT:
    if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance,                  \
      &_throwaway_exception); }
    return NULL;
  }
  /*
   * Cast method for interface and class type conversions.
   */
  
  struct bHYPRE_ErrorHandler__object*
  bHYPRE_ErrorHandler__rmicast(
    void* obj,
    sidl_BaseInterface* _ex)
  {
    struct bHYPRE_ErrorHandler__object* cast = NULL;
  
    *_ex = NULL;
    if(!connect_loaded) {
      sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.ErrorHandler", (         \
        void*)bHYPRE_ErrorHandler__IHConnect, _ex);
      connect_loaded = 1;
    }
    if (obj != NULL) {
      struct sidl_BaseInterface__object* base = (struct                         \
        sidl_BaseInterface__object*) obj;
      cast = (struct bHYPRE_ErrorHandler__object*) (*base->d_epv->f__cast)(
        base->d_object,
        "bHYPRE.ErrorHandler", _ex); SIDL_CHECK(*_ex);
    }
  
    return cast;
    EXIT:
    return NULL;
  }
  
  /*
   * RMI connector function for the class.
   */
  
  struct bHYPRE_ErrorHandler__object*
  bHYPRE_ErrorHandler__connectI(const char* url, sidl_bool ar, struct           \
    sidl_BaseInterface__object **_ex)
  {
    return bHYPRE_ErrorHandler__remoteConnect(url, ar, _ex);
  }
  
  static PyObject *
  pStub_ErrorHandler__connect(PyObject *_ignored, PyObject *_args, PyObject     \
    *_kwdict) {
    PyObject *_return_value = NULL;
    struct bHYPRE_ErrorHandler__object* self = NULL;
    char* url = NULL;
    struct sidl_BaseInterface__object *_exception = NULL;
    static char *_kwlist[] = {
      "url",
      NULL
    };
    int _okay;
    sidl_rmi_NetworkException__import();
    _okay = PyArg_ParseTupleAndKeywords(
      _args, _kwdict, 
      "z", _kwlist,
      &url);
    if (_okay) {
      self = bHYPRE_ErrorHandler__remoteConnect(url,1,&_exception);
      if (_exception) {
        struct sidl_rmi_NetworkException__object *_ex0;
        if ((_ex0 = (struct sidl_rmi_NetworkException__object *)
        sidl_PyExceptionCast(_exception, "sidl.rmi.NetworkException"))) {
          struct sidl_BaseInterface__object *throwaway_exception;
          PyObject *_obj = sidl_rmi_NetworkException__wrap(_ex0);
          PyObject *_eargs = PyTuple_New(1);
          PyTuple_SetItem(_eargs, 0, _obj);
          _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _eargs);
          PyErr_SetObject(sidl_rmi_NetworkException__type, _obj);
          Py_XDECREF(_obj);
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
            &throwaway_exception);
          Py_XDECREF(_eargs);
        }
      }
      else {
        _return_value = Py_BuildValue(
          "O&",
          (void *)bHYPRE_ErrorHandler__wrap, self);
      }
    }
    return _return_value;
  }
  
  staticforward PyTypeObject _bHYPRE_ErrorHandlerType;
  
  static struct bHYPRE_ErrorHandler__sepv *_sepv = NULL;
  
  static const struct bHYPRE_ErrorHandler__external *_implEPV = NULL;
  
  static PyObject *
  pStub_ErrorHandler_Check(PyObject *_ignored, PyObject *_args, PyObject        \
    *_kwdict) {
    PyObject *_return_value = NULL;
    int32_t ierr = (int32_t) 0;
    enum bHYPRE_ErrorCode__enum error_code = (enum bHYPRE_ErrorCode__enum) 0;
    struct sidl_BaseInterface__object *_exception = NULL;
    long _proxy_ierr;
    long _proxy_error_code;
    static char *_kwlist[] = {
      "ierr",
      "error_code",
      NULL
    };
    int _okay;
    sidl_RuntimeException__import();
    _okay = PyArg_ParseTupleAndKeywords(
      _args, _kwdict, 
      "ll", _kwlist,
      &_proxy_ierr,
      &_proxy_error_code);
    if (_okay) {
      int32_t _return = (int32_t) 0;
      long _proxy__return;
      ierr = _proxy_ierr;
      error_code = _proxy_error_code;
      _return = (*(_sepv->f_Check))(ierr, error_code, &_exception);
      _proxy__return = _return;
      if (_exception) {
        struct sidl_RuntimeException__object *_ex0;
        if ((_ex0 = (struct sidl_RuntimeException__object *)
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
          struct sidl_BaseInterface__object *throwaway_exception;
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
          PyObject *_eargs = PyTuple_New(1);
          PyTuple_SetItem(_eargs, 0, _obj);
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
          Py_XDECREF(_obj);
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
            &throwaway_exception);
          Py_XDECREF(_eargs);
        }
      }
      else {
        _return_value = Py_BuildValue(
          "l",
          _proxy__return);
      }
    }
    return _return_value;
  }
  
  static PyObject *
  pStub_ErrorHandler_Describe(PyObject *_ignored, PyObject *_args, PyObject     \
    *_kwdict) {
    PyObject *_return_value = NULL;
    int32_t ierr = (int32_t) 0;
    char* message = NULL;
    struct sidl_BaseInterface__object *_exception = NULL;
    long _proxy_ierr;
    static char *_kwlist[] = {
      "ierr",
      NULL
    };
    int _okay;
    sidl_RuntimeException__import();
    _okay = PyArg_ParseTupleAndKeywords(
      _args, _kwdict, 
      "l", _kwlist,
      &_proxy_ierr);
    if (_okay) {
      ierr = _proxy_ierr;
      (*(_sepv->f_Describe))(ierr, &message, &_exception);
      if (_exception) {
        struct sidl_RuntimeException__object *_ex0;
        if ((_ex0 = (struct sidl_RuntimeException__object *)
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
          struct sidl_BaseInterface__object *throwaway_exception;
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
          PyObject *_eargs = PyTuple_New(1);
          PyTuple_SetItem(_eargs, 0, _obj);
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
          Py_XDECREF(_obj);
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
            &throwaway_exception);
          Py_XDECREF(_eargs);
        }
      }
      else {
        _return_value = Py_BuildValue(
          "z",
          message);
      free((void *)message);}
    }
    return _return_value;
  }
  
  static PyObject *
  pStub_ErrorHandler__exec(PyObject *_self, PyObject *_args, PyObject *_kwdict) \
    {
    PyObject *_return_value = NULL;
    struct bHYPRE_ErrorHandler__object *_self_ior =
      ((struct bHYPRE_ErrorHandler__object *)
       sidl_Cast(_self, "bHYPRE.ErrorHandler"));
    if (_self_ior) {
      char* methodName = NULL;
      struct sidl_rmi_Call__object* inArgs = NULL;
      struct sidl_rmi_Return__object* outArgs = NULL;
      struct sidl_BaseInterface__object *_exception = NULL;
      static char *_kwlist[] = {
        "methodName",
        "inArgs",
        "outArgs",
        NULL
      };
      int _okay;
      sidl_RuntimeException__import();
      sidl_rmi_Call__import();
      sidl_rmi_Return__import();
      _okay = PyArg_ParseTupleAndKeywords(
        _args, _kwdict, 
        "zO&O&", _kwlist,
        &methodName,
        (void *)sidl_rmi_Call__convert, &inArgs,
        (void *)sidl_rmi_Return__convert, &outArgs);
      if (_okay) {
        (*(_self_ior->d_epv->f__exec))(_self_ior, methodName, inArgs, outArgs,  \
          &_exception);
        if (_exception) {
          struct sidl_RuntimeException__object *_ex0;
          if ((_ex0 = (struct sidl_RuntimeException__object *)
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
            struct sidl_BaseInterface__object *throwaway_exception;
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
            PyObject *_eargs = PyTuple_New(1);
            PyTuple_SetItem(_eargs, 0, _obj);
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
            Py_XDECREF(_obj);
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
              &throwaway_exception);
            Py_XDECREF(_eargs);
          }
        }
        else {
          _return_value = Py_None;
          Py_INCREF(_return_value);
        }
        sidl_rmi_Call_deref(inArgs);
        sidl_rmi_Return_deref(outArgs);
      }
      {
        struct sidl_BaseInterface__object *throwaway_exception;
        (*(_self_ior->d_epv->f_deleteRef))(_self_ior, &throwaway_exception);
      }
    }
    else {
      PyErr_SetString(PyExc_TypeError, 
        "self pointer is not a bHYPRE.ErrorHandler");
    }
    return _return_value;
  }
  
  static PyObject *
  pStub_ErrorHandler__getURL(PyObject *_self, PyObject *_args, PyObject         \
    *_kwdict) {
    PyObject *_return_value = NULL;
    struct bHYPRE_ErrorHandler__object *_self_ior =
      ((struct bHYPRE_ErrorHandler__object *)
       sidl_Cast(_self, "bHYPRE.ErrorHandler"));
    if (_self_ior) {
      struct sidl_BaseInterface__object *_exception = NULL;
      static char *_kwlist[] = {
        NULL
      };
      int _okay;
      sidl_RuntimeException__import();
      _okay = PyArg_ParseTupleAndKeywords(
        _args, _kwdict, 
        "", _kwlist);
      if (_okay) {
        char* _return = NULL;
        _return = (*(_self_ior->d_epv->f__getURL))(_self_ior, &_exception);
        if (_exception) {
          struct sidl_RuntimeException__object *_ex0;
          if ((_ex0 = (struct sidl_RuntimeException__object *)
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
            struct sidl_BaseInterface__object *throwaway_exception;
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
            PyObject *_eargs = PyTuple_New(1);
            PyTuple_SetItem(_eargs, 0, _obj);
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
            Py_XDECREF(_obj);
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
              &throwaway_exception);
            Py_XDECREF(_eargs);
          }
        }
        else {
          _return_value = Py_BuildValue(
            "z",
            _return);
          free((void *)_return);
        }
      }
      {
        struct sidl_BaseInterface__object *throwaway_exception;
        (*(_self_ior->d_epv->f_deleteRef))(_self_ior, &throwaway_exception);
      }
    }
    else {
      PyErr_SetString(PyExc_TypeError, 
        "self pointer is not a bHYPRE.ErrorHandler");
    }
    return _return_value;
  }
  
  static PyObject *
  pStub_ErrorHandler__isLocal(PyObject *_self, PyObject *_args, PyObject        \
    *_kwdict) {
    PyObject *_return_value = NULL;
    struct bHYPRE_ErrorHandler__object *_self_ior =
      ((struct bHYPRE_ErrorHandler__object *)
       sidl_Cast(_self, "bHYPRE.ErrorHandler"));
    if (_self_ior) {
      struct sidl_BaseInterface__object *_exception = NULL;
      static char *_kwlist[] = {
        NULL
      };
      int _okay;
      sidl_RuntimeException__import();
      _okay = PyArg_ParseTupleAndKeywords(
        _args, _kwdict, 
        "", _kwlist);
      if (_okay) {
        sidl_bool _return = (sidl_bool) 0;
        int _proxy__return;
        _return = !(*(_self_ior->d_epv->f__isRemote))(_self_ior, &_exception);
        _proxy__return = _return;
        if (_exception) {
          struct sidl_RuntimeException__object *_ex0;
          if ((_ex0 = (struct sidl_RuntimeException__object *)
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
            struct sidl_BaseInterface__object *throwaway_exception;
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
            PyObject *_eargs = PyTuple_New(1);
            PyTuple_SetItem(_eargs, 0, _obj);
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
            Py_XDECREF(_obj);
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
              &throwaway_exception);
            Py_XDECREF(_eargs);
          }
        }
        else {
          _return_value = Py_BuildValue(
            "i",
            _proxy__return);
        }
      }
      {
        struct sidl_BaseInterface__object *throwaway_exception;
        (*(_self_ior->d_epv->f_deleteRef))(_self_ior, &throwaway_exception);
      }
    }
    else {
      PyErr_SetString(PyExc_TypeError, 
        "self pointer is not a bHYPRE.ErrorHandler");
    }
    return _return_value;
  }
  
  static PyObject *
  pStub_ErrorHandler__isRemote(PyObject *_self, PyObject *_args, PyObject       \
    *_kwdict) {
    PyObject *_return_value = NULL;
    struct bHYPRE_ErrorHandler__object *_self_ior =
      ((struct bHYPRE_ErrorHandler__object *)
       sidl_Cast(_self, "bHYPRE.ErrorHandler"));
    if (_self_ior) {
      struct sidl_BaseInterface__object *_exception = NULL;
      static char *_kwlist[] = {
        NULL
      };
      int _okay;
      sidl_RuntimeException__import();
      _okay = PyArg_ParseTupleAndKeywords(
        _args, _kwdict, 
        "", _kwlist);
      if (_okay) {
        sidl_bool _return = (sidl_bool) 0;
        int _proxy__return;
        _return = (*(_self_ior->d_epv->f__isRemote))(_self_ior, &_exception);
        _proxy__return = _return;
        if (_exception) {
          struct sidl_RuntimeException__object *_ex0;
          if ((_ex0 = (struct sidl_RuntimeException__object *)
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
            struct sidl_BaseInterface__object *throwaway_exception;
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
            PyObject *_eargs = PyTuple_New(1);
            PyTuple_SetItem(_eargs, 0, _obj);
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
            Py_XDECREF(_obj);
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
              &throwaway_exception);
            Py_XDECREF(_eargs);
          }
        }
        else {
          _return_value = Py_BuildValue(
            "i",
            _proxy__return);
        }
      }
      {
        struct sidl_BaseInterface__object *throwaway_exception;
        (*(_self_ior->d_epv->f_deleteRef))(_self_ior, &throwaway_exception);
      }
    }
    else {
      PyErr_SetString(PyExc_TypeError, 
        "self pointer is not a bHYPRE.ErrorHandler");
    }
    return _return_value;
  }
  
  static PyObject *
  pStub_ErrorHandler__set_hooks(PyObject *_self, PyObject *_args, PyObject      \
    *_kwdict) {
    PyObject *_return_value = NULL;
    struct bHYPRE_ErrorHandler__object *_self_ior =
      ((struct bHYPRE_ErrorHandler__object *)
       sidl_Cast(_self, "bHYPRE.ErrorHandler"));
    if (_self_ior) {
      sidl_bool on = (sidl_bool) 0;
      struct sidl_BaseInterface__object *_exception = NULL;
      int _proxy_on;
      static char *_kwlist[] = {
        "on",
        NULL
      };
      int _okay;
      sidl_RuntimeException__import();
      _okay = PyArg_ParseTupleAndKeywords(
        _args, _kwdict, 
        "i", _kwlist,
        &_proxy_on);
      if (_okay) {
        on = (_proxy_on ? (TRUE) : (FALSE));
        (*(_self_ior->d_epv->f__set_hooks))(_self_ior, on, &_exception);
        if (_exception) {
          struct sidl_RuntimeException__object *_ex0;
          if ((_ex0 = (struct sidl_RuntimeException__object *)
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
            struct sidl_BaseInterface__object *throwaway_exception;
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
            PyObject *_eargs = PyTuple_New(1);
            PyTuple_SetItem(_eargs, 0, _obj);
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
            Py_XDECREF(_obj);
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
              &throwaway_exception);
            Py_XDECREF(_eargs);
          }
        }
        else {
          _return_value = Py_None;
          Py_INCREF(_return_value);
        }
      }
      {
        struct sidl_BaseInterface__object *throwaway_exception;
        (*(_self_ior->d_epv->f_deleteRef))(_self_ior, &throwaway_exception);
      }
    }
    else {
      PyErr_SetString(PyExc_TypeError, 
        "self pointer is not a bHYPRE.ErrorHandler");
    }
    return _return_value;
  }
  
  static PyObject *
  pStub_ErrorHandler__set_hooks_static(PyObject *_ignored, PyObject *_args,     \
    PyObject *_kwdict) {
    PyObject *_return_value = NULL;
    sidl_bool on = (sidl_bool) 0;
    struct sidl_BaseInterface__object *_exception = NULL;
    int _proxy_on;
    static char *_kwlist[] = {
      "on",
      NULL
    };
    int _okay;
    sidl_RuntimeException__import();
    _okay = PyArg_ParseTupleAndKeywords(
      _args, _kwdict, 
      "i", _kwlist,
      &_proxy_on);
    if (_okay) {
      on = (_proxy_on ? (TRUE) : (FALSE));
      (*(_sepv->f__set_hooks_static))(on, &_exception);
      if (_exception) {
        struct sidl_RuntimeException__object *_ex0;
        if ((_ex0 = (struct sidl_RuntimeException__object *)
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
          struct sidl_BaseInterface__object *throwaway_exception;
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
          PyObject *_eargs = PyTuple_New(1);
          PyTuple_SetItem(_eargs, 0, _obj);
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
          Py_XDECREF(_obj);
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
            &throwaway_exception);
          Py_XDECREF(_eargs);
        }
      }
      else {
        _return_value = Py_None;
        Py_INCREF(_return_value);
      }
    }
    if(_implEPV) {
      _sepv = (*_implEPV->getStaticEPV)();
    }
    return _return_value;
  }
  
  static int
  bHYPRE_ErrorHandler_createCast(PyObject *self, PyObject *args, PyObject       \
    *kwds) {
    struct bHYPRE_ErrorHandler__object *optarg = NULL;
    char* url = NULL;
    PyObject * implObj = NULL;
    static char *_kwlist[] = {"sobj",  "url", "impl", NULL };
    int _okay = PyArg_ParseTupleAndKeywords(args, kwds, "|O&zO", _kwlist, (void \
      *)bHYPRE_ErrorHandler__convert, &optarg, &url, &implObj);
    if (_okay) {
      if (!optarg && !url && !implObj) {
        struct sidl_BaseInterface__object *_exception;
        optarg = (*(_implEPV->createObject))(NULL,&_exception);
        if (_exception) {
          sidl_RuntimeException__import();
          {
            struct sidl_RuntimeException__object *_ex0;
            if ((_ex0 = (struct sidl_RuntimeException__object *)
            sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
              struct sidl_BaseInterface__object *throwaway_exception;
              PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
              PyObject *_eargs = PyTuple_New(1);
              PyTuple_SetItem(_eargs, 0, _obj);
              _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
              PyErr_SetObject(sidl_RuntimeException__type, _obj);
              Py_XDECREF(_obj);
              (*(_exception->d_epv->f_deleteRef))(_exception->d_object,         \
                &throwaway_exception);
              Py_XDECREF(_eargs);
            }
            return -1;
          }
        }
      }
      else if (!optarg && !url && implObj) {
        struct sidl_BaseInterface__object *_exception;
        Py_INCREF(implObj);
        optarg = (*(_implEPV->createObject))((void*)implObj,&_exception);
        if (_exception) {
          sidl_RuntimeException__import();
          {
            struct sidl_RuntimeException__object *_ex0;
            if ((_ex0 = (struct sidl_RuntimeException__object *)
            sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
              struct sidl_BaseInterface__object *throwaway_exception;
              PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
              PyObject *_eargs = PyTuple_New(1);
              PyTuple_SetItem(_eargs, 0, _obj);
              _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
              PyErr_SetObject(sidl_RuntimeException__type, _obj);
              Py_XDECREF(_obj);
              (*(_exception->d_epv->f_deleteRef))(_exception->d_object,         \
                &throwaway_exception);
              Py_XDECREF(_eargs);
            }
            return -1;
          }
        }
    }
    else if(url && !optarg && !implObj) {
      struct sidl_BaseInterface__object *_exception = NULL;
      optarg = bHYPRE_ErrorHandler__remoteCreate(url,&_exception);
      if (_exception) {
        sidl_rmi_NetworkException__import();
        struct sidl_rmi_NetworkException__object *_ex0;
        if ((_ex0 = (struct sidl_rmi_NetworkException__object *)
        sidl_PyExceptionCast(_exception, "sidl.rmi.NetworkException"))) {
          struct sidl_BaseInterface__object *throwaway_exception;
          PyObject *_obj = sidl_rmi_NetworkException__wrap(_ex0);
          PyObject *_eargs = PyTuple_New(1);
          PyTuple_SetItem(_eargs, 0, _obj);
          _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _eargs);
          PyErr_SetObject(sidl_rmi_NetworkException__type, _obj);
          Py_XDECREF(_obj);
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
            &throwaway_exception);
          Py_XDECREF(_eargs);
        }
        return -1;
      }
    }
    /* OK, but fall though */
    else if(!url && optarg && !implObj) {}
    /* Error case. */
    else {
      return -1;
    }
    return sidl_Object_Init(
      (SPObject *)self,
      (struct sidl_BaseInterface__object *)optarg,
      sidl_PyStealRef);
  }
  return -1;
  }
  
  static PyMethodDef _ErrorHandlerModuleMethods[] = {
    { "Check", (PyCFunction)pStub_ErrorHandler_Check,
    (METH_VARARGS | METH_KEYWORDS),
  "\
  Check( in int ierr,\n\
         in bHYPRE.ErrorCode error_code)\n\
  RETURNS\n\
     (int _return)\n\
  RAISES\n\
      sidl.RuntimeException\n\
  \n\
  \
  The Check method will return nonzero when the error flag ierr\n\
  includes an error of type error\\_code; and zero otherwise."
     },
    { "Describe", (PyCFunction)pStub_ErrorHandler_Describe,
    (METH_VARARGS | METH_KEYWORDS),
  "\
  Describe( in int ierr)\n\
  RETURNS\n\
     ( out string message)\n\
  RAISES\n\
      sidl.RuntimeException\n\
  \n\
  \
  included in the error flag ierr."
     },
    { "_connect", (PyCFunction)pStub_ErrorHandler__connect,
    (METH_VARARGS | METH_KEYWORDS),
  "\
  _connect( in string url)\n\
  RETURNS\n\
     ( out bHYPRE.ErrorHandler self)\n\
  RAISES\n\
      sidl.rmi.NetworkException\n\
  "
     },
    { "_set_hooks_static", (PyCFunction)pStub_ErrorHandler__set_hooks_static,
    (METH_VARARGS | METH_KEYWORDS),
  "\
  _set_hooks_static( in bool on)\n\
  RETURNS\n\
      None\n\
  RAISES\n\
      sidl.RuntimeException\n\
  \n\
  \
  Static Method to set whether or not method hooks should be invoked."
     },
    { NULL, NULL }
  };
  
  static PyMethodDef _ErrorHandlerObjectMethods[] = {
    { "_exec", (PyCFunction)pStub_ErrorHandler__exec,
    (METH_VARARGS | METH_KEYWORDS),
  "\
  _exec( in string methodName,\n\
         in sidl.rmi.Call inArgs,\n\
         in sidl.rmi.Return outArgs)\n\
  RETURNS\n\
      None\n\
  RAISES\n\
      sidl.RuntimeException\n\
  \n\
  \
  Select and execute a method by name"
     },
    { "_getURL", (PyCFunction)pStub_ErrorHandler__getURL,
    (METH_VARARGS | METH_KEYWORDS),
  "\
  _getURL()\n\
  RETURNS\n\
     (string _return)\n\
  RAISES\n\
      sidl.RuntimeException\n\
  \n\
  \
  Get the URL of the Implementation of this object (for RMI)"
     },
    { "_isLocal", (PyCFunction)pStub_ErrorHandler__isLocal,
    (METH_VARARGS | METH_KEYWORDS),
  "\
  _isLocal()\n\
  RETURNS\n\
     (bool _return)\n\
  RAISES\n\
      sidl.RuntimeException\n\
  \n\
  \
  TRUE if this object is local, false if remote"
     },
    { "_isRemote", (PyCFunction)pStub_ErrorHandler__isRemote,
    (METH_VARARGS | METH_KEYWORDS),
  "\
  _isRemote()\n\
  RETURNS\n\
     (bool _return)\n\
  RAISES\n\
      sidl.RuntimeException\n\
  \n\
  \
  TRUE if this object is remote, false if local"
     },
    { "_set_hooks", (PyCFunction)pStub_ErrorHandler__set_hooks,
    (METH_VARARGS | METH_KEYWORDS),
  "\
  _set_hooks( in bool on)\n\
  RETURNS\n\
      None\n\
  RAISES\n\
      sidl.RuntimeException\n\
  \n\
  \
  Method to set whether or not method hooks should be invoked."
     },
    { NULL, NULL }
  };
  
  static PyTypeObject _bHYPRE_ErrorHandlerType = {
    PyObject_HEAD_INIT(NULL)
    0,      /* ob_size */
    "bHYPRE.ErrorHandler.ErrorHandler", /* tp_name */
    0,      /* tp_basicsize */
    0,      /* tp_itemsize */
    0,      /* tp_dealloc */
    0,      /* tp_print */
    0,      /* tp_getattr */
    0,      /* tp_setattr */
    0,      /* tp_compare */
    0,      /* tp_repr */
    0,      /* tp_as_number */
    0,      /* tp_as_sequence */
    0,      /* tp_as_mapping */
    0,      /* tp_hash  */
    0,      /* tp_call */
    0,      /* tp_str */
    0,      /* tp_getattro */
    0,      /* tp_setattro */
    0,      /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT, /* tp_flags */
    "\
  \
  ErrorHandler class is an interface to the hypre error handling system.\n\
  Its methods help interpret the error flag ierr returned by hypre functions.", /* tp_doc */
    0,      /* tp_traverse */
    0,       /* tp_clear */
    0,       /* tp_richcompare */
    0,       /* tp_weaklistoffset */
    0,       /* tp_iter */
    0,       /* tp_iternext */
    _ErrorHandlerObjectMethods, /* tp_methods */
    0,       /* tp_members */
    0,       /* tp_getset */
    0,       /* tp_base */
    0,       /* tp_dict */
    0,       /* tp_descr_get */
    0,       /* tp_descr_set */
    0,       /* tp_dictoffset */
    bHYPRE_ErrorHandler_createCast,   /* tp_init */
    0,       /* tp_alloc */
    0,       /* tp_new */
  };
  
  bHYPRE_ErrorHandler__wrap_RETURN
  bHYPRE_ErrorHandler__wrap bHYPRE_ErrorHandler__wrap_PROTO {
    PyObject *result;
    if (sidlobj) {
      result = _bHYPRE_ErrorHandlerType.tp_new(&_bHYPRE_ErrorHandlerType, NULL, \
        NULL);
      if (result) {
        if (sidl_Object_Init(
          (SPObject *)result,
          (struct sidl_BaseInterface__object *)(sidlobj),
          sidl_PyStealRef))
        {
          Py_DECREF(result);
          result = NULL;
        }
      }
    }
    else {
      result = Py_None;
      Py_INCREF(result);
    }
    return result;
  }
  
  bHYPRE_ErrorHandler__weakRef_RETURN
  bHYPRE_ErrorHandler__weakRef bHYPRE_ErrorHandler__weakRef_PROTO {
    PyObject *result;
    if (sidlobj) {
      result = _bHYPRE_ErrorHandlerType.tp_new(&_bHYPRE_ErrorHandlerType, NULL, \
        NULL);
      if (result) {
        if (sidl_Object_Init(
          (SPObject *)result,
          (struct sidl_BaseInterface__object *)(sidlobj),
          sidl_PyWeakRef))
        {
          Py_DECREF(result);
          result = NULL;
        }
      }
    }
    else {
      result = Py_None;
      Py_INCREF(result);
    }
    return result;
  }
  
  bHYPRE_ErrorHandler_deref_RETURN
  bHYPRE_ErrorHandler_deref bHYPRE_ErrorHandler_deref_PROTO {
    if (sidlobj) {
      struct sidl_BaseInterface__object *throwaway_exception;
      (*(sidlobj->d_epv->f_deleteRef))(sidlobj, &throwaway_exception);
    }
  }
  
  bHYPRE_ErrorHandler__newRef_RETURN
  bHYPRE_ErrorHandler__newRef bHYPRE_ErrorHandler__newRef_PROTO {
    PyObject *result;
    if (sidlobj) {
      result = _bHYPRE_ErrorHandlerType.tp_new(&_bHYPRE_ErrorHandlerType, NULL, \
        NULL);
      if (result) {
        if (sidl_Object_Init(
          (SPObject *)result,
          (struct sidl_BaseInterface__object *)(sidlobj),
          sidl_PyNewRef))
        {
          Py_DECREF(result);
          result = NULL;
        }
      }
    }
    else {
      result = Py_None;
      Py_INCREF(result);
    }
    return result;
  }
  
  bHYPRE_ErrorHandler__addRef_RETURN
  bHYPRE_ErrorHandler__addRef bHYPRE_ErrorHandler__addRef_PROTO {
    if (sidlobj) {
      struct sidl_BaseInterface__object *throwaway_exception;
      (*(sidlobj->d_epv->f_addRef))(sidlobj, &throwaway_exception);
    }
  }
  
  bHYPRE_ErrorHandler_PyType_RETURN
  bHYPRE_ErrorHandler_PyType bHYPRE_ErrorHandler_PyType_PROTO {
    Py_INCREF(&_bHYPRE_ErrorHandlerType);
    return &_bHYPRE_ErrorHandlerType;
  }
  
  bHYPRE_ErrorHandler__convert_RETURN
  bHYPRE_ErrorHandler__convert bHYPRE_ErrorHandler__convert_PROTO {
    *sidlobj = sidl_Cast(obj, "bHYPRE.ErrorHandler");
    if ((!(*sidlobj)) && (obj != Py_None)) {
      PyErr_SetString(PyExc_TypeError, 
        "argument is not a(n) bHYPRE.ErrorHandler");
      return 0;
    }
    return 1;
  }
  
  static int
  _convertPython(void *sidlarray, const int *ind, PyObject *pyobj)
  {
    struct bHYPRE_ErrorHandler__object *sidlobj;
    if (bHYPRE_ErrorHandler__convert(pyobj, &sidlobj)) {
      sidl_interface__array_set((struct sidl_interface__array *)sidlarray,
      ind, (struct sidl_BaseInterface__object *)sidlobj);
      if (sidlobj) {
        struct sidl_BaseInterface__object *asInt = (struct                      \
          sidl_BaseInterface__object *)sidlobj;
        struct sidl_BaseInterface__object *throwaway_exception;
        (*asInt->d_epv->f_deleteRef)(asInt->d_object, &throwaway_exception);
      }
      return FALSE;
    }
    return TRUE;
  }
  
  bHYPRE_ErrorHandler__convert_python_array_RETURN
  bHYPRE_ErrorHandler__convert_python_array                                     \
    bHYPRE_ErrorHandler__convert_python_array_PROTO {
    int result = 0;
    *sidlarray = NULL;
    if (obj == Py_None) {
      result = TRUE;
    }
    else {
      PyObject *pya = PyArray_FromObject(obj, PyArray_OBJECT, 0, 0);
      if (pya) {
        if (PyArray_OBJECT == ((PyArrayObject *)pya)->descr->type_num) {
          int dimen, lower[SIDL_MAX_ARRAY_DIMENSION],
            upper[SIDL_MAX_ARRAY_DIMENSION],
            stride[SIDL_MAX_ARRAY_DIMENSION];
          if (sidl_array__extract_python_info
            (pya, &dimen, lower, upper, stride))
          {
              *sidlarray = (struct                                              \
                bHYPRE_ErrorHandler__array*)sidl_interface__array_createRow
              (dimen, lower, upper);
            result = sidl_array__convert_python
              (pya, dimen, *sidlarray, _convertPython);
            if (*sidlarray && !result) {
              sidl_interface__array_deleteRef(
                (struct  sidl_interface__array *)*sidlarray);
              *sidlarray = NULL;
            }
          }
        }
        Py_DECREF(pya);
      }
    }
    return result;
  }
  
  static int
  _convertSIDL(void *sidlarray, const int *ind, PyObject **dest)
  {
    struct bHYPRE_ErrorHandler__object *sidlobj = (struct                       \
      bHYPRE_ErrorHandler__object*)
    sidl_interface__array_get((struct sidl_interface__array *)
      sidlarray, ind);
    *dest = bHYPRE_ErrorHandler__wrap(sidlobj);
    return (*dest == NULL);
  }
  
  bHYPRE_ErrorHandler__convert_sidl_array_RETURN
  bHYPRE_ErrorHandler__convert_sidl_array                                       \
    bHYPRE_ErrorHandler__convert_sidl_array_PROTO {
    PyObject *pya = NULL;
    if (sidlarray) {
      const int dimen = sidlArrayDim(sidlarray);
      int i;
      int *lower = (int *)malloc(sizeof(int) * dimen);
      int *upper = (int *)malloc(sizeof(int) * dimen);
      int *numelem = (int *)malloc(sizeof(int) * dimen);
      for(i = 0; i < dimen; ++i) {
        lower[i] = sidlLower(sidlarray, i);
        upper[i] = sidlUpper(sidlarray, i);
        numelem[i] = 1 + upper[i] - lower[i];
      }
      pya = PyArray_FromDims(dimen, numelem, PyArray_OBJECT);
      if (pya) {
        if (!sidl_array__convert_sidl(pya, dimen, lower, upper,
          numelem, sidlarray, _convertSIDL))
        {
          Py_DECREF(pya);
          pya = NULL;
        }
      }
      free(numelem);
      free(upper);
      free(lower);
    }
    else {
      Py_INCREF(Py_None);
      pya = Py_None;
    }
    return pya;
  }
  
  void
  initErrorHandler(void) {
    PyObject *module, *dict, *c_api;
    static void *ExternalAPI[bHYPRE_ErrorHandler__API_NUM];
    struct sidl_BaseInterface__object *throwaway_exception;
    sidl_DLL dll = NULL;
    struct bHYPRE_ErrorHandler__external*(*_extFunc)(void) = NULL;
    module = Py_InitModule3("ErrorHandler", _ErrorHandlerModuleMethods, "\
  \
  ErrorHandler class is an interface to the hypre error handling system.\n\
  Its methods help interpret the error flag ierr returned by hypre functions."
    );
    dict = PyModule_GetDict(module);
    ExternalAPI[bHYPRE_ErrorHandler__wrap_NUM] = (                              \
      void*)bHYPRE_ErrorHandler__wrap;
    ExternalAPI[bHYPRE_ErrorHandler__convert_NUM] = (                           \
      void*)bHYPRE_ErrorHandler__convert;
    ExternalAPI[bHYPRE_ErrorHandler__convert_python_array_NUM] = (              \
      void*)bHYPRE_ErrorHandler__convert_python_array;
    ExternalAPI[bHYPRE_ErrorHandler__convert_sidl_array_NUM] = (                \
      void*)bHYPRE_ErrorHandler__convert_sidl_array;
    ExternalAPI[bHYPRE_ErrorHandler__weakRef_NUM] = (                           \
      void*)bHYPRE_ErrorHandler__weakRef;
    ExternalAPI[bHYPRE_ErrorHandler_deref_NUM] = (                              \
      void*)bHYPRE_ErrorHandler_deref;
    ExternalAPI[bHYPRE_ErrorHandler__newRef_NUM] = (                            \
      void*)bHYPRE_ErrorHandler__newRef;
    ExternalAPI[bHYPRE_ErrorHandler__addRef_NUM] = (                            \
      void*)bHYPRE_ErrorHandler__addRef;
    ExternalAPI[bHYPRE_ErrorHandler_PyType_NUM] = (                             \
      void*)bHYPRE_ErrorHandler_PyType;
    ExternalAPI[bHYPRE_ErrorHandler__connectI_NUM] = (                          \
      void*)bHYPRE_ErrorHandler__connectI;
    ExternalAPI[bHYPRE_ErrorHandler__rmicast_NUM] = (                           \
      void*)bHYPRE_ErrorHandler__rmicast;
    import_SIDLObjA();
    if (PyErr_Occurred()) {
      Py_FatalError("Error importing sidlObjA module.");
    }
    c_api = PyCObject_FromVoidPtr((void *)ExternalAPI, NULL);
    PyDict_SetItemString(dict, "_C_API", c_api);
    Py_XDECREF(c_api);
    import_SIDLPyArrays();
    if (PyErr_Occurred()) {
      Py_FatalError("Error importing sidlPyArrays module.");
    }
    import_array();
    if (PyErr_Occurred()) {
      Py_FatalError("Error importing Numeric Python module.");
    }
    sidl_BaseClass__import();
    _bHYPRE_ErrorHandlerType.tp_base = sidl_BaseClass_PyType();
    _bHYPRE_ErrorHandlerType.tp_bases = PyTuple_New(1);
    PyTuple_SetItem(_bHYPRE_ErrorHandlerType.tp_bases,0, (PyObject              \
      *)sidl_BaseClass_PyType());
    if (PyType_Ready(&_bHYPRE_ErrorHandlerType) < 0) {
      PyErr_Print();
      fprintf(stderr, "PyType_Ready on bHYPRE.ErrorHandler failed.\n");
      return;
    }
    Py_INCREF(&_bHYPRE_ErrorHandlerType);
    PyDict_SetItemString(dict, "ErrorHandler", (PyObject                        \
      *)&_bHYPRE_ErrorHandlerType);
    /* Load the implementation after initializing the module. */
    /* Try search global namespace first */
    dll = sidl_DLL__create(&throwaway_exception);
    if (dll && sidl_DLL_loadLibrary(dll, "main:", TRUE, FALSE,                  \
      &throwaway_exception)) {
      _extFunc = (struct bHYPRE_ErrorHandler__external*(*)(void))
        sidl_DLL_lookupSymbol(dll, "bHYPRE_ErrorHandler__externals",            \
          &throwaway_exception);
      if (_extFunc) {
        _implEPV = (*_extFunc)();
      }
    }
    if (dll) sidl_DLL_deleteRef(dll, &throwaway_exception);
    if (!_implEPV) {
      dll = sidl_Loader_findLibrary("bHYPRE.ErrorHandler",
        "ior/impl", sidl_Scope_SCLSCOPE,
        sidl_Resolve_SCLRESOLVE, &throwaway_exception);
      if (dll) {
        _extFunc = (struct bHYPRE_ErrorHandler__external*(*)(void))
          sidl_DLL_lookupSymbol(dll, "bHYPRE_ErrorHandler__externals",          \
            &throwaway_exception);
        if (_extFunc) {
          _implEPV = (*_extFunc)();
        }
        sidl_DLL_deleteRef(dll, &throwaway_exception);
      }
    }
    if (_implEPV) {
      _sepv = (*_implEPV->getStaticEPV)();
      if (PyErr_Occurred()) {
        Py_FatalError("Cannot initialize Python module bHYPRE.ErrorHandler.");
      }
    }
    else {
      Py_FatalError("Cannot load implementation for sidl class                  \
        bHYPRE.ErrorHandler");
    }
  
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.ErrorHandler", (           \
      void*)bHYPRE_ErrorHandler__IHConnect, &throwaway_exception);
  }
  