← Back to branch summary

~ubuntu-branches/ubuntu/karmic/hypre/karmic

« back to all changes in this revision

Viewing changes to src/babel-runtime/python/sidl/sidl_BaseClass_Module.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam C. Powell, IV
  • Date: 2009-03-20 11:40:12 UTC
  • mfrom: (4.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20090320114012-132h6ok9w2r6o609
Tags: 2.4.0b-2
Rebuild against new openmpi.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/babel-runtime/python/sidl/sidl_BaseClass_Module.c
2
2
 * File:          sidl_BaseClass_Module.c
3
3
 * Symbol:        sidl.BaseClass-v0.9.15
4
4
 * Symbol Type:   class
5
 
 * Babel Version: 1.0.0
6
 
 * Release:       $Name:  $
7
 
 * Revision:      @(#) $Id: sidl_BaseClass_Module.c,v 1.5 2006/08/29 22:29:31 painter Exp $
 
5
 * Babel Version: 1.0.4
 
6
 * Release:       $Name: V2-4-0b $
 
7
 * Revision:      @(#) $Id: sidl_BaseClass_Module.c,v 1.6 2007/09/27 19:35:26 painter Exp $
8
8
 * Description:   implement a C extension type for a sidl extendable
9
9
 * 
10
10
 * Copyright (c) 2000-2002, The Regents of the University of California.
161
161
 * RMI connector function for the class. (no addref)
162
162
 */
163
163
struct sidl_BaseClass__object*
164
 
sidl_BaseClass__connectI(const char * url, sidl_bool ar,                      \
165
 
  struct sidl_BaseInterface__object **_ex);
 
164
sidl_BaseClass__connectI(const char * url, sidl_bool ar, struct               \
 
165
  sidl_BaseInterface__object **_ex);
166
166
 
167
167
/* Static variables to hold version of IOR */
168
 
static const int32_t s_IOR_MAJOR_VERSION = 0;
169
 
static const int32_t s_IOR_MINOR_VERSION = 10;
 
168
static const int32_t s_IOR_MAJOR_VERSION = 1;
 
169
static const int32_t s_IOR_MINOR_VERSION = 0;
170
170
 
171
171
/* Static variables for managing EPV initialization. */
172
172
static int s_remote_initialized = 0;
196
196
    cmp1 = strcmp(name, "sidl.BaseClass");
197
197
    if (!cmp1) {
198
198
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
199
 
      cast = self;
 
199
      cast = ((struct sidl_BaseClass__object*)self);
200
200
      return cast;
201
201
    }
202
202
  }
203
203
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
204
 
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,                    \
205
 
      struct sidl_BaseInterface__object**) = 
206
 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,                     \
207
 
        struct sidl_BaseInterface__object**)) 
 
204
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct             \
 
205
      sidl_BaseInterface__object**) = 
 
206
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct              \
 
207
        sidl_BaseInterface__object**)) 
208
208
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
209
209
    cast =  (*func)(((struct sidl_BaseClass__remote*)self->d_data)->d_ih,     \
210
210
      _ex);
393
393
    if(iobj){
394
394
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,       \
395
395
        _ex);SIDL_CHECK(*_ex);
396
 
      sidl_rmi_Invocation_packString( _inv, "iobj", _url,                     \
397
 
        _ex);SIDL_CHECK(*_ex);
 
396
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(    \
 
397
        *_ex);
398
398
      free((void*)_url);
399
399
    } else {
400
 
      sidl_rmi_Invocation_packString( _inv, "iobj", NULL,                     \
401
 
        _ex);SIDL_CHECK(*_ex);
 
400
      sidl_rmi_Invocation_packString( _inv, "iobj", NULL, _ex);SIDL_CHECK(    \
 
401
        *_ex);
402
402
    }
403
403
 
404
404
    /* send actual RMI request */
414
414
    }
415
415
 
416
416
    /* extract return value */
417
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,                 \
418
 
      _ex);SIDL_CHECK(*_ex);
 
417
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
 
418
      *_ex);
419
419
 
420
420
    /* unpack out and inout arguments */
421
421
 
463
463
    }
464
464
 
465
465
    /* extract return value */
466
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,                 \
467
 
      _ex);SIDL_CHECK(*_ex);
 
466
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
 
467
      *_ex);
468
468
 
469
469
    /* unpack out and inout arguments */
470
470
 
513
513
    /* extract return value */
514
514
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,           \
515
515
      _ex);SIDL_CHECK(*_ex);
