← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/babel/bHYPREClient-F/sidl_BaseException_fStub.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/bHYPREClient-F/sidl_BaseException_fStub.c
2
2
 * File:          sidl_BaseException_fStub.c
3
3
 * Symbol:        sidl.BaseException-v0.9.15
4
4
 * Symbol Type:   interface
5
 
 * Babel Version: 1.0.0
6
 
 * Release:       $Name:  $
7
 
 * Revision:      @(#) $Id: sidl_BaseException_fStub.c,v 1.38 2006/09/14 21:51:51 painter Exp $
 
5
 * Babel Version: 1.0.4
 
6
 * Release:       $Name: V2-4-0b $
 
7
 * Revision:      @(#) $Id: sidl_BaseException_fStub.c,v 1.40 2007/09/27 19:56:34 painter Exp $
8
8
 * Description:   Client-side glue code for sidl.BaseException
9
9
 * 
10
10
 * Copyright (c) 2000-2002, The Regents of the University of California.
99
99
 
100
100
static int connect_loaded = 0;
101
101
 
102
 
static struct sidl_BaseException__object* 
103
 
  sidl_BaseException__remoteConnect(const char* url, sidl_bool ar,
104
 
  sidl_BaseInterface *_ex);
 
102
static struct sidl_BaseException__object* sidl_BaseException__remoteConnect(
 
103
  const char* url, sidl_bool ar, sidl_BaseInterface *_ex);
105
104
static struct sidl_BaseException__object* sidl_BaseException__IHConnect(struct 
106
 
  sidl_rmi_InstanceHandle__object *instance,
107
 
  struct sidl_BaseInterface__object **_ex);
 
105
  sidl_rmi_InstanceHandle__object *instance, struct sidl_BaseInterface__object 
 
106
  **_ex);
108
107
/*
109
108
 * Remote Connector for the class.
110
109
 */
123
122
  char* _proxy_url = NULL;
124
123
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
125
124
  _proxy_url =
126
 
    sidl_copy_fortran_str(SIDL_F77_STR(url),
 
125
    sidl_copy_fortran_str(SIDL_F77_STR(url),(ptrdiff_t)
127
126
      SIDL_F77_STR_LEN(url));
128
 
  _proxy_self = sidl_BaseException__remoteConnect(_proxy_url, 1,
 
127
  _proxy_self = sidl_BaseException__remoteConnect(_proxy_url, 1, 
129
128
    &_proxy_exception);
130
129
  if (_proxy_exception) {
131
130
    *exception = (ptrdiff_t)_proxy_exception;
154
153
 
155
154
  *retval = 0;
156
155
  if(!connect_loaded) {
157
 
    sidl_rmi_ConnectRegistry_registerConnect("sidl.BaseException",
158
 
      (void*)sidl_BaseException__IHConnect, &proxy_exception);
 
156
    sidl_rmi_ConnectRegistry_registerConnect("sidl.BaseException", (
 
157
      void*)sidl_BaseException__IHConnect, &proxy_exception);
159
158
    SIDL_CHECK(proxy_exception);
160
159
    connect_loaded = 1;
161
160
  }
197
196
    (struct sidl_BaseException__object*)
198
197
    (ptrdiff_t)(*self);
199
198
  _proxy_name =
200
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
199
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
201
200
      SIDL_F77_STR_LEN(name));
202
201
  _epv = _proxy_self->d_epv;
203
202
  _proxy_retval = 
243
242
    (struct sidl_BaseException__object*)
244
243
    (ptrdiff_t)(*self);
245
244
  _proxy_methodName =
246
 
    sidl_copy_fortran_str(SIDL_F77_STR(methodName),
 
245
    sidl_copy_fortran_str(SIDL_F77_STR(methodName),(ptrdiff_t)
247
246
      SIDL_F77_STR_LEN(methodName));
248
247
  _proxy_inArgs =
249
248
    (struct sidl_rmi_Call__object*)
302
301
  else {
303
302
    *exception = (ptrdiff_t)NULL;
304
303
    sidl_copy_c_str(
305
 
      SIDL_F77_STR(retval),
 
304
      SIDL_F77_STR(retval),(size_t)
306
305
      SIDL_F77_STR_LEN(retval),
307
306
      _proxy_retval);
 
307
    if (_proxy_retval) free(_proxy_retval);
308
308
  }
309
 
  free((void *)_proxy_retval);
310
309
}
311
310
 
312
311
 
557
556
    (struct sidl_BaseException__object*)
558
557
    (ptrdiff_t)(*self);
559
558
  _proxy_name =
560
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
559
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
561
560
      SIDL_F77_STR_LEN(name));
562
561
  _epv = _proxy_self->d_epv;
563
562
  _proxy_retval = 
715
714
  else {
716
715
    *exception = (ptrdiff_t)NULL;
717
716
    sidl_copy_c_str(
718
 
      SIDL_F77_STR(retval),
 
717
      SIDL_F77_STR(retval),(size_t)
719
718
      SIDL_F77_STR_LEN(retval),
720
719
      _proxy_retval);
 
720
    if (_proxy_retval) free(_proxy_retval);
721
721
  }
722
 
  free((void *)_proxy_retval);
723
722
}
724
723
 
725
724
/*
744
743
    (struct sidl_BaseException__object*)
745
744
    (ptrdiff_t)(*self);
746
745
  _proxy_message =
747
 
    sidl_copy_fortran_str(SIDL_F77_STR(message),
 
746
    sidl_copy_fortran_str(SIDL_F77_STR(message),(ptrdiff_t)
748
747
      SIDL_F77_STR_LEN(message));
749
748
  _epv = _proxy_self->d_epv;
750
749
  (*(_epv->f_setNote))(
795
794
  else {
796
795
    *exception = (ptrdiff_t)NULL;
797
796
    sidl_copy_c_str(
798
 
      SIDL_F77_STR(retval),
 
797
      SIDL_F77_STR(retval),(size_t)
799
798
      SIDL_F77_STR_LEN(retval),
800
799
      _proxy_retval);
 
800
    if (_proxy_retval) free(_proxy_retval);
801
801
  }
802
 
  free((void *)_proxy_retval);
803
802
}
804
803
 
805
804
/*
824
823
    (struct sidl_BaseException__object*)
825
824
    (ptrdiff_t)(*self);
826
825
  _proxy_traceline =
827
 
    sidl_copy_fortran_str(SIDL_F77_STR(traceline),
 
826
    sidl_copy_fortran_str(SIDL_F77_STR(traceline),(ptrdiff_t)
828
827
      SIDL_F77_STR_LEN(traceline));
829
828
  _epv = _proxy_self->d_epv;
830
829
  (*(_epv->f_addLine))(
869
868
    (struct sidl_BaseException__object*)
870
869
    (ptrdiff_t)(*self);
871
870
  _proxy_filename =
872
 
    sidl_copy_fortran_str(SIDL_F77_STR(filename),
 
871
    sidl_copy_fortran_str(SIDL_F77_STR(filename),(ptrdiff_t)
873
872
      SIDL_F77_STR_LEN(filename));
874
873
  _proxy_methodname =
875
 
    sidl_copy_fortran_str(SIDL_F77_STR(methodname),
 
874
    sidl_copy_fortran_str(SIDL_F77_STR(methodname),(ptrdiff_t)
876
875
      SIDL_F77_STR_LEN(methodname));
877
876
  _epv = _proxy_self->d_epv;
878
877
  (*(_epv->f_add))(
951
950
                  sidl_BaseException__array_addRef_f)
952
951
  (int64_t *array)
953
952
{
954
 
  sidl_interface__array_addRef((struct sidl_interface__array 
955
 
    *)(ptrdiff_t)*array);
 
953
  sidl_interface__array_addRef((struct sidl_interface__array *)(
 
954
    ptrdiff_t)*array);
956
955
}
957
956
 
958
957
void
961
960
                  sidl_BaseException__array_deleteRef_f)
962
961
  (int64_t *array)
963
962
{
964
 
  sidl_interface__array_deleteRef((struct sidl_interface__array 
965
 
    *)(ptrdiff_t)*array);
 
963
  sidl_interface__array_deleteRef((struct sidl_interface__array *)(
 
964
    ptrdiff_t)*array);
966
965
}
967
966
 
968
967
void
974
973
   int64_t *result)
975
974
{
976
975
  *result = (ptrdiff_t)
977
 
    sidl_interface__array_get1((const struct sidl_interface__array 
978
 
      *)(ptrdiff_t)*array
 
976
    sidl_interface__array_get1((const struct sidl_interface__array *)(
 
977
      ptrdiff_t)*array
979
978
    , *i1);
980
979
}
981
980
 
989
988
   int64_t *result)
990
989
{
991
990
  *result = (ptrdiff_t)
992
 
    sidl_interface__array_get2((const struct sidl_interface__array 
993
 
      *)(ptrdiff_t)*array
 
991
    sidl_interface__array_get2((const struct sidl_interface__array *)(
 
992
      ptrdiff_t)*array
994
993
    , *i1, *i2);
995
994
}
996
995
 
1005
1004
   int64_t *result)
1006
1005
{
1007
1006
  *result = (ptrdiff_t)
1008
 
    sidl_interface__array_get3((const struct sidl_interface__array 
1009
 
      *)(ptrdiff_t)*array
 
1007
    sidl_interface__array_get3((const struct sidl_interface__array *)(
 
1008
      ptrdiff_t)*array
1010
1009
    , *i1, *i2, *i3);
1011
1010
}
1012
1011
 
1022
1021
   int64_t *result)
1023
1022
{
1024
1023
  *result = (ptrdiff_t)
1025
 
    sidl_interface__array_get4((const struct sidl_interface__array 
1026
 
      *)(ptrdiff_t)*array
 
1024
    sidl_interface__array_get4((const struct sidl_interface__array *)(
 
1025
      ptrdiff_t)*array
1027
1026
    , *i1, *i2, *i3, *i4);
1028
1027
}
1029
1028
 
1040
1039
   int64_t *result)
1041
1040
{
1042
1041
  *result = (ptrdiff_t)
1043
 
    sidl_interface__array_get5((const struct sidl_interface__array 
1044
 
      *)(ptrdiff_t)*array
 
1042
    sidl_interface__array_get5((const struct sidl_interface__array *)(
 
1043
      ptrdiff_t)*array
1045
1044
    , *i1, *i2, *i3, *i4, *i5);
1046
1045
}
1047
1046
 
1059
1058
   int64_t *result)
1060
1059
{
1061
1060
  *result = (ptrdiff_t)
1062
 
    sidl_interface__array_get6((const struct sidl_interface__array 
1063
 
      *)(ptrdiff_t)*array
 
1061
    sidl_interface__array_get6((const struct sidl_interface__array *)(
 
1062
      ptrdiff_t)*array
1064
1063
    , *i1, *i2, *i3, *i4, *i5, *i6);
1065
1064
}
1066
1065
 
1079
1078
   int64_t *result)
1080
1079
{
1081
1080
  *result = (ptrdiff_t)
1082
 
    sidl_interface__array_get7((const struct sidl_interface__array 
1083
 
      *)(ptrdiff_t)*array
 
1081
    sidl_interface__array_get7((const struct sidl_interface__array *)(
 
1082
      ptrdiff_t)*array
1084
1083
    , *i1, *i2, *i3, *i4, *i5, *i6, *i7);
1085
1084
}
1086
1085
 
1093
1092
   int64_t *result)
1094
1093
{
1095
1094
  *result = (ptrdiff_t)
1096
 
    sidl_interface__array_get((const struct sidl_interface__array 
1097
 
      *)(ptrdiff_t)*array, indices);
 
1095
    sidl_interface__array_get((const struct sidl_interface__array *)(
 
1096
      ptrdiff_t)*array, indices);
1098
1097
}
1099
1098
 
1100
1099
void
1164
1163
   int64_t *value)
1165
1164
{
1166
1165
  sidl_interface__array_set5((struct sidl_interface__array *)(ptrdiff_t)*array
1167
 
  , *i1, *i2, *i3, *i4, *i5,
1168
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1166
  , *i1, *i2, *i3, *i4, *i5, (struct sidl_BaseInterface__object *)(
 
1167
    ptrdiff_t)*value);
1169
1168
}
1170
1169
 
1171
1170
void
1182
1181
   int64_t *value)
1183
1182
{
1184
1183
  sidl_interface__array_set6((struct sidl_interface__array *)(ptrdiff_t)*array
1185
 
  , *i1, *i2, *i3, *i4, *i5, *i6,
1186
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1184
  , *i1, *i2, *i3, *i4, *i5, *i6, (struct sidl_BaseInterface__object *)(
 
1185
    ptrdiff_t)*value);
1187
1186
}
1188
1187
 
1189
1188
void
1201
1200
   int64_t *value)
1202
1201
{
1203
1202
  sidl_interface__array_set7((struct sidl_interface__array *)(ptrdiff_t)*array
1204
 
  , *i1, *i2, *i3, *i4, *i5, *i6, *i7,
1205
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1203
  , *i1, *i2, *i3, *i4, *i5, *i6, *i7, (struct sidl_BaseInterface__object *)(
 
1204
    ptrdiff_t)*value);
1206
1205
}
1207
1206
 
1208
1207
void
1213
1212
  int32_t indices[],
1214
1213
  int64_t *value)
1215
1214
{
1216
 
  sidl_interface__array_set((struct sidl_interface__array *)(ptrdiff_t)*array,
 
1215
  sidl_interface__array_set((struct sidl_interface__array *)(ptrdiff_t)*array, 
1217
1216
    indices, (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
1218
1217
}
1219
1218
 
1224
1223
  (int64_t *array, int32_t *result)
1225
1224
{
1226
1225
  *result =
1227
 
    sidl_interface__array_dimen((struct sidl_interface__array 
1228
 
      *)(ptrdiff_t)*array);
 
1226
    sidl_interface__array_dimen((struct sidl_interface__array *)(
 
1227
      ptrdiff_t)*array);
1229
1228
}
1230
1229
 
1231
1230
void
1237
1236
   int32_t *result)
1238
1237
{
1239
1238
  *result = 
1240
 
    sidl_interface__array_lower((struct sidl_interface__array 
1241
 
      *)(ptrdiff_t)*array, *ind);
 
1239
    sidl_interface__array_lower((struct sidl_interface__array *)(
 
1240
      ptrdiff_t)*array, *ind);
1242
1241
}
1243
1242
 
1244
1243
void
1250
1249
   int32_t *result)
1251
1250
{
1252
1251
  *result = 
1253
 
    sidl_interface__array_upper((struct sidl_interface__array 
1254
 
      *)(ptrdiff_t)*array, *ind);
 
1252
    sidl_interface__array_upper((struct sidl_interface__array *)(
 
1253
      ptrdiff_t)*array, *ind);
1255
1254
}
1256
1255
 
1257
1256
void
1263
1262
   int32_t *result)
1264
1263
{
1265
1264
  *result = 
1266
 
    sidl_interface__array_length((struct sidl_interface__array 
1267
 
      *)(ptrdiff_t)*array, *ind);
 
1265
    sidl_interface__array_length((struct sidl_interface__array *)(
 
1266
      ptrdiff_t)*array, *ind);
1268
1267
}
1269
1268
 
1270
1269
void
1276
1275
   int32_t *result)
1277
1276
{
1278
1277
  *result = 
1279
 
    sidl_interface__array_stride((struct sidl_interface__array 
1280
 
      *)(ptrdiff_t)*array, *ind);
 
1278
    sidl_interface__array_stride((struct sidl_interface__array *)(
 
1279
      ptrdiff_t)*array, *ind);
1281
1280
}
1282
1281
 
1283
1282
void
1298
1297
  (int64_t *array,
1299
1298
   SIDL_F77_Bool *result)
1300
1299
{
1301
 
  *result = sidl_interface__array_isRowOrder((struct sidl_interface__array 
1302
 
    *)(ptrdiff_t)*array);
 
1300
  *result = sidl_interface__array_isRowOrder((struct sidl_interface__array *)(
 
1301
    ptrdiff_t)*array);
1303
1302
}
1304
1303
 
1305
1304
void
1309
1308
  (int64_t *src,
1310
1309
   int64_t *dest)
1311
1310
{
1312
 
  sidl_interface__array_copy((const struct sidl_interface__array 
1313
 
    *)(ptrdiff_t)*src,
 
1311
  sidl_interface__array_copy((const struct sidl_interface__array *)(
 
1312
    ptrdiff_t)*src,
1314
1313
                             (struct sidl_interface__array *)(ptrdiff_t)*dest);
1315
1314
}
1316
1315
 
1320
1319
                  sidl_BaseException__array_smartCopy_f)
1321
1320
  (int64_t *src)
1322
1321
{
1323
 
  sidl_interface__array_smartCopy((struct sidl_interface__array 
1324
 
    *)(ptrdiff_t)*src);
 
1322
  sidl_interface__array_smartCopy((struct sidl_interface__array *)(
 
1323
    ptrdiff_t)*src);
1325
1324
}
1326
1325
 
1327
1326
void
1351
1350
   int64_t *result)
1352
1351
{
1353
1352
  *result = (ptrdiff_t)
1354
 
    sidl_interface__array_ensure((struct sidl_interface__array 
1355
 
      *)(ptrdiff_t)*src,
 
1353
    sidl_interface__array_ensure((struct sidl_interface__array *)(
 
1354
      ptrdiff_t)*src,
1356
1355
    *dimen, *ordering);
1357
1356
}
1358
1357
 
1407
1406
#endif
1408
1407
 
1409
1408
/* Static variables to hold version of IOR */
1410
 
static const int32_t s_IOR_MAJOR_VERSION = 0;
1411
 
static const int32_t s_IOR_MINOR_VERSION = 10;
 
1409
static const int32_t s_IOR_MAJOR_VERSION = 1;
 
1410
static const int32_t s_IOR_MINOR_VERSION = 0;
1412
1411
 
1413
1412
/* Static variables for managing EPV initialization. */
1414
1413
static int s_remote_initialized = 0;
1436
1435
  cmp0 = strcmp(name, "sidl._BaseException");
1437
1436
  if (!cmp0) {
1438
1437
    (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
1439
 
    cast = self;
 
1438
    cast = ((struct sidl__BaseException__object*)self);
1440
1439
    return cast;
1441
1440
  }
1442
1441
  else if (cmp0 < 0) {
1464
1463
    }
1465
1464
  }
1466
1465
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
1467
 
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,
1468
 
      struct sidl_BaseInterface__object**) = 
