← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/babel-runtime/python/sidlx/rmi/sidlx_rmi_GenNetworkException_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/sidlx/rmi/sidlx_rmi_GenNetworkException_Module.c
2
2
 * File:          sidlx_rmi_GenNetworkException_Module.c
3
3
 * Symbol:        sidlx.rmi.GenNetworkException-v0.1
4
4
 * Symbol Type:   class
5
 
 * Babel Version: 1.0.0
 
5
 * Babel Version: 1.0.4
6
6
 * Description:   implement a C extension type for a sidl extendable
7
7
 * 
8
8
 * WARNING: Automatically generated; changes will be lost
154
154
  struct sidl_BaseInterface__object **_ex);
155
155
 
156
156
/* Static variables to hold version of IOR */
157
 
static const int32_t s_IOR_MAJOR_VERSION = 0;
158
 
static const int32_t s_IOR_MINOR_VERSION = 10;
 
157
static const int32_t s_IOR_MAJOR_VERSION = 1;
 
158
static const int32_t s_IOR_MINOR_VERSION = 0;
159
159
 
160
160
/* Static variables for managing EPV initialization. */
161
161
static int s_remote_initialized = 0;
196
196
  cmp0 = strcmp(name, "sidl.SIDLException");
197
197
  if (!cmp0) {
198
198
    (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
199
 
    cast = self;
 
199
    cast = ((struct sidl_SIDLException__object*)self);
200
200
    return cast;
201
201
  }
202
202
  else if (cmp0 < 0) {
203
203
    cmp1 = strcmp(name, "sidl.BaseInterface");
204
204
    if (!cmp1) {
205
205
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
206
 
      cast =                                                                  \
207
 
        &((                                                                   \
 
206
      cast = &((                                                              \
208
207
        *self).d_sidl_rmi_networkexception.d_sidl_io_ioexception.d_sidl_sidlexception.d_sidl_baseclass.d_sidl_baseinterface);
209
208
      return cast;
210
209
    }
212
211
      cmp2 = strcmp(name, "sidl.BaseException");
213
212
      if (!cmp2) {
214
213
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
215
 
        cast =                                                                \
216
 
          &((                                                                 \
 
214
        cast = &((                                                            \
217
215
          *self).d_sidl_rmi_networkexception.d_sidl_io_ioexception.d_sidl_sidlexception.d_sidl_baseexception);
218
216
        return cast;
219
217
      }
221
219
        cmp3 = strcmp(name, "sidl.BaseClass");
222
220
        if (!cmp3) {
223
221
          (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
224
 
          cast = self;
 
222
          cast = ((struct sidl_BaseClass__object*)self);
225
223
          return cast;
226
224
        }
227
225
      }
230
228
      cmp2 = strcmp(name, "sidl.RuntimeException");
231
229
      if (!cmp2) {
232
230
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
233
 
        cast =                                                                \
234
 
          &((                                                                 \
 
231
        cast = &((                                                            \
235
232
          *self).d_sidl_rmi_networkexception.d_sidl_io_ioexception.d_sidl_runtimeexception);
236
233
        return cast;
237
234
      }
241
238
    cmp1 = strcmp(name, "sidl.rmi.NetworkException");
242
239
    if (!cmp1) {
243
240
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
244
 
      cast = self;
 
241
      cast = ((struct sidl_rmi_NetworkException__object*)self);
245
242
      return cast;
246
243
    }
247
244
    else if (cmp1 < 0) {
248
245
      cmp2 = strcmp(name, "sidl.io.Serializable");
249
246
      if (!cmp2) {
250
247
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
251
 
        cast =                                                                \
252
 
          &((                                                                 \
 
248
        cast = &((                                                            \
253
249
          *self).d_sidl_rmi_networkexception.d_sidl_io_ioexception.d_sidl_sidlexception.d_sidl_io_serializable);
254
250
        return cast;
255
251
      }
257
253
        cmp3 = strcmp(name, "sidl.io.IOException");
258
254
        if (!cmp3) {
259
255
          (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
260
 
          cast = self;
 
256
          cast = ((struct sidl_io_IOException__object*)self);
261
257
          return cast;
262
258
        }
263
259
      }
266
262
      cmp2 = strcmp(name, "sidlx.rmi.GenNetworkException");
267
263
      if (!cmp2) {
268
264
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
269
 
        cast = self;
 
265
        cast = ((struct sidlx_rmi_GenNetworkException__object*)self);
270
266
        return cast;
271
267
      }
272
268
    }
273
269
  }
274
270
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
275
 
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,                    \
276
 
      struct sidl_BaseInterface__object**) = 
277
 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,                     \
278
 
        struct sidl_BaseInterface__object**)) 
 
271
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct             \
 
272
      sidl_BaseInterface__object**) = 
 
273
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct              \
 
274
        sidl_BaseInterface__object**)) 
279
275
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
280
276
    cast =  (*func)(((struct                                                  \
281
277
      sidlx_rmi_GenNetworkException__remote*)self->d_data)->d_ih, _ex);
435
431
    }
436
432
 
437
433
    /* extract return value */
438
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
439
 
      _ex);SIDL_CHECK(*_ex);
 
434
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
435
      *_ex);
440
436
 
441
437
    /* unpack out and inout arguments */
442
438
 
511
507
    if(iobj){
512
508
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,       \
513
509
        _ex);SIDL_CHECK(*_ex);
514
 
      sidl_rmi_Invocation_packString( _inv, "iobj", _url,                     \
515
 
        _ex);SIDL_CHECK(*_ex);
 
510
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(    \
 
511
        *_ex);
516
512
      free((void*)_url);
517
513
    } else {
518
 
      sidl_rmi_Invocation_packString( _inv, "iobj", NULL,                     \
519
 
        _ex);SIDL_CHECK(*_ex);
 
514
      sidl_rmi_Invocation_packString( _inv, "iobj", NULL, _ex);SIDL_CHECK(    \
 
515
        *_ex);
520
516
    }
521
517
 
522
518
    /* send actual RMI request */
532
528
    }
533
529
 
534
530
    /* extract return value */
535
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,                 \
536
 
      _ex);SIDL_CHECK(*_ex);
 
531
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
 
532
      *_ex);
537
533
 
538
534
    /* unpack out and inout arguments */
539
535
 
581
577
    }
582
578
 
583
579
    /* extract return value */
584
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,                 \
585
 
      _ex);SIDL_CHECK(*_ex);
 
580
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
 
581
      *_ex);
586
582
 
587
583
    /* unpack out and inout arguments */
588
584
 
631
627
    /* extract return value */
632
628
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,           \
633
629
      _ex);SIDL_CHECK(*_ex);
634
 
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,                    \
635
 
      _ex);SIDL_CHECK(*_ex);
 
630
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(   \
 
631
      *_ex);
636
632
 
637
633
    /* unpack out and inout arguments */
638
634
 
711
707
      _conn, "setNote", _ex ); SIDL_CHECK(*_ex);
712
708
 
713
709
    /* pack in and inout arguments */
714
 
    sidl_rmi_Invocation_packString( _inv, "message", message,                 \
715
 
      _ex);SIDL_CHECK(*_ex);
 
710
    sidl_rmi_Invocation_packString( _inv, "message", message, _ex);SIDL_CHECK(\
 
711
      *_ex);
716
712
 
717
713
    /* send actual RMI request */