516
 
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,                    \
517
 
      _ex);SIDL_CHECK(*_ex);
 
516
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(   \
 
517
      *_ex);
518
518
 
519
519
    /* unpack out and inout arguments */
520
520
 
549
549
  epv->f_isType            = remote_sidl_BaseClass_isType;
550
550
  epv->f_getClassInfo      = remote_sidl_BaseClass_getClassInfo;
551
551
 
552
 
  e0->f__cast        = (void* (*)(void*,const char*,                          \
553
 
    sidl_BaseInterface*)) epv->f__cast;
 
552
  e0->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*))     \
 
553
    epv->f__cast;
554
554
  e0->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
555
555
  e0->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
556
556
  e0->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
557
 
  e0->f__isRemote    = (sidl_bool (*)(void*,                                  \
558
 
    sidl_BaseInterface*)) epv->f__isRemote;
559
 
  e0->f__set_hooks   = (void (*)(void*,int32_t,                               \
560
 
    sidl_BaseInterface*)) epv->f__set_hooks;
561
 
  e0->f__exec        = (void (*)(void*,const char*,                           \
562
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
563
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
564
 
  e0->f_addRef       = (void (*)(void*,                                       \
565
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
566
 
  e0->f_deleteRef    = (void (*)(void*,                                       \
567
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
568
 
  e0->f_isSame       = (sidl_bool (*)(void*,                                  \
569
 
    struct sidl_BaseInterface__object*,                                       \
570
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
571
 
  e0->f_isType       = (sidl_bool (*)(void*,const char*,                      \
572
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
573
 
  e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,             \
574
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
557
  e0->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*))             \
 
558
    epv->f__isRemote;
 
559
  e0->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*))         \
 
560
    epv->f__set_hooks;
 
561
  e0->f__exec        = (void (*)(void*,const char*,struct                     \
 
562
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
 
563
    sidl_BaseInterface__object **)) epv->f__exec;
 
564
  e0->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
565
    epv->f_addRef;
 
566
  e0->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
567
    epv->f_deleteRef;
 
568
  e0->f_isSame       = (sidl_bool (*)(void*,struct                            \
 
569
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
570
    epv->f_isSame;
 
571
  e0->f_isType       = (sidl_bool (*)(void*,const char*,struct                \
 
572
    sidl_BaseInterface__object **)) epv->f_isType;
 
573
  e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct       \
 
574
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
575
575
 
576
576
  s_remote_initialized = 1;
577
577
}
593
593
  if(url == NULL) {return NULL;}
594
594
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
595
595
  if(objectID) {
596
 
    sidl_BaseInterface bi =                                                   \
597
 
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(      \
 
596
    sidl_BaseInterface bi = (                                                 \
 
597
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(       \
598
598
      objectID, _ex); SIDL_CHECK(*_ex);
599
599
    return sidl_BaseClass__rmicast(bi,_ex);SIDL_CHECK(*_ex);
600
600
  }
601
 
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar,                \
602
 
    _ex ); SIDL_CHECK(*_ex);
 
601
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex );         \
 
602
    SIDL_CHECK(*_ex);
603
603
  if ( instance == NULL) { return NULL; }
604
604
  self =
605
605
    (struct sidl_BaseClass__object*) malloc(
683
683
  struct sidl_BaseClass__object* s0;
684
684
 
685
685
  struct sidl_BaseClass__remote* r_obj;
686
 
  sidl_rmi_InstanceHandle instance =                                          \
687
 
    sidl_rmi_ProtocolFactory_createInstance(url, "sidl.BaseClass",            \
688
 
    _ex ); SIDL_CHECK(*_ex);
 
686
  sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance( \
 
687
    url, "sidl.BaseClass", _ex ); SIDL_CHECK(*_ex);
689
688
  if ( instance == NULL) { return NULL; }
690
689
  self =
691
690
    (struct sidl_BaseClass__object*) malloc(
732
731
 
733
732
  *_ex = NULL;
734
733
  if(!connect_loaded) {
735
 
    sidl_rmi_ConnectRegistry_registerConnect("sidl.BaseClass",                \
736
 
      (void*)sidl_BaseClass__IHConnect, _ex);
 
734
    sidl_rmi_ConnectRegistry_registerConnect("sidl.BaseClass", (              \
 
735
      void*)sidl_BaseClass__IHConnect, _ex);
737
736
    connect_loaded = 1;
738
737
  }
739
738
  if (obj != NULL) {
754
753
 */
755
754
 
756
755
struct sidl_BaseClass__object*
757
 
sidl_BaseClass__connectI(const char* url, sidl_bool ar,                       \
758
 
  struct sidl_BaseInterface__object **_ex)
 
756
sidl_BaseClass__connectI(const char* url, sidl_bool ar, struct                \
 
757
  sidl_BaseInterface__object **_ex)
759
758
{
760
759
  return sidl_BaseClass__remoteConnect(url, ar, _ex);
761
760
}
762
761
 
763
762
static PyObject *
764
 
pStub_BaseClass__connect(PyObject *_ignored, PyObject *_args,                 \
765
 
  PyObject *_kwdict) {
 
763
pStub_BaseClass__connect(PyObject *_ignored, PyObject *_args, PyObject        \
 
764
  *_kwdict) {
766
765
  PyObject *_return_value = NULL;
767
766
  struct sidl_BaseClass__object* self = NULL;
768
767
  char* url = NULL;
785
784
      sidl_PyExceptionCast(_exception, "sidl.rmi.NetworkException"))) {
786
785
        struct sidl_BaseInterface__object *throwaway_exception;
787
786
        PyObject *_obj = sidl_rmi_NetworkException__wrap(_ex0);
788
 
        PyObject *_args = PyTuple_New(1);
789
 
        PyTuple_SetItem(_args, 0, _obj);
790
 
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _args);
 
787
        PyObject *_eargs = PyTuple_New(1);
 
788
        PyTuple_SetItem(_eargs, 0, _obj);
 
789
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _eargs);
791
790
        PyErr_SetObject(sidl_rmi_NetworkException__type, _obj);
792
791
        Py_XDECREF(_obj);
793
792
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
794
793
          &throwaway_exception);
795
 
        Py_XDECREF(_args);
 
794
        Py_XDECREF(_eargs);
796
795
      }
797
796
    }
798
797
    else {
844
843
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
845
844
          struct sidl_BaseInterface__object *throwaway_exception;
846
845
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
847
 
          PyObject *_args = PyTuple_New(1);
848
 
          PyTuple_SetItem(_args, 0, _obj);
849
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
846
          PyObject *_eargs = PyTuple_New(1);
 
847
          PyTuple_SetItem(_eargs, 0, _obj);
 
848
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
850
849
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
851
850
          Py_XDECREF(_obj);
852
851
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
853
852
            &throwaway_exception);
854
 
          Py_XDECREF(_args);
 
853
          Py_XDECREF(_eargs);
855
854
        }
856
855
      }
857
856
      else {
898
897
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
899
898
          struct sidl_BaseInterface__object *throwaway_exception;
900
899
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
901
 
          PyObject *_args = PyTuple_New(1);
902
 
          PyTuple_SetItem(_args, 0, _obj);
903
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
900
          PyObject *_eargs = PyTuple_New(1);
 
901
          PyTuple_SetItem(_eargs, 0, _obj);
 
902
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
904
903
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
905
904
          Py_XDECREF(_obj);
906
905
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
907
906
            &throwaway_exception);
908
 
          Py_XDECREF(_args);
 
907
          Py_XDECREF(_eargs);
909
908
        }
910
909
      }
911
910
      else {
912
911
        _return_value = Py_BuildValue(
913
912
          "z",
914
913
          _return);
 
914
        free((void *)_return);
915
915
      }
916
 
      free((void *)_return);
917
916
    }
918
917
    {
919
918
      struct sidl_BaseInterface__object *throwaway_exception;
928
927
}
929
928
 
930
929
static PyObject *
931
 
pStub_BaseClass__isLocal(PyObject *_self, PyObject *_args,                    \
932
 
  PyObject *_kwdict) {
 
930
pStub_BaseClass__isLocal(PyObject *_self, PyObject *_args, PyObject *_kwdict) \
 
931
  {
933
932
  PyObject *_return_value = NULL;
934
933
  struct sidl_BaseClass__object *_self_ior =
935
934
    ((struct sidl_BaseClass__object *)
955
954
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
956
955
          struct sidl_BaseInterface__object *throwaway_exception;
957
956
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
958
 
          PyObject *_args = PyTuple_New(1);
959
 
          PyTuple_SetItem(_args, 0, _obj);
960
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
957
          PyObject *_eargs = PyTuple_New(1);
 
958
          PyTuple_SetItem(_eargs, 0, _obj);
 
959
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
961
960
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
962
961
          Py_XDECREF(_obj);
963
962
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
964
963
            &throwaway_exception);
965
 
          Py_XDECREF(_args);
 
964
          Py_XDECREF(_eargs);
966
965
        }
967
966
      }
968
967
      else {
984
983
}
985
984
 
986
985
static PyObject *
987
 
pStub_BaseClass__isRemote(PyObject *_self, PyObject *_args,                   \
988
 
  PyObject *_kwdict) {
 
986
pStub_BaseClass__isRemote(PyObject *_self, PyObject *_args, PyObject          \
 
987
  *_kwdict) {
989
988
  PyObject *_return_value = NULL;
990
989
  struct sidl_BaseClass__object *_self_ior =
991
990
    ((struct sidl_BaseClass__object *)
1011
1010
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
1012
1011
          struct sidl_BaseInterface__object *throwaway_exception;
1013
1012
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
1014
 
          PyObject *_args = PyTuple_New(1);
1015
 
          PyTuple_SetItem(_args, 0, _obj);
1016
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
1013
          PyObject *_eargs = PyTuple_New(1);
 
1014
          PyTuple_SetItem(_eargs, 0, _obj);
 
1015
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
1017
1016
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
1018
1017
          Py_XDECREF(_obj);
1019
1018
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
1020
1019
            &throwaway_exception);
1021
 
          Py_XDECREF(_args);
 
1020
          Py_XDECREF(_eargs);
1022
1021
        }
1023
1022
      }
1024
1023
      else {
1040
1039
}
1041
1040
 
1042
1041
static PyObject *
1043
 
pStub_BaseClass__set_hooks(PyObject *_self, PyObject *_args,                  \
1044
 
  PyObject *_kwdict) {
 
1042
pStub_BaseClass__set_hooks(PyObject *_self, PyObject *_args, PyObject         \
 
1043
  *_kwdict) {
1045
1044
  PyObject *_return_value = NULL;
1046
1045
  struct sidl_BaseClass__object *_self_ior =
1047
1046
    ((struct sidl_BaseClass__object *)
1069
1068
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
1070
1069
          struct sidl_BaseInterface__object *throwaway_exception;
1071
1070
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
1072
 
          PyObject *_args = PyTuple_New(1);
1073
 
          PyTuple_SetItem(_args, 0, _obj);
1074
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
1071
          PyObject *_eargs = PyTuple_New(1);
 
1072
          PyTuple_SetItem(_eargs, 0, _obj);
 
1073
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
1075
1074
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
1076
1075
          Py_XDECREF(_obj);
1077
1076
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
1078
1077
            &throwaway_exception);
1079
 
          Py_XDECREF(_args);
 
1078
          Py_XDECREF(_eargs);
1080
1079
        }
1081
1080
      }
1082
1081
      else {
1102
1101
  char* url = NULL;
1103
1102
  PyObject * implObj = NULL;
1104
1103
  static char *_kwlist[] = {"sobj",  "url", "impl", NULL };
1105
 
  int _okay = PyArg_ParseTupleAndKeywords(args, kwds, "|O&zO", _kwlist,       \
1106
 
    (void *)sidl_BaseClass__convert, &optarg, &url, &implObj);
 
1104
  int _okay = PyArg_ParseTupleAndKeywords(args, kwds, "|O&zO", _kwlist, (void \
 
1105
    *)sidl_BaseClass__convert, &optarg, &url, &implObj);
1107
1106
  if (_okay) {
1108
1107
    if (!optarg && !url && !implObj) {
1109
1108
      struct sidl_BaseInterface__object *_exception;
1116
1115
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
1117
1116
            struct sidl_BaseInterface__object *throwaway_exception;
1118
1117
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
1119
 
            PyObject *_args = PyTuple_New(1);
1120
 
            PyTuple_SetItem(_args, 0, _obj);
1121
 
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
1118
            PyObject *_eargs = PyTuple_New(1);
 
1119
            PyTuple_SetItem(_eargs, 0, _obj);
 
1120
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
1122
1121
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
1123
1122
            Py_XDECREF(_obj);
1124
1123
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,         \
1125
1124
              &throwaway_exception);
1126
 
            Py_XDECREF(_args);
 
1125
            Py_XDECREF(_eargs);
1127
1126
          }
1128
1127
          return -1;
1129
1128
        }
1141
1140
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
1142
1141
            struct sidl_BaseInterface__object *throwaway_exception;
1143
1142
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
1144
 
            PyObject *_args = PyTuple_New(1);
1145
 
            PyTuple_SetItem(_args, 0, _obj);
1146
 
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
1143
            PyObject *_eargs = PyTuple_New(1);
 
1144
            PyTuple_SetItem(_eargs, 0, _obj);
 
1145
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
1147
1146
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
1148
1147
            Py_XDECREF(_obj);
1149
1148
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,         \
1150
1149
              &throwaway_exception);