1469
 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,
1470
 
        struct sidl_BaseInterface__object**)) 
 
1466
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1467
      sidl_BaseInterface__object**) = 
 
1468
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1469
        sidl_BaseInterface__object**)) 
1471
1470
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
1472
 
    cast =  (*func)(((struct sidl__BaseException__remote*)self->d_data)->d_ih,
 
1471
    cast =  (*func)(((struct sidl__BaseException__remote*)self->d_data)->d_ih, 
1473
1472
      _ex);
1474
1473
  }
1475
1474
 
1510
1509
  struct sidl_rmi_InstanceHandle__object *_conn = ((struct 
1511
1510
    sidl__BaseException__remote*)self->d_data)->d_ih;
1512
1511
  sidl_rmi_Response _rsvp = NULL;
1513
 
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1512
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1514
1513
    "addRef", _ex ); SIDL_CHECK(*_ex);
1515
1514
  /* send actual RMI request */
1516
1515
  _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
1555
1554
    sidl_rmi_Response _rsvp = NULL;
1556
1555
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1557
1556
      sidl__BaseException__remote*)self->d_data)->d_ih;
1558
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1557
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1559
1558
      "_set_hooks", _ex ); SIDL_CHECK(*_ex);
1560
1559
 
1561
1560
    /* pack in and inout arguments */