718
714
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
852
848
    /* pack in and inout arguments */
853
849
    sidl_rmi_Invocation_packString( _inv, "filename", filename,               \
854
850
      _ex);SIDL_CHECK(*_ex);
855
 
    sidl_rmi_Invocation_packInt( _inv, "lineno", lineno,                      \
856
 
      _ex);SIDL_CHECK(*_ex);
 
851
    sidl_rmi_Invocation_packInt( _inv, "lineno", lineno, _ex);SIDL_CHECK(     \
 
852
      *_ex);
857
853
    sidl_rmi_Invocation_packString( _inv, "methodname", methodname,           \
858
854
      _ex);SIDL_CHECK(*_ex);
859
855
 
902
898
    if(ser){
903
899
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)ser,        \
904
900
        _ex);SIDL_CHECK(*_ex);
905
 
      sidl_rmi_Invocation_packString( _inv, "ser", _url,                      \
906
 
        _ex);SIDL_CHECK(*_ex);
 
901
      sidl_rmi_Invocation_packString( _inv, "ser", _url, _ex);SIDL_CHECK(     \
 
902
        *_ex);
907
903
      free((void*)_url);
908
904
    } else {
909
 
      sidl_rmi_Invocation_packString( _inv, "ser", NULL,                      \
910
 
        _ex);SIDL_CHECK(*_ex);
 
905
      sidl_rmi_Invocation_packString( _inv, "ser", NULL, _ex);SIDL_CHECK(     \
 
906
        *_ex);
911
907
    }
912
908
 
913
909
    /* send actual RMI request */
955
951
    if(des){
956
952
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)des,        \
957
953
        _ex);SIDL_CHECK(*_ex);
958
 
      sidl_rmi_Invocation_packString( _inv, "des", _url,                      \
959
 
        _ex);SIDL_CHECK(*_ex);
 
954
      sidl_rmi_Invocation_packString( _inv, "des", _url, _ex);SIDL_CHECK(     \
 
955
        *_ex);
960
956
      free((void*)_url);
961
957
    } else {
962
 
      sidl_rmi_Invocation_packString( _inv, "des", NULL,                      \
963
 
        _ex);SIDL_CHECK(*_ex);
 
958
      sidl_rmi_Invocation_packString( _inv, "des", NULL, _ex);SIDL_CHECK(     \
 
959
        *_ex);
964
960
    }
965
961
 
966
962
    /* send actual RMI request */
1045
1041
  e0->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t,      \
1046
1042
    sidl_BaseInterface*)) epv->f__set_hooks;
1047
1043
  e0->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,  \
1048
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1049
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1050
 
  e0->f_addRef       = (void (*)(struct sidl_BaseClass__object*,              \
1051
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1052
 
  e0->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,              \
1053
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1054
 
  e0->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,         \
1055
 
    struct sidl_BaseInterface__object*,                                       \
1056
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1057
 
  e0->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,         \
1058
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
1044
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct      \
 
1045
    sidl_BaseInterface__object **)) epv->f__exec;
 
1046
  e0->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct        \
 
1047
    sidl_BaseInterface__object **)) epv->f_addRef;
 
1048
  e0->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct        \
 
1049
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1050
  e0->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct   \
 
1051
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1052
    epv->f_isSame;
 
1053
  e0->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const    \
 
1054
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
1059
1055
  e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct             \
1060
 
    sidl_BaseClass__object*,                                                  \
1061
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1056
    sidl_BaseClass__object*,struct sidl_BaseInterface__object **))            \
 
1057
    epv->f_getClassInfo;
1062
1058
 
1063
 
  e1->f__cast        = (void* (*)(void*,const char*,                          \
1064
 
    sidl_BaseInterface*)) epv->f__cast;
 
1059
  e1->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*))     \
 
1060
    epv->f__cast;
1065
1061
  e1->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
1066
1062
  e1->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
1067
1063
  e1->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
1068
 
  e1->f__isRemote    = (sidl_bool (*)(void*,                                  \
1069
 
    sidl_BaseInterface*)) epv->f__isRemote;
1070
 
  e1->f__set_hooks   = (void (*)(void*,int32_t,                               \
1071
 
    sidl_BaseInterface*)) epv->f__set_hooks;
1072
 
  e1->f__exec        = (void (*)(void*,const char*,                           \
1073
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1074
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1075
 
  e1->f_getNote      = (char* (*)(void*,                                      \
1076
 
    struct sidl_BaseInterface__object **)) epv->f_getNote;
1077
 
  e1->f_setNote      = (void (*)(void*,const char*,                           \
1078
 
    struct sidl_BaseInterface__object **)) epv->f_setNote;
1079
 
  e1->f_getTrace     = (char* (*)(void*,                                      \
1080
 
    struct sidl_BaseInterface__object **)) epv->f_getTrace;
1081
 
  e1->f_addLine      = (void (*)(void*,const char*,                           \
1082
 
    struct sidl_BaseInterface__object **)) epv->f_addLine;
1083
 
  e1->f_add          = (void (*)(void*,const char*,int32_t,const char*,       \
1084
 
    struct sidl_BaseInterface__object **)) epv->f_add;
 
1064
  e1->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*))             \
 
1065
    epv->f__isRemote;
 
1066
  e1->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*))         \
 
1067
    epv->f__set_hooks;
 
1068
  e1->f__exec        = (void (*)(void*,const char*,struct                     \
 
1069
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
 
1070
    sidl_BaseInterface__object **)) epv->f__exec;
 
1071
  e1->f_getNote      = (char* (*)(void*,struct sidl_BaseInterface__object     \
 
1072
    **)) epv->f_getNote;
 
1073
  e1->f_setNote      = (void (*)(void*,const char*,struct                     \
 
1074
    sidl_BaseInterface__object **)) epv->f_setNote;
 
1075
  e1->f_getTrace     = (char* (*)(void*,struct sidl_BaseInterface__object     \
 
1076
    **)) epv->f_getTrace;
 
1077
  e1->f_addLine      = (void (*)(void*,const char*,struct                     \
 
1078
    sidl_BaseInterface__object **)) epv->f_addLine;
 
1079
  e1->f_add          = (void (*)(void*,const char*,int32_t,const char*,struct \
 
1080
    sidl_BaseInterface__object **)) epv->f_add;
1085
1081
  e1->f_packObj      = (void (*)(void*,struct sidl_io_Serializer__object*,    \
1086
1082
    struct sidl_BaseInterface__object **)) epv->f_packObj;
1087
1083
  e1->f_unpackObj    = (void (*)(void*,struct sidl_io_Deserializer__object*,  \
1088
1084
    struct sidl_BaseInterface__object **)) epv->f_unpackObj;