1151
 
            Py_XDECREF(_args);
 
1150
            Py_XDECREF(_eargs);
1152
1151
          }
1153
1152
          return -1;
1154
1153
        }
1164
1163
      sidl_PyExceptionCast(_exception, "sidl.rmi.NetworkException"))) {
1165
1164
        struct sidl_BaseInterface__object *throwaway_exception;
1166
1165
        PyObject *_obj = sidl_rmi_NetworkException__wrap(_ex0);
1167
 
        PyObject *_args = PyTuple_New(1);
1168
 
        PyTuple_SetItem(_args, 0, _obj);
1169
 
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _args);
 
1166
        PyObject *_eargs = PyTuple_New(1);
 
1167
        PyTuple_SetItem(_eargs, 0, _obj);
 
1168
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _eargs);
1170
1169
        PyErr_SetObject(sidl_rmi_NetworkException__type, _obj);
1171
1170
        Py_XDECREF(_obj);
1172
1171
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
1173
1172
          &throwaway_exception);
1174
 
        Py_XDECREF(_args);
 
1173
        Py_XDECREF(_eargs);
1175
1174
      }
1176
1175
      return -1;
1177
1176
    }
1528
1527
  dict = PyModule_GetDict(module);
1529
1528
  ExternalAPI[sidl_BaseClass__wrap_NUM] = (void*)sidl_BaseClass__wrap;