1649
1648
    sidl_bool _retval = FALSE;
1650
1649
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1651
1650
      sidl__BaseException__remote*)self->d_data)->d_ih;
1652
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1651
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1653
1652
      "isSame", _ex ); SIDL_CHECK(*_ex);
1654
1653
 
1655
1654
    /* pack in and inout arguments */
1656
1655
    if(iobj){
1657
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,
 
1656
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj, 
1658
1657
        _ex);SIDL_CHECK(*_ex);
1659
1658
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(*_ex);
1660
1659
      free((void*)_url);
1675
1674
    }
1676
1675
 
1677
1676
    /* extract return value */
1678
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1679
 
      _ex);SIDL_CHECK(*_ex);
 
1677
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1678
      *_ex);
1680
1679
 
1681
1680
    /* unpack out and inout arguments */
1682
1681
 
1705
1704
    sidl_bool _retval = FALSE;
1706
1705
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1707
1706
      sidl__BaseException__remote*)self->d_data)->d_ih;
1708
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1707
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1709
1708
      "isType", _ex ); SIDL_CHECK(*_ex);
1710
1709
 
1711
1710
    /* pack in and inout arguments */
1724
1723
    }
1725
1724
 
1726
1725
    /* extract return value */
1727
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1728
 
      _ex);SIDL_CHECK(*_ex);
 