1089
 
  e1->f_addRef       = (void (*)(void*,                                       \
1090
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1091
 
  e1->f_deleteRef    = (void (*)(void*,                                       \
1092
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1093
 
  e1->f_isSame       = (sidl_bool (*)(void*,                                  \
1094
 
    struct sidl_BaseInterface__object*,                                       \
1095
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1096
 
  e1->f_isType       = (sidl_bool (*)(void*,const char*,                      \
1097
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
1098
 
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,             \
1099
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1085
  e1->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1086
    epv->f_addRef;
 
1087
  e1->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1088
    epv->f_deleteRef;
 
1089
  e1->f_isSame       = (sidl_bool (*)(void*,struct                            \
 
1090
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1091
    epv->f_isSame;
 
1092
  e1->f_isType       = (sidl_bool (*)(void*,const char*,struct                \
 
1093
    sidl_BaseInterface__object **)) epv->f_isType;
 
1094
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct       \
 
1095
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
1100
1096
 
1101
 
  e2->f__cast        = (void* (*)(void*,const char*,                          \
1102
 
    sidl_BaseInterface*)) epv->f__cast;
 
1097
  e2->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*))     \
 
1098
    epv->f__cast;
1103
1099
  e2->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
1104
1100
  e2->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
1105
1101
  e2->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
1106
 
  e2->f__isRemote    = (sidl_bool (*)(void*,                                  \
1107
 
    sidl_BaseInterface*)) epv->f__isRemote;
1108
 
  e2->f__set_hooks   = (void (*)(void*,int32_t,                               \
1109
 
    sidl_BaseInterface*)) epv->f__set_hooks;
1110
 
  e2->f__exec        = (void (*)(void*,const char*,                           \
1111
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1112
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1113
 
  e2->f_addRef       = (void (*)(void*,                                       \
1114
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1115
 
  e2->f_deleteRef    = (void (*)(void*,                                       \
1116
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1117
 
  e2->f_isSame       = (sidl_bool (*)(void*,                                  \
1118
 
    struct sidl_BaseInterface__object*,                                       \
1119
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1120
 
  e2->f_isType       = (sidl_bool (*)(void*,const char*,                      \
1121
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
1122
 
  e2->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,             \
1123
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1102
  e2->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*))             \
 
1103
    epv->f__isRemote;
 
1104
  e2->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*))         \
 
1105
    epv->f__set_hooks;
 
1106
  e2->f__exec        = (void (*)(void*,const char*,struct                     \
 
1107
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
 
1108
    sidl_BaseInterface__object **)) epv->f__exec;
 
1109
  e2->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1110
    epv->f_addRef;
 
1111
  e2->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1112
    epv->f_deleteRef;
 
1113
  e2->f_isSame       = (sidl_bool (*)(void*,struct                            \
 
1114
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1115
    epv->f_isSame;
 
1116
  e2->f_isType       = (sidl_bool (*)(void*,const char*,struct                \
 
1117
    sidl_BaseInterface__object **)) epv->f_isType;
 
1118
  e2->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct       \
 
1119
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
1124
1120
 
1125
 
  e3->f__cast        = (void* (*)(void*,const char*,                          \
1126
 
    sidl_BaseInterface*)) epv->f__cast;
 
1121
  e3->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*))     \
 
1122
    epv->f__cast;
1127
1123
  e3->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
1128
1124
  e3->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
1129
1125
  e3->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
1130
 
  e3->f__isRemote    = (sidl_bool (*)(void*,                                  \
1131
 
    sidl_BaseInterface*)) epv->f__isRemote;
1132
 
  e3->f__set_hooks   = (void (*)(void*,int32_t,                               \
1133
 
    sidl_BaseInterface*)) epv->f__set_hooks;
1134
 
  e3->f__exec        = (void (*)(void*,const char*,                           \
1135
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1136
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1137
 
  e3->f_getNote      = (char* (*)(void*,                                      \
1138
 
    struct sidl_BaseInterface__object **)) epv->f_getNote;
1139
 
  e3->f_setNote      = (void (*)(void*,const char*,                           \
1140
 
    struct sidl_BaseInterface__object **)) epv->f_setNote;
1141
 
  e3->f_getTrace     = (char* (*)(void*,                                      \
1142
 
    struct sidl_BaseInterface__object **)) epv->f_getTrace;
1143
 
  e3->f_addLine      = (void (*)(void*,const char*,                           \
1144
 
    struct sidl_BaseInterface__object **)) epv->f_addLine;
1145
 
  e3->f_add          = (void (*)(void*,const char*,int32_t,const char*,       \
1146
 
    struct sidl_BaseInterface__object **)) epv->f_add;
 
1126
  e3->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*))             \
 
1127
    epv->f__isRemote;
 
1128
  e3->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*))         \
 
1129
    epv->f__set_hooks;
 
1130
  e3->f__exec        = (void (*)(void*,const char*,struct                     \
 
1131
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
 
1132
    sidl_BaseInterface__object **)) epv->f__exec;
 
1133
  e3->f_getNote      = (char* (*)(void*,struct sidl_BaseInterface__object     \
 
1134
    **)) epv->f_getNote;
 
1135
  e3->f_setNote      = (void (*)(void*,const char*,struct                     \
 
1136
    sidl_BaseInterface__object **)) epv->f_setNote;
 
1137
  e3->f_getTrace     = (char* (*)(void*,struct sidl_BaseInterface__object     \
 
1138
    **)) epv->f_getTrace;
 
1139
  e3->f_addLine      = (void (*)(void*,const char*,struct                     \
 
1140
    sidl_BaseInterface__object **)) epv->f_addLine;
 
1141
  e3->f_add          = (void (*)(void*,const char*,int32_t,const char*,struct \
 
1142
    sidl_BaseInterface__object **)) epv->f_add;
1147
1143
  e3->f_packObj      = (void (*)(void*,struct sidl_io_Serializer__object*,    \
1148
1144
    struct sidl_BaseInterface__object **)) epv->f_packObj;
1149
1145
  e3->f_unpackObj    = (void (*)(void*,struct sidl_io_Deserializer__object*,  \
1150
1146
    struct sidl_BaseInterface__object **)) epv->f_unpackObj;
1151
 
  e3->f_addRef       = (void (*)(void*,                                       \
1152
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1153
 
  e3->f_deleteRef    = (void (*)(void*,                                       \
1154
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1155
 
  e3->f_isSame       = (sidl_bool (*)(void*,                                  \
1156
 
    struct sidl_BaseInterface__object*,                                       \
1157
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1158
 
  e3->f_isType       = (sidl_bool (*)(void*,const char*,                      \
1159
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
1160
 
  e3->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,             \
1161
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1147
  e3->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1148
    epv->f_addRef;
 
1149
  e3->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1150
    epv->f_deleteRef;
 
1151
  e3->f_isSame       = (sidl_bool (*)(void*,struct                            \
 
1152
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1153
    epv->f_isSame;
 
1154
  e3->f_isType       = (sidl_bool (*)(void*,const char*,struct                \
 
1155
    sidl_BaseInterface__object **)) epv->f_isType;
 
1156
  e3->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct       \
 
1157
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
1162
1158
 
1163
 
  e4->f__cast        = (void* (*)(struct sidl_SIDLException__object*,         \
1164
 
    const char*,sidl_BaseInterface*)) epv->f__cast;
 
1159
  e4->f__cast        = (void* (*)(struct sidl_SIDLException__object*,const    \
 
1160
    char*,sidl_BaseInterface*)) epv->f__cast;
1165
1161
  e4->f__delete      = (void (*)(struct sidl_SIDLException__object*,          \
1166
1162
    sidl_BaseInterface*)) epv->f__delete;
1167
1163
  e4->f__getURL      = (char* (*)(struct sidl_SIDLException__object*,         \
1172
1168
    sidl_BaseInterface*)) epv->f__isRemote;
1173
1169
  e4->f__set_hooks   = (void (*)(struct sidl_SIDLException__object*,int32_t,  \
1174
1170
    sidl_BaseInterface*)) epv->f__set_hooks;
1175
 
  e4->f__exec        = (void (*)(struct sidl_SIDLException__object*,          \
1176
 
    const char*,struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,\
 
1171
  e4->f__exec        = (void (*)(struct sidl_SIDLException__object*,const     \
 
1172
    char*,struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,      \
1177
1173
    struct sidl_BaseInterface__object **)) epv->f__exec;
1178
 
  e4->f_addRef       = (void (*)(struct sidl_SIDLException__object*,          \
1179
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1180
 
  e4->f_deleteRef    = (void (*)(struct sidl_SIDLException__object*,          \
1181
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1174
  e4->f_addRef       = (void (*)(struct sidl_SIDLException__object*,struct    \
 
1175
    sidl_BaseInterface__object **)) epv->f_addRef;
 
1176
  e4->f_deleteRef    = (void (*)(struct sidl_SIDLException__object*,struct    \
 
1177
    sidl_BaseInterface__object **)) epv->f_deleteRef;
1182
1178
  e4->f_isSame       = (sidl_bool (*)(struct sidl_SIDLException__object*,     \
1183
 
    struct sidl_BaseInterface__object*,                                       \
1184
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
 
1179
    struct sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) \
 
1180
    epv->f_isSame;
1185
1181
  e4->f_isType       = (sidl_bool (*)(struct sidl_SIDLException__object*,     \
1186
1182
    const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
1187
1183
  e4->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct             \
1188
 
    sidl_SIDLException__object*,                                              \
1189
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
1190
 
  e4->f_getNote      = (char* (*)(struct sidl_SIDLException__object*,         \
1191
 
    struct sidl_BaseInterface__object **)) epv->f_getNote;
1192
 
  e4->f_setNote      = (void (*)(struct sidl_SIDLException__object*,          \
1193
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_setNote;
1194
 
  e4->f_getTrace     = (char* (*)(struct sidl_SIDLException__object*,         \
1195
 
    struct sidl_BaseInterface__object **)) epv->f_getTrace;
1196
 
  e4->f_addLine      = (void (*)(struct sidl_SIDLException__object*,          \
1197
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_addLine;
1198
 
  e4->f_add          = (void (*)(struct sidl_SIDLException__object*,          \
1199
 
    const char*,int32_t,const char*,                                          \
1200
 
    struct sidl_BaseInterface__object **)) epv->f_add;
1201
 
  e4->f_packObj      = (void (*)(struct sidl_SIDLException__object*,          \
1202
 
    struct sidl_io_Serializer__object*,                                       \
1203
 
    struct sidl_BaseInterface__object **)) epv->f_packObj;
1204
 
  e4->f_unpackObj    = (void (*)(struct sidl_SIDLException__object*,          \
1205
 
    struct sidl_io_Deserializer__object*,                                     \
1206
 
    struct sidl_BaseInterface__object **)) epv->f_unpackObj;
 
1184
    sidl_SIDLException__object*,struct sidl_BaseInterface__object **))        \
 
1185
    epv->f_getClassInfo;
 
1186
  e4->f_getNote      = (char* (*)(struct sidl_SIDLException__object*,struct   \
 
1187
    sidl_BaseInterface__object **)) epv->f_getNote;
 
1188
  e4->f_setNote      = (void (*)(struct sidl_SIDLException__object*,const     \
 
1189
    char*,struct sidl_BaseInterface__object **)) epv->f_setNote;
 
1190
  e4->f_getTrace     = (char* (*)(struct sidl_SIDLException__object*,struct   \
 
1191
    sidl_BaseInterface__object **)) epv->f_getTrace;
 
1192
  e4->f_addLine      = (void (*)(struct sidl_SIDLException__object*,const     \
 
1193
    char*,struct sidl_BaseInterface__object **)) epv->f_addLine;
 
1194
  e4->f_add          = (void (*)(struct sidl_SIDLException__object*,const     \
 
1195
    char*,int32_t,const char*,struct sidl_BaseInterface__object **))          \
 
1196
    epv->f_add;
 
1197
  e4->f_packObj      = (void (*)(struct sidl_SIDLException__object*,struct    \
 
1198
    sidl_io_Serializer__object*,struct sidl_BaseInterface__object **))        \
 
1199
    epv->f_packObj;
 
1200
  e4->f_unpackObj    = (void (*)(struct sidl_SIDLException__object*,struct    \
 
1201
    sidl_io_Deserializer__object*,struct sidl_BaseInterface__object **))      \
 
1202
    epv->f_unpackObj;
1207
1203
 
1208
 
  e5->f__cast        = (void* (*)(struct sidl_io_IOException__object*,        \
1209
 
    const char*,sidl_BaseInterface*)) epv->f__cast;
 
1204
  e5->f__cast        = (void* (*)(struct sidl_io_IOException__object*,const   \
 
1205
    char*,sidl_BaseInterface*)) epv->f__cast;
1210
1206
  e5->f__delete      = (void (*)(struct sidl_io_IOException__object*,         \
1211
1207
    sidl_BaseInterface*)) epv->f__delete;
1212
1208
  e5->f__getURL      = (char* (*)(struct sidl_io_IOException__object*,        \
1217
1213
    sidl_BaseInterface*)) epv->f__isRemote;
1218
1214
  e5->f__set_hooks   = (void (*)(struct sidl_io_IOException__object*,int32_t, \
1219
1215
    sidl_BaseInterface*)) epv->f__set_hooks;
1220
 
  e5->f__exec        = (void (*)(struct sidl_io_IOException__object*,         \
1221
 
    const char*,struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,\
 
1216
  e5->f__exec        = (void (*)(struct sidl_io_IOException__object*,const    \
 
1217
    char*,struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,      \
1222
1218
    struct sidl_BaseInterface__object **)) epv->f__exec;
1223
 
  e5->f_addRef       = (void (*)(struct sidl_io_IOException__object*,         \
1224
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1225
 
  e5->f_deleteRef    = (void (*)(struct sidl_io_IOException__object*,         \
1226
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1219
  e5->f_addRef       = (void (*)(struct sidl_io_IOException__object*,struct   \
 
1220
    sidl_BaseInterface__object **)) epv->f_addRef;
 
1221
  e5->f_deleteRef    = (void (*)(struct sidl_io_IOException__object*,struct   \
 
1222
    sidl_BaseInterface__object **)) epv->f_deleteRef;
1227
1223
  e5->f_isSame       = (sidl_bool (*)(struct sidl_io_IOException__object*,    \
1228
 
    struct sidl_BaseInterface__object*,                                       \
1229
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
 
1224
    struct sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) \
 
1225
    epv->f_isSame;
1230
1226
  e5->f_isType       = (sidl_bool (*)(struct sidl_io_IOException__object*,    \
1231
1227
    const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
1232
1228
  e5->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct             \
1233
 
    sidl_io_IOException__object*,                                             \
1234
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
1235
 
  e5->f_getNote      = (char* (*)(struct sidl_io_IOException__object*,        \
1236
 
    struct sidl_BaseInterface__object **)) epv->f_getNote;
1237
 
  e5->f_setNote      = (void (*)(struct sidl_io_IOException__object*,         \
1238
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_setNote;
1239
 
  e5->f_getTrace     = (char* (*)(struct sidl_io_IOException__object*,        \
1240
 
    struct sidl_BaseInterface__object **)) epv->f_getTrace;
1241
 
  e5->f_addLine      = (void (*)(struct sidl_io_IOException__object*,         \
1242
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_addLine;
1243
 
  e5->f_add          = (void (*)(struct sidl_io_IOException__object*,         \
1244
 
    const char*,int32_t,const char*,                                          \
1245
 
    struct sidl_BaseInterface__object **)) epv->f_add;
1246
 
  e5->f_packObj      = (void (*)(struct sidl_io_IOException__object*,         \
1247
 
    struct sidl_io_Serializer__object*,                                       \
1248
 
    struct sidl_BaseInterface__object **)) epv->f_packObj;
1249
 
  e5->f_unpackObj    = (void (*)(struct sidl_io_IOException__object*,         \
1250
 
    struct sidl_io_Deserializer__object*,                                     \
1251
 
    struct sidl_BaseInterface__object **)) epv->f_unpackObj;
 
1229
    sidl_io_IOException__object*,struct sidl_BaseInterface__object **))       \
 
1230
    epv->f_getClassInfo;
 
1231
  e5->f_getNote      = (char* (*)(struct sidl_io_IOException__object*,struct  \
 
1232
    sidl_BaseInterface__object **)) epv->f_getNote;
 
1233
  e5->f_setNote      = (void (*)(struct sidl_io_IOException__object*,const    \
 
1234
    char*,struct sidl_BaseInterface__object **)) epv->f_setNote;
 
1235
  e5->f_getTrace     = (char* (*)(struct sidl_io_IOException__object*,struct  \
 
1236
    sidl_BaseInterface__object **)) epv->f_getTrace;
 
1237
  e5->f_addLine      = (void (*)(struct sidl_io_IOException__object*,const    \
 
1238
    char*,struct sidl_BaseInterface__object **)) epv->f_addLine;
 
1239
  e5->f_add          = (void (*)(struct sidl_io_IOException__object*,const    \
 
1240
    char*,int32_t,const char*,struct sidl_BaseInterface__object **))          \
 
1241
    epv->f_add;
 
1242
  e5->f_packObj      = (void (*)(struct sidl_io_IOException__object*,struct   \
 
1243
    sidl_io_Serializer__object*,struct sidl_BaseInterface__object **))        \
 
1244
    epv->f_packObj;
 
1245
  e5->f_unpackObj    = (void (*)(struct sidl_io_IOException__object*,struct   \
 
1246
    sidl_io_Deserializer__object*,struct sidl_BaseInterface__object **))      \
 
1247
    epv->f_unpackObj;
1252
1248
 
1253
 
  e6->f__cast        = (void* (*)(void*,const char*,                          \
1254
 
    sidl_BaseInterface*)) epv->f__cast;
 
1249
  e6->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*))     \
 
1250
    epv->f__cast;
1255
1251
  e6->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
1256
1252
  e6->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
1257
1253
  e6->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
1258
 
  e6->f__isRemote    = (sidl_bool (*)(void*,                                  \
1259
 
    sidl_BaseInterface*)) epv->f__isRemote;
1260
 
  e6->f__set_hooks   = (void (*)(void*,int32_t,                               \
1261
 
    sidl_BaseInterface*)) epv->f__set_hooks;
1262
 
  e6->f__exec        = (void (*)(void*,const char*,                           \
1263
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1264
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
 
1254
  e6->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*))             \
 
1255
    epv->f__isRemote;
 
1256
  e6->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*))         \
 
1257
    epv->f__set_hooks;
 
1258
  e6->f__exec        = (void (*)(void*,const char*,struct                     \
 
1259
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
 
1260
    sidl_BaseInterface__object **)) epv->f__exec;
1265
1261
  e6->f_packObj      = (void (*)(void*,struct sidl_io_Serializer__object*,    \
1266
1262
    struct sidl_BaseInterface__object **)) epv->f_packObj;
1267
1263
  e6->f_unpackObj    = (void (*)(void*,struct sidl_io_Deserializer__object*,  \
1268
1264
    struct sidl_BaseInterface__object **)) epv->f_unpackObj;
1269
 
  e6->f_addRef       = (void (*)(void*,                                       \
1270
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1271
 
  e6->f_deleteRef    = (void (*)(void*,                                       \
1272
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1273
 
  e6->f_isSame       = (sidl_bool (*)(void*,                                  \
1274
 
    struct sidl_BaseInterface__object*,                                       \
1275
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1276
 
  e6->f_isType       = (sidl_bool (*)(void*,const char*,                      \
1277
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
1278
 
  e6->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,             \
1279
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1265
  e6->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1266
    epv->f_addRef;
 
1267
  e6->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1268
    epv->f_deleteRef;
 
1269
  e6->f_isSame       = (sidl_bool (*)(void*,struct                            \
 
1270
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1271
    epv->f_isSame;
 
1272
  e6->f_isType       = (sidl_bool (*)(void*,const char*,struct                \
 
1273
    sidl_BaseInterface__object **)) epv->f_isType;
 
1274
  e6->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct       \
 
1275
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
1280
1276
 
1281
1277
  e7->f__cast        = (void* (*)(struct sidl_rmi_NetworkException__object*,  \
1282
1278
    const char*,sidl_BaseInterface*)) epv->f__cast;
1303
1299
    sidl_rmi_NetworkException__object*,struct sidl_BaseInterface__object*,    \
1304
1300
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1305
1301
  e7->f_isType       = (sidl_bool (*)(struct                                  \
1306
 
    sidl_rmi_NetworkException__object*,const char*,                           \
1307
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
1302
    sidl_rmi_NetworkException__object*,const char*,struct                     \
 
1303
    sidl_BaseInterface__object **)) epv->f_isType;
1308
1304
  e7->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct             \
1309
 
    sidl_rmi_NetworkException__object*,                                       \
1310
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1305
    sidl_rmi_NetworkException__object*,struct sidl_BaseInterface__object **)) \
 
1306
    epv->f_getClassInfo;
1311
1307
  e7->f_getNote      = (char* (*)(struct sidl_rmi_NetworkException__object*,  \
1312
1308
    struct sidl_BaseInterface__object **)) epv->f_getNote;
1313
1309
  e7->f_setNote      = (void (*)(struct sidl_rmi_NetworkException__object*,   \
1317
1313
  e7->f_addLine      = (void (*)(struct sidl_rmi_NetworkException__object*,   \
1318
1314
    const char*,struct sidl_BaseInterface__object **)) epv->f_addLine;
1319
1315
  e7->f_add          = (void (*)(struct sidl_rmi_NetworkException__object*,   \
1320
 
    const char*,int32_t,const char*,                                          \
1321
 
    struct sidl_BaseInterface__object **)) epv->f_add;
 
1316
    const char*,int32_t,const char*,struct sidl_BaseInterface__object **))    \
 
1317
    epv->f_add;
1322
1318
  e7->f_packObj      = (void (*)(struct sidl_rmi_NetworkException__object*,   \
1323
 
    struct sidl_io_Serializer__object*,                                       \
1324
 
    struct sidl_BaseInterface__object **)) epv->f_packObj;
 
1319
    struct sidl_io_Serializer__object*,struct sidl_BaseInterface__object **)) \
 
1320
    epv->f_packObj;
1325
1321
  e7->f_unpackObj    = (void (*)(struct sidl_rmi_NetworkException__object*,   \
1326
 
    struct sidl_io_Deserializer__object*,                                     \
1327
 
    struct sidl_BaseInterface__object **)) epv->f_unpackObj;
 
1322
    struct sidl_io_Deserializer__object*,struct sidl_BaseInterface__object    \
 
1323
    **)) epv->f_unpackObj;
1328
1324
 
1329
1325
  s_remote_initialized = 1;
1330
1326
}
1350
1346
  if(url == NULL) {return NULL;}
1351
1347
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
1352
1348
  if(objectID) {
1353
 
    sidl_BaseInterface bi =                                                   \
1354
 
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(      \
 
1349
    sidl_BaseInterface bi = (                                                 \
 
1350
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(       \
1355
1351
      objectID, _ex); SIDL_CHECK(*_ex);
1356
1352
    return sidlx_rmi_GenNetworkException__rmicast(bi,_ex);SIDL_CHECK(*_ex);
1357
1353
  }
1358
 
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar,                \
1359
 
    _ex ); SIDL_CHECK(*_ex);
 
1354
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex );         \
 
1355
    SIDL_CHECK(*_ex);
1360
1356
  if ( instance == NULL) { return NULL; }
1361
1357
  self =
1362
1358
    (struct sidlx_rmi_GenNetworkException__object*) malloc(
1501
1497
  struct sidl_BaseClass__object* s4;
1502
1498
 
1503
1499
  struct sidlx_rmi_GenNetworkException__remote* r_obj;
1504
 
  sidl_rmi_InstanceHandle instance =                                          \
1505
 
    sidl_rmi_ProtocolFactory_createInstance(url,                              \
1506
 
    "sidlx.rmi.GenNetworkException", _ex ); SIDL_CHECK(*_ex);
 
1500
  sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance( \
 
1501
    url, "sidlx.rmi.GenNetworkException", _ex ); SIDL_CHECK(*_ex);
1507
1502
  if ( instance == NULL) { return NULL; }
1508
1503
  self =
1509
1504
    (struct sidlx_rmi_GenNetworkException__object*) malloc(
1583
1578
  if (obj != NULL) {
1584
1579
    struct sidl_BaseInterface__object* base = (struct                         \
1585
1580
      sidl_BaseInterface__object*) obj;
1586
 
    cast = (struct sidlx_rmi_GenNetworkException__object*)                    \
1587
 
      (*base->d_epv->f__cast)(
 
1581
    cast = (struct sidlx_rmi_GenNetworkException__object*) (                  \
 
1582
      *base->d_epv->f__cast)(
1588
1583
      base->d_object,
1589
1584
      "sidlx.rmi.GenNetworkException", _ex); SIDL_CHECK(*_ex);
1590
1585
  }
1599
1594
 */
1600
1595
 
1601
1596
struct sidlx_rmi_GenNetworkException__object*
1602
 
sidlx_rmi_GenNetworkException__connectI(const char* url, sidl_bool ar,        \
1603
 
  struct sidl_BaseInterface__object **_ex)
 
1597
sidlx_rmi_GenNetworkException__connectI(const char* url, sidl_bool ar, struct \
 
1598
  sidl_BaseInterface__object **_ex)
1604
1599
{
1605
1600
  return sidlx_rmi_GenNetworkException__remoteConnect(url, ar, _ex);
1606
1601
}
1629
1624
      sidl_PyExceptionCast(_exception, "sidl.rmi.NetworkException"))) {
1630
1625
        struct sidl_BaseInterface__object *throwaway_exception;
1631
1626
        PyObject *_obj = sidl_rmi_NetworkException__wrap(_ex0);
1632
 
        PyObject *_args = PyTuple_New(1);
1633
 
        PyTuple_SetItem(_args, 0, _obj);
1634
 
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _args);
 
1627
        PyObject *_eargs = PyTuple_New(1);
 
1628
        PyTuple_SetItem(_eargs, 0, _obj);
 
1629
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _eargs);
1635
1630
        PyErr_SetObject(sidl_rmi_NetworkException__type, _obj);
1636
1631
        Py_XDECREF(_obj);
1637
1632
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
1638
1633
          &throwaway_exception);
1639
 
        Py_XDECREF(_args);
 
1634
        Py_XDECREF(_eargs);
1640
1635
      }
1641
1636
    }
1642
1637
    else {
1653
1648
static const struct sidlx_rmi_GenNetworkException__external *_implEPV = NULL;
1654
1649
 
1655
1650
static PyObject *
1656
 
pStub_GenNetworkException__exec(PyObject *_self, PyObject *_args,             \
1657
 
  PyObject *_kwdict) {
 
1651
pStub_GenNetworkException__exec(PyObject *_self, PyObject *_args, PyObject    \
 
1652
  *_kwdict) {
1658
1653
  PyObject *_return_value = NULL;
1659
1654
  struct sidlx_rmi_GenNetworkException__object *_self_ior =
1660
1655
    ((struct sidlx_rmi_GenNetworkException__object *)
1689
1684
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
1690
1685
          struct sidl_BaseInterface__object *throwaway_exception;
1691
1686
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
1692
 
          PyObject *_args = PyTuple_New(1);
1693
 
          PyTuple_SetItem(_args, 0, _obj);
1694
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
1687
          PyObject *_eargs = PyTuple_New(1);
 
1688
          PyTuple_SetItem(_eargs, 0, _obj);
 
1689
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
1695
1690
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
1696
1691
          Py_XDECREF(_obj);
1697
1692
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
1698
1693
            &throwaway_exception);
1699
 
          Py_XDECREF(_args);
 
1694
          Py_XDECREF(_eargs);
1700
1695
        }
1701
1696
      }
1702
1697
      else {
1719
1714
}
1720
1715
 
1721
1716
static PyObject *
1722
 
pStub_GenNetworkException__getURL(PyObject *_self, PyObject *_args,           \
1723
 
  PyObject *_kwdict) {
 
1717
pStub_GenNetworkException__getURL(PyObject *_self, PyObject *_args, PyObject  \
 
1718
  *_kwdict) {
1724
1719
  PyObject *_return_value = NULL;
1725
1720
  struct sidlx_rmi_GenNetworkException__object *_self_ior =
1726
1721
    ((struct sidlx_rmi_GenNetworkException__object *)
1744
1739
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
1745
1740
          struct sidl_BaseInterface__object *throwaway_exception;
1746
1741
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
1747
 
          PyObject *_args = PyTuple_New(1);
1748
 
          PyTuple_SetItem(_args, 0, _obj);
1749
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
1742
          PyObject *_eargs = PyTuple_New(1);
 
1743
          PyTuple_SetItem(_eargs, 0, _obj);
 
1744
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
1750
1745
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
1751
1746
          Py_XDECREF(_obj);
1752
1747
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
1753
1748
            &throwaway_exception);
1754
 
          Py_XDECREF(_args);
 
1749
          Py_XDECREF(_eargs);
1755
1750
        }
1756
1751
      }
1757
1752
      else {
1758
1753
        _return_value = Py_BuildValue(
1759
1754
          "z",
1760
1755
          _return);
 
1756
        free((void *)_return);
1761
1757
      }
1762
 
      free((void *)_return);
1763
1758
    }
1764
1759
    {
1765
1760
      struct sidl_BaseInterface__object *throwaway_exception;
1774
1769
}
1775
1770
 
1776
1771
static PyObject *
1777
 
pStub_GenNetworkException__isLocal(PyObject *_self, PyObject *_args,          \
1778
 
  PyObject *_kwdict) {
 
1772
pStub_GenNetworkException__isLocal(PyObject *_self, PyObject *_args, PyObject \
 
1773
  *_kwdict) {
1779
1774
  PyObject *_return_value = NULL;
1780
1775
  struct sidlx_rmi_GenNetworkException__object *_self_ior =
1781
1776
    ((struct sidlx_rmi_GenNetworkException__object *)
1801
1796
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
1802
1797
          struct sidl_BaseInterface__object *throwaway_exception;
1803
1798
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
1804
 
          PyObject *_args = PyTuple_New(1);
1805
 
          PyTuple_SetItem(_args, 0, _obj);
1806
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
1799
          PyObject *_eargs = PyTuple_New(1);
 
1800
          PyTuple_SetItem(_eargs, 0, _obj);
 
1801
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
1807
1802
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
1808
1803
          Py_XDECREF(_obj);
1809
1804
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
1810
1805
            &throwaway_exception);
1811
 
          Py_XDECREF(_args);
 
1806
          Py_XDECREF(_eargs);
1812
1807
        }
1813
1808
      }
1814
1809
      else {
1857
1852
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
1858
1853
          struct sidl_BaseInterface__object *throwaway_exception;
1859
1854
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
1860
 
          PyObject *_args = PyTuple_New(1);
1861
 
          PyTuple_SetItem(_args, 0, _obj);
1862
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
1855
          PyObject *_eargs = PyTuple_New(1);
 
1856
          PyTuple_SetItem(_eargs, 0, _obj);
 
1857
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
1863
1858
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
1864
1859
          Py_XDECREF(_obj);
1865
1860
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
1866
1861
            &throwaway_exception);
1867
 
          Py_XDECREF(_args);
 
1862
          Py_XDECREF(_eargs);
1868
1863
        }
1869
1864
      }
1870
1865
      else {
1915
1910
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
1916
1911
          struct sidl_BaseInterface__object *throwaway_exception;
1917
1912
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
1918
 
          PyObject *_args = PyTuple_New(1);
1919
 
          PyTuple_SetItem(_args, 0, _obj);
1920
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
1913
          PyObject *_eargs = PyTuple_New(1);
 
1914
          PyTuple_SetItem(_eargs, 0, _obj);
 
1915
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
1921
1916
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
1922
1917
          Py_XDECREF(_obj);
1923
1918
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
1924
1919
            &throwaway_exception);
1925
 
          Py_XDECREF(_args);
 
1920
          Py_XDECREF(_eargs);
1926
1921
        }
1927
1922
      }
1928
1923
      else {
1949
1944
  char* url = NULL;
1950
1945
  PyObject * implObj = NULL;
1951
1946
  static char *_kwlist[] = {"sobj",  "url", "impl", NULL };
1952
 
  int _okay = PyArg_ParseTupleAndKeywords(args, kwds, "|O&zO", _kwlist,       \
1953
 
    (void *)sidlx_rmi_GenNetworkException__convert, &optarg, &url, &implObj);
 
1947
  int _okay = PyArg_ParseTupleAndKeywords(args, kwds, "|O&zO", _kwlist, (void \
 
1948
    *)sidlx_rmi_GenNetworkException__convert, &optarg, &url, &implObj);
1954
1949
  if (_okay) {
1955
1950
    if (!optarg && !url && !implObj) {
1956
1951
      struct sidl_BaseInterface__object *_exception;
1963
1958
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
1964
1959
            struct sidl_BaseInterface__object *throwaway_exception;
1965
1960
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
1966
 
            PyObject *_args = PyTuple_New(1);
1967
 
            PyTuple_SetItem(_args, 0, _obj);
1968
 
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
1961
            PyObject *_eargs = PyTuple_New(1);
 
1962
            PyTuple_SetItem(_eargs, 0, _obj);
 
1963
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
1969
1964
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
1970
1965
            Py_XDECREF(_obj);
1971
1966
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,         \
1972
1967
              &throwaway_exception);
1973
 
            Py_XDECREF(_args);
 
1968
            Py_XDECREF(_eargs);
1974
1969
          }
1975
1970
          return -1;
1976
1971
        }
1988
1983
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
1989
1984
            struct sidl_BaseInterface__object *throwaway_exception;
1990
1985
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
1991
 
            PyObject *_args = PyTuple_New(1);
1992
 
            PyTuple_SetItem(_args, 0, _obj);
1993
 
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
1986
            PyObject *_eargs = PyTuple_New(1);
 
1987
            PyTuple_SetItem(_eargs, 0, _obj);
 
1988
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
1994
1989
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
1995
1990
            Py_XDECREF(_obj);
1996
1991
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,         \
1997
1992
              &throwaway_exception);
1998
 
            Py_XDECREF(_args);
 
1993
            Py_XDECREF(_eargs);
1999
1994
          }
2000
1995
          return -1;
2001
1996
        }
2011
2006
      sidl_PyExceptionCast(_exception, "sidl.rmi.NetworkException"))) {
2012
2007
        struct sidl_BaseInterface__object *throwaway_exception;
2013
2008
        PyObject *_obj = sidl_rmi_NetworkException__wrap(_ex0);
2014
 
        PyObject *_args = PyTuple_New(1);
2015
 
        PyTuple_SetItem(_args, 0, _obj);
2016
 
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _args);
 
2009
        PyObject *_eargs = PyTuple_New(1);
 
2010
        PyTuple_SetItem(_eargs, 0, _obj);
 
2011
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _eargs);
2017
2012
        PyErr_SetObject(sidl_rmi_NetworkException__type, _obj);
2018
2013
        Py_XDECREF(_obj);
2019
2014
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
2020
2015
          &throwaway_exception);
2021
 
        Py_XDECREF(_args);
 
2016
        Py_XDECREF(_eargs);
2022
2017
      }
2023
2018
      return -1;
2024
2019
    }
2166
2161
  {
2167
2162
  PyObject *result;
2168
2163
  if (sidlobj) {
2169
 
    result =                                                                  \
2170
 
      _sidlx_rmi_GenNetworkExceptionType.tp_new(                              \
 
2164
    result = _sidlx_rmi_GenNetworkExceptionType.tp_new(                       \
2171
2165
      &_sidlx_rmi_GenNetworkExceptionType, NULL, NULL);
2172
2166
    if (result) {
2173
2167
      if (sidl_Object_Init(
2192
2186
  sidlx_rmi_GenNetworkException__weakRef_PROTO {
2193
2187
  PyObject *result;
2194
2188
  if (sidlobj) {
2195
 
    result =                                                                  \
2196
 
      _sidlx_rmi_GenNetworkExceptionType.tp_new(                              \
 
2189
    result = _sidlx_rmi_GenNetworkExceptionType.tp_new(                       \
2197
2190
      &_sidlx_rmi_GenNetworkExceptionType, NULL, NULL);
2198
2191
    if (result) {
2199
2192
      if (sidl_Object_Init(
2227
2220
  sidlx_rmi_GenNetworkException__newRef_PROTO {
2228
2221
  PyObject *result;
2229
2222
  if (sidlobj) {
2230
 
    result =                                                                  \
2231
 
      _sidlx_rmi_GenNetworkExceptionType.tp_new(                              \
 
2223
    result = _sidlx_rmi_GenNetworkExceptionType.tp_new(                       \
2232
2224
      &_sidlx_rmi_GenNetworkExceptionType, NULL, NULL);
2233
2225
    if (result) {
2234
2226
      if (sidl_Object_Init(
2390
2382
Generic Network Exception"
2391
2383
  );
2392
2384
  dict = PyModule_GetDict(module);
2393
 
  ExternalAPI[sidlx_rmi_GenNetworkException__wrap_NUM] =                      \
2394
 
    (void*)sidlx_rmi_GenNetworkException__wrap;
2395
 
  ExternalAPI[sidlx_rmi_GenNetworkException__convert_NUM] =                   \
2396
 
    (void*)sidlx_rmi_GenNetworkException__convert;
2397
 
  ExternalAPI[sidlx_rmi_GenNetworkException__convert_python_array_NUM] =      \
2398
 
    (void*)sidlx_rmi_GenNetworkException__convert_python_array;
2399
 
  ExternalAPI[sidlx_rmi_GenNetworkException__convert_sidl_array_NUM] =        \
2400
 
    (void*)sidlx_rmi_GenNetworkException__convert_sidl_array;
2401
 
  ExternalAPI[sidlx_rmi_GenNetworkException__weakRef_NUM] =                   \
2402
 
    (void*)sidlx_rmi_GenNetworkException__weakRef;
2403
 
  ExternalAPI[sidlx_rmi_GenNetworkException_deref_NUM] =                      \
2404
 
    (void*)sidlx_rmi_GenNetworkException_deref;
2405
 
  ExternalAPI[sidlx_rmi_GenNetworkException__newRef_NUM] =                    \
2406
 
    (void*)sidlx_rmi_GenNetworkException__newRef;
2407
 
  ExternalAPI[sidlx_rmi_GenNetworkException__addRef_NUM] =                    \
2408
 
    (void*)sidlx_rmi_GenNetworkException__addRef;
2409
 
  ExternalAPI[sidlx_rmi_GenNetworkException_PyType_NUM] =                     \
2410
 
    (void*)sidlx_rmi_GenNetworkException_PyType;
2411
 
  ExternalAPI[sidlx_rmi_GenNetworkException__connectI_NUM] =                  \
2412
 
    (void*)sidlx_rmi_GenNetworkException__connectI;
2413
 
  ExternalAPI[sidlx_rmi_GenNetworkException__rmicast_NUM] =                   \
2414
 
    (void*)sidlx_rmi_GenNetworkException__rmicast;
 
2385
  ExternalAPI[sidlx_rmi_GenNetworkException__wrap_NUM] = (                    \
 
2386
    void*)sidlx_rmi_GenNetworkException__wrap;
 
2387
  ExternalAPI[sidlx_rmi_GenNetworkException__convert_NUM] = (                 \
 
2388
    void*)sidlx_rmi_GenNetworkException__convert;
 
2389
  ExternalAPI[sidlx_rmi_GenNetworkException__convert_python_array_NUM] = (    \
 
2390
    void*)sidlx_rmi_GenNetworkException__convert_python_array;
 
2391
  ExternalAPI[sidlx_rmi_GenNetworkException__convert_sidl_array_NUM] = (      \
 
2392
    void*)sidlx_rmi_GenNetworkException__convert_sidl_array;
 
2393
  ExternalAPI[sidlx_rmi_GenNetworkException__weakRef_NUM] = (                 \
 
2394
    void*)sidlx_rmi_GenNetworkException__weakRef;
 
2395
  ExternalAPI[sidlx_rmi_GenNetworkException_deref_NUM] = (                    \
 
2396
    void*)sidlx_rmi_GenNetworkException_deref;
 
2397
  ExternalAPI[sidlx_rmi_GenNetworkException__newRef_NUM] = (                  \
 
2398
    void*)sidlx_rmi_GenNetworkException__newRef;
 
2399
  ExternalAPI[sidlx_rmi_GenNetworkException__addRef_NUM] = (                  \
 
2400
    void*)sidlx_rmi_GenNetworkException__addRef;
 
2401
  ExternalAPI[sidlx_rmi_GenNetworkException_PyType_NUM] = (                   \
 
2402
    void*)sidlx_rmi_GenNetworkException_PyType;
 
2403
  ExternalAPI[sidlx_rmi_GenNetworkException__connectI_NUM] = (                \
 
2404
    void*)sidlx_rmi_GenNetworkException__connectI;
 
2405
  ExternalAPI[sidlx_rmi_GenNetworkException__rmicast_NUM] = (                 \
 
2406
    void*)sidlx_rmi_GenNetworkException__rmicast;
2415
2407
  import_SIDLObjA();
2416
2408
  if (PyErr_Occurred()) {
2417
2409
    Py_FatalError("Error importing sidlObjA module.");
2434
2426
  _sidlx_rmi_GenNetworkExceptionType.tp_base =                                \
2435
2427
    sidl_rmi_NetworkException_PyType();
2436
2428
  _sidlx_rmi_GenNetworkExceptionType.tp_bases = PyTuple_New(1);
2437
 
  PyTuple_SetItem(_sidlx_rmi_GenNetworkExceptionType.tp_bases,0,              \
2438
 
    (PyObject *)sidl_rmi_NetworkException_PyType());
 
2429
  PyTuple_SetItem(_sidlx_rmi_GenNetworkExceptionType.tp_bases,0, (PyObject    \
 
2430
    *)sidl_rmi_NetworkException_PyType());
2439
2431
  if (PyType_Ready(&_sidlx_rmi_GenNetworkExceptionType) < 0) {
2440
2432
    PyErr_Print();
2441
 
    fprintf(stderr,                                                           \
2442
 
      "PyType_Ready on sidlx.rmi.GenNetworkException failed.\n");
 
2433
    fprintf(stderr, "PyType_Ready on sidlx.rmi.GenNetworkException            \
 
2434
      failed.\n");
2443
2435
    return;
2444
2436
  }
2445
2437
  Py_INCREF(&_sidlx_rmi_GenNetworkExceptionType);
2446
 
  PyDict_SetItemString(dict, "GenNetworkException",                           \
2447
 
    (PyObject *)&_sidlx_rmi_GenNetworkExceptionType);
 
2438
  PyDict_SetItemString(dict, "GenNetworkException", (PyObject                 \
 
2439
    *)&_sidlx_rmi_GenNetworkExceptionType);
2448
2440
  _exceptionBases = PyTuple_New(1);
2449
2441
  Py_INCREF(sidl_rmi_NetworkException__type);
2450
2442
  PyTuple_SetItem(_exceptionBases, 0, sidl_rmi_NetworkException__type);
2504
2496
      sidlx.rmi.GenNetworkException");
2505
2497
  }
2506
2498
 
2507
 
  sidl_rmi_ConnectRegistry_registerConnect("sidlx.rmi.GenNetworkException",   \
2508
 
    (void*)sidlx_rmi_GenNetworkException__IHConnect, &throwaway_exception);
 
2499
  sidl_rmi_ConnectRegistry_registerConnect("sidlx.rmi.GenNetworkException", ( \
 
2500
    void*)sidlx_rmi_GenNetworkException__IHConnect, &throwaway_exception);
2509
2501
}