1530
1529
  ExternalAPI[sidl_BaseClass__convert_NUM] = (void*)sidl_BaseClass__convert;
1531
 
  ExternalAPI[sidl_BaseClass__convert_python_array_NUM] =                     \
1532
 
    (void*)sidl_BaseClass__convert_python_array;
1533
 
  ExternalAPI[sidl_BaseClass__convert_sidl_array_NUM] =                       \
1534
 
    (void*)sidl_BaseClass__convert_sidl_array;
 
1530
  ExternalAPI[sidl_BaseClass__convert_python_array_NUM] = (                   \
 
1531
    void*)sidl_BaseClass__convert_python_array;
 
1532
  ExternalAPI[sidl_BaseClass__convert_sidl_array_NUM] = (                     \
 
1533
    void*)sidl_BaseClass__convert_sidl_array;
1535
1534
  ExternalAPI[sidl_BaseClass__weakRef_NUM] = (void*)sidl_BaseClass__weakRef;
1536
1535
  ExternalAPI[sidl_BaseClass_deref_NUM] = (void*)sidl_BaseClass_deref;
1537
1536
  ExternalAPI[sidl_BaseClass__newRef_NUM] = (void*)sidl_BaseClass__newRef;
1557
1556
  sidl_BaseInterface__import();
1558
1557
  _sidl_BaseClassType.tp_base = sidl_BaseInterface_PyType();
1559
1558
  _sidl_BaseClassType.tp_bases = PyTuple_New(1);
1560
 
  PyTuple_SetItem(_sidl_BaseClassType.tp_bases,0,                             \
1561
 
    (PyObject *)sidl_BaseInterface_PyType());
 
1559
  PyTuple_SetItem(_sidl_BaseClassType.tp_bases,0, (PyObject                   \
 
1560
    *)sidl_BaseInterface_PyType());
1562
1561
  if (PyType_Ready(&_sidl_BaseClassType) < 0) {
1563
1562
    PyErr_Print();
1564
1563
    fprintf(stderr, "PyType_Ready on sidl.BaseClass failed.\n");
1571
1570
    Py_FatalError("Cannot load implementation for sidl class sidl.BaseClass");
1572
1571
  }
1573
1572
 
1574
 
  sidl_rmi_ConnectRegistry_registerConnect("sidl.BaseClass",                  \
1575
 
    (void*)sidl_BaseClass__IHConnect, &throwaway_exception);
 
1573
  sidl_rmi_ConnectRegistry_registerConnect("sidl.BaseClass", (                \
 
1574
    void*)sidl_BaseClass__IHConnect, &throwaway_exception);
1576
1575
}