1726
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1727
      *_ex);
1729
1728
 
1730
1729
    /* unpack out and inout arguments */
1731
1730
 
1754
1753
    struct sidl_ClassInfo__object* _retval = 0;
1755
1754
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1756
1755
      sidl__BaseException__remote*)self->d_data)->d_ih;
1757
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1756
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1758
1757
      "getClassInfo", _ex ); SIDL_CHECK(*_ex);
1759
1758
 
1760
1759
    /* pack in and inout arguments */
1772
1771
    }
1773
1772
 
1774
1773
    /* extract return value */
1775
 
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
1776
 
      _ex);SIDL_CHECK(*_ex);
1777
 
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,
1778
 
      _ex);SIDL_CHECK(*_ex);
 
1774
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
1775
      _ex);SIDL_CHECK(*_ex);
 
1776
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
1777
      *_ex);
1779
1778
 
1780
1779
    /* unpack out and inout arguments */
1781
1780
 
1803
1802
    sidl_rmi_Response _rsvp = NULL;
1804
1803
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1805
1804
      sidl__BaseException__remote*)self->d_data)->d_ih;
1806
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1805
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1807
1806
      "packObj", _ex ); SIDL_CHECK(*_ex);
1808
1807
 
1809
1808
    /* pack in and inout arguments */
1810
1809
    if(ser){
1811
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)ser,
 
1810
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)ser, 
1812
1811
        _ex);SIDL_CHECK(*_ex);
1813
1812
      sidl_rmi_Invocation_packString( _inv, "ser", _url, _ex);SIDL_CHECK(*_ex);
1814
1813
      free((void*)_url);
1854
1853
    sidl_rmi_Response _rsvp = NULL;
1855
1854
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1856
1855
      sidl__BaseException__remote*)self->d_data)->d_ih;
1857
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1856
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1858
1857
      "unpackObj", _ex ); SIDL_CHECK(*_ex);
1859
1858
 
1860
1859
    /* pack in and inout arguments */
1861
1860
    if(des){
1862
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)des,
 
1861
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)des, 
1863
1862
        _ex);SIDL_CHECK(*_ex);
1864
1863
      sidl_rmi_Invocation_packString( _inv, "des", _url, _ex);SIDL_CHECK(*_ex);
1865
1864
      free((void*)_url);
1905
1904
    char* _retval = 0;
1906
1905
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1907
1906
      sidl__BaseException__remote*)self->d_data)->d_ih;
1908
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1907
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1909
1908
      "getNote", _ex ); SIDL_CHECK(*_ex);
1910
1909
 
1911
1910
    /* pack in and inout arguments */
1923
1922
    }
1924
1923
 
1925
1924
    /* extract return value */
1926
 
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval,
1927
 
      _ex);SIDL_CHECK(*_ex);
 
1925
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1926
      *_ex);
1928
1927
 
1929
1928
    /* unpack out and inout arguments */
1930
1929
 
1952
1951
    sidl_rmi_Response _rsvp = NULL;
1953
1952
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1954
1953
      sidl__BaseException__remote*)self->d_data)->d_ih;
1955
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1954
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1956
1955
      "setNote", _ex ); SIDL_CHECK(*_ex);
1957
1956
 
1958
1957
    /* pack in and inout arguments */
1959
 
    sidl_rmi_Invocation_packString( _inv, "message", message,
1960
 
      _ex);SIDL_CHECK(*_ex);
 
1958
    sidl_rmi_Invocation_packString( _inv, "message", message, _ex);SIDL_CHECK(
 
1959
      *_ex);
1961
1960
 
1962
1961
    /* send actual RMI request */
1963
1962
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
1997
1996
    char* _retval = 0;
1998
1997
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1999
1998
      sidl__BaseException__remote*)self->d_data)->d_ih;
2000
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1999
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2001
2000
      "getTrace", _ex ); SIDL_CHECK(*_ex);
2002
2001
 
2003
2002
    /* pack in and inout arguments */
2015
2014
    }
2016
2015
 
2017
2016
    /* extract return value */
2018
 
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval,
2019
 
      _ex);SIDL_CHECK(*_ex);
 
2017
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2018
      *_ex);
2020
2019
 
2021
2020
    /* unpack out and inout arguments */
2022
2021
 
2044
2043
    sidl_rmi_Response _rsvp = NULL;
2045
2044
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2046
2045
      sidl__BaseException__remote*)self->d_data)->d_ih;
2047
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2046
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2048
2047
      "addLine", _ex ); SIDL_CHECK(*_ex);
2049
2048
 
2050
2049
    /* pack in and inout arguments */
2051
 
    sidl_rmi_Invocation_packString( _inv, "traceline", traceline,
 
2050
    sidl_rmi_Invocation_packString( _inv, "traceline", traceline, 
2052
2051
      _ex);SIDL_CHECK(*_ex);
2053
2052
 
2054
2053
    /* send actual RMI request */
2091
2090
    sidl_rmi_Response _rsvp = NULL;
2092
2091
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2093
2092
      sidl__BaseException__remote*)self->d_data)->d_ih;
2094
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2093
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2095
2094
      "add", _ex ); SIDL_CHECK(*_ex);
2096
2095
 
2097
2096
    /* pack in and inout arguments */
2098
 
    sidl_rmi_Invocation_packString( _inv, "filename", filename,
2099
 
      _ex);SIDL_CHECK(*_ex);
 
2097
    sidl_rmi_Invocation_packString( _inv, "filename", filename, _ex);SIDL_CHECK(
 
2098
      *_ex);
2100
2099
    sidl_rmi_Invocation_packInt( _inv, "lineno", lineno, _ex);SIDL_CHECK(*_ex);
2101
 
    sidl_rmi_Invocation_packString( _inv, "methodname", methodname,
 
2100
    sidl_rmi_Invocation_packString( _inv, "methodname", methodname, 
2102
2101
      _ex);SIDL_CHECK(*_ex);
2103
2102
 
2104
2103
    /* send actual RMI request */
2155
2154
  epv->f_addLine           = remote_sidl__BaseException_addLine;
2156
2155
  epv->f_add               = remote_sidl__BaseException_add;
2157
2156
 
2158
 
  e0->f__cast        = (void* (*)(void*,const char*,
2159
 
    sidl_BaseInterface*)) epv->f__cast;
 
2157
  e0->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
2158
    epv->f__cast;
2160
2159
  e0->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
2161
2160
  e0->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
2162
2161
  e0->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
2163
 
  e0->f__isRemote    = (sidl_bool (*)(void*,
2164
 
    sidl_BaseInterface*)) epv->f__isRemote;
2165
 
  e0->f__set_hooks   = (void (*)(void*,int32_t,
2166
 
    sidl_BaseInterface*)) epv->f__set_hooks;
2167
 
  e0->f__exec        = (void (*)(void*,const char*,
2168
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2169
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
2170
 
  e0->f_addRef       = (void (*)(void*,
2171
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
2172
 
  e0->f_deleteRef    = (void (*)(void*,
2173
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2162
  e0->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
2163
    epv->f__isRemote;
 
2164
  e0->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
2165
    epv->f__set_hooks;
 
2166
  e0->f__exec        = (void (*)(void*,const char*,struct 
 
2167
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2168
    sidl_BaseInterface__object **)) epv->f__exec;
 
2169
  e0->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2170
    epv->f_addRef;
 
2171
  e0->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2172
    epv->f_deleteRef;
2174
2173
  e0->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
2175
2174
    struct sidl_BaseInterface__object **)) epv->f_isSame;
2176
 
  e0->f_isType       = (sidl_bool (*)(void*,const char*,
2177
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
2178
 
  e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
2179
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2175
  e0->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
2176
    sidl_BaseInterface__object **)) epv->f_isType;
 
2177
  e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2178
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
2180
2179
  e0->f_packObj      = (void (*)(void*,struct sidl_io_Serializer__object*,
2181
2180
    struct sidl_BaseInterface__object **)) epv->f_packObj;
2182
2181
  e0->f_unpackObj    = (void (*)(void*,struct sidl_io_Deserializer__object*,
2183
2182
    struct sidl_BaseInterface__object **)) epv->f_unpackObj;
2184
 
  e0->f_getNote      = (char* (*)(void*,
2185
 
    struct sidl_BaseInterface__object **)) epv->f_getNote;
2186
 
  e0->f_setNote      = (void (*)(void*,const char*,
2187
 
    struct sidl_BaseInterface__object **)) epv->f_setNote;
2188
 
  e0->f_getTrace     = (char* (*)(void*,
2189
 
    struct sidl_BaseInterface__object **)) epv->f_getTrace;
2190
 
  e0->f_addLine      = (void (*)(void*,const char*,
2191
 
    struct sidl_BaseInterface__object **)) epv->f_addLine;
2192
 
  e0->f_add          = (void (*)(void*,const char*,int32_t,const char*,
2193
 
    struct sidl_BaseInterface__object **)) epv->f_add;
 
2183
  e0->f_getNote      = (char* (*)(void*,struct sidl_BaseInterface__object **)) 
 
2184
    epv->f_getNote;
 
2185
  e0->f_setNote      = (void (*)(void*,const char*,struct 
 
2186
    sidl_BaseInterface__object **)) epv->f_setNote;
 
2187
  e0->f_getTrace     = (char* (*)(void*,struct sidl_BaseInterface__object **)) 
 
2188
    epv->f_getTrace;
 
2189
  e0->f_addLine      = (void (*)(void*,const char*,struct 
 
2190
    sidl_BaseInterface__object **)) epv->f_addLine;
 
2191
  e0->f_add          = (void (*)(void*,const char*,int32_t,const char*,struct 
 
2192
    sidl_BaseInterface__object **)) epv->f_add;
2194
2193
 
2195
 
  e1->f__cast        = (void* (*)(void*,const char*,
2196
 
    sidl_BaseInterface*)) epv->f__cast;
 
2194
  e1->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
2195
    epv->f__cast;
2197
2196
  e1->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
2198
2197
  e1->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
2199
2198
  e1->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
2200
 
  e1->f__isRemote    = (sidl_bool (*)(void*,
2201
 
    sidl_BaseInterface*)) epv->f__isRemote;
2202
 
  e1->f__set_hooks   = (void (*)(void*,int32_t,
2203
 
    sidl_BaseInterface*)) epv->f__set_hooks;
2204
 
  e1->f__exec        = (void (*)(void*,const char*,
2205
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2206
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
2207
 
  e1->f_addRef       = (void (*)(void*,
2208
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
2209
 
  e1->f_deleteRef    = (void (*)(void*,
2210
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2199
  e1->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
2200
    epv->f__isRemote;
 
2201
  e1->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
2202
    epv->f__set_hooks;
 
2203
  e1->f__exec        = (void (*)(void*,const char*,struct 
 
2204
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2205
    sidl_BaseInterface__object **)) epv->f__exec;
 
2206
  e1->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2207
    epv->f_addRef;
 
2208
  e1->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2209
    epv->f_deleteRef;
2211
2210
  e1->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
2212
2211
    struct sidl_BaseInterface__object **)) epv->f_isSame;
2213
 
  e1->f_isType       = (sidl_bool (*)(void*,const char*,
2214
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
2215
 
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
2216
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2212
  e1->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
2213
    sidl_BaseInterface__object **)) epv->f_isType;
 
2214
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2215
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
2217
2216
 
2218
 
  e2->f__cast        = (void* (*)(void*,const char*,
2219
 
    sidl_BaseInterface*)) epv->f__cast;
 
2217
  e2->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
2218
    epv->f__cast;
2220
2219
  e2->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
2221
2220
  e2->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
2222
2221
  e2->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
2223
 
  e2->f__isRemote    = (sidl_bool (*)(void*,
2224
 
    sidl_BaseInterface*)) epv->f__isRemote;
2225
 
  e2->f__set_hooks   = (void (*)(void*,int32_t,
2226
 
    sidl_BaseInterface*)) epv->f__set_hooks;
2227
 
  e2->f__exec        = (void (*)(void*,const char*,
2228
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2229
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
2230
 
  e2->f_addRef       = (void (*)(void*,
2231
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
2232
 
  e2->f_deleteRef    = (void (*)(void*,
2233
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2222
  e2->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
2223
    epv->f__isRemote;
 
2224
  e2->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
2225
    epv->f__set_hooks;
 
2226
  e2->f__exec        = (void (*)(void*,const char*,struct 
 
2227
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2228
    sidl_BaseInterface__object **)) epv->f__exec;
 
2229
  e2->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2230
    epv->f_addRef;
 
2231
  e2->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2232
    epv->f_deleteRef;
2234
2233
  e2->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
2235
2234
    struct sidl_BaseInterface__object **)) epv->f_isSame;
2236
 
  e2->f_isType       = (sidl_bool (*)(void*,const char*,
2237
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
2238
 
  e2->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
2239
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2235
  e2->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
2236
    sidl_BaseInterface__object **)) epv->f_isType;
 
2237
  e2->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2238
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
2240
2239
  e2->f_packObj      = (void (*)(void*,struct sidl_io_Serializer__object*,
2241
2240
    struct sidl_BaseInterface__object **)) epv->f_packObj;
2242
2241
  e2->f_unpackObj    = (void (*)(void*,struct sidl_io_Deserializer__object*,
2247
2246
 
2248
2247
/* Create an instance that connects to an existing remote object. */
2249
2248
static struct sidl_BaseException__object*
2250
 
sidl_BaseException__remoteConnect(const char *url, sidl_bool ar,
 
2249
sidl_BaseException__remoteConnect(const char *url, sidl_bool ar, 
2251
2250
  sidl_BaseInterface *_ex)
2252
2251
{
2253
2252
  struct sidl__BaseException__object* self;
2259
2258
  char* objectID = NULL;
2260
2259
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
2261
2260
  if(objectID) {
2262
 
    sidl_BaseInterface bi = 
2263
 
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
2264
 
      objectID, _ex);
 
2261
    sidl_BaseInterface bi = (
 
2262
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(objectID,
 
2263
      _ex);
2265
2264
    if(ar) {
2266
2265
      sidl_BaseInterface_addRef(bi, _ex);
2267
2266
    }
2306
2305
/* Create an instance that uses an already existing  */
2307
2306
/* InstanceHandel to connect to an existing remote object. */
2308
2307
static struct sidl_BaseException__object*
2309
 
sidl_BaseException__IHConnect(sidl_rmi_InstanceHandle instance,
 
2308
sidl_BaseException__IHConnect(sidl_rmi_InstanceHandle instance, 
2310
2309
  sidl_BaseInterface *_ex)
2311
2310
{
2312
2311
  struct sidl__BaseException__object* self;
2362
2361
 
2363
2362
  *_ex = NULL;
2364
2363
  if(!connect_loaded) {
2365
 
    sidl_rmi_ConnectRegistry_registerConnect("sidl.BaseException",
2366
 
      (void*)sidl_BaseException__IHConnect, _ex);
 
2364
    sidl_rmi_ConnectRegistry_registerConnect("sidl.BaseException", (
 
2365
      void*)sidl_BaseException__IHConnect, _ex);
2367
2366
    connect_loaded = 1;
2368
2367
  }
2369
2368
  if (obj != NULL) {
2384
2383
 */
2385
2384
 
2386
2385
struct sidl_BaseException__object*
2387
 
sidl_BaseException__connectI(const char* url, sidl_bool ar,
2388
 
  struct sidl_BaseInterface__object **_ex)
 
2386
sidl_BaseException__connectI(const char* url, sidl_bool ar, struct 
 
2387
  sidl_BaseInterface__object **_ex)
2389
2388
{
2390
2389
  return sidl_BaseException__remoteConnect(url, ar, _ex);
2391
2390
}