← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/babel/bHYPREClient-P/bHYPRE/bHYPRE_Euclid_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/bHYPREClient-P/bHYPRE/bHYPRE_Euclid_Module.c
2
2
 * File:          bHYPRE_Euclid_Module.c
3
3
 * Symbol:        bHYPRE.Euclid-v1.0.0
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
26
26
 * Objects of this type can be cast to Solver objects using the
27
27
 * {\tt \_\_cast} methods.
28
28
 * 
29
 
 * RDF: Documentation goes here.
30
29
 * Although the usual Solver SetParameter functions are available,
31
30
 * a Euclid-stype parameter-setting function is also available, SetParameters.
32
31
 */
152
151
 * RMI connector function for the class. (no addref)
153
152
 */
154
153
struct bHYPRE_Euclid__object*
155
 
bHYPRE_Euclid__connectI(const char * url, sidl_bool ar,                       \
156
 
  struct sidl_BaseInterface__object **_ex);
 
154
bHYPRE_Euclid__connectI(const char * url, sidl_bool ar, struct                \
 
155
  sidl_BaseInterface__object **_ex);
157
156
 
158
157
/* Static variables to hold version of IOR */
159
 
static const int32_t s_IOR_MAJOR_VERSION = 0;
160
 
static const int32_t s_IOR_MINOR_VERSION = 10;
 
158
static const int32_t s_IOR_MAJOR_VERSION = 1;
 
159
static const int32_t s_IOR_MINOR_VERSION = 0;
161
160
 
162
161
/* Static variables for managing EPV initialization. */
163
162
static int s_remote_initialized = 0;
201
200
      cmp2 = strcmp(name, "bHYPRE.Euclid");
202
201
      if (!cmp2) {
203
202
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
204
 
        cast = self;
 
203
        cast = ((struct bHYPRE_Euclid__object*)self);
205
204
        return cast;
206
205
      }
207
206
    }
217
216
      cmp2 = strcmp(name, "sidl.BaseClass");
218
217
      if (!cmp2) {
219
218
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
220
 
        cast = self;
 
219
        cast = ((struct sidl_BaseClass__object*)self);
221
220
        return cast;
222
221
      }
223
222
    }
224
223
  }
225
224
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
226
 
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,                    \
227
 
      struct sidl_BaseInterface__object**) = 
228
 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,                     \
229
 
        struct sidl_BaseInterface__object**)) 
 
225
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct             \
 
226
      sidl_BaseInterface__object**) = 
 
227
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct              \
 
228
        sidl_BaseInterface__object**)) 
230
229
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
231
230
    cast =  (*func)(((struct bHYPRE_Euclid__remote*)self->d_data)->d_ih, _ex);
232
231
  }
374
373
 
375
374
    /* pack in and inout arguments */
376
375
    sidl_rmi_Invocation_packInt( _inv, "argc", argc, _ex);SIDL_CHECK(*_ex);
377
 
    sidl_rmi_Invocation_packString( _inv, "argv", *argv,                      \
378
 
      _ex);SIDL_CHECK(*_ex);
 
376
    sidl_rmi_Invocation_packString( _inv, "argv", *argv, _ex);SIDL_CHECK(     \
 
377
      *_ex);
379
378
 
380
379
    /* send actual RMI request */
381
380
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
390
389
    }
391
390
 
392
391
    /* extract return value */
393
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
394
 
      _ex);SIDL_CHECK(*_ex);
 
392
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
393
      *_ex);
395
394
 
396
395
    /* unpack out and inout arguments */
397
 
    sidl_rmi_Response_unpackString( _rsvp, "argv", argv,                      \
398
 
      _ex);SIDL_CHECK(*_ex);
 
396
    sidl_rmi_Response_unpackString( _rsvp, "argv", argv, _ex);SIDL_CHECK(     \
 
397
      *_ex);
399
398
 
400
399
    /* cleanup and return */
401
400
    EXIT:
468
467
    if(iobj){
469
468
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,       \
470
469
        _ex);SIDL_CHECK(*_ex);
471
 
      sidl_rmi_Invocation_packString( _inv, "iobj", _url,                     \
472
 
        _ex);SIDL_CHECK(*_ex);
 
470
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(    \
 
471
        *_ex);
473
472
      free((void*)_url);
474
473
    } else {
475
 
      sidl_rmi_Invocation_packString( _inv, "iobj", NULL,                     \
476
 
        _ex);SIDL_CHECK(*_ex);
 
474
      sidl_rmi_Invocation_packString( _inv, "iobj", NULL, _ex);SIDL_CHECK(    \
 
475
        *_ex);
477
476
    }
478
477
 
479
478
    /* send actual RMI request */
489
488
    }
490
489
 
491
490
    /* extract return value */
492
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,                 \
493
 
      _ex);SIDL_CHECK(*_ex);
 
491
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
 
492
      *_ex);
494
493
 
495
494
    /* unpack out and inout arguments */
496
495
 
538
537
    }
539
538
 
540
539
    /* extract return value */
541
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,                 \
542
 
      _ex);SIDL_CHECK(*_ex);
 
540
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
 
541
      *_ex);
543
542
 
544
543
    /* unpack out and inout arguments */
545
544
 
588
587
    /* extract return value */
589
588
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,           \
590
589
      _ex);SIDL_CHECK(*_ex);
591
 
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,                    \
592
 
      _ex);SIDL_CHECK(*_ex);
 
590
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(   \
 
591
      *_ex);
593
592
 
594
593
    /* unpack out and inout arguments */
595
594
 
644
643
    }
645
644
 
646
645
    /* extract return value */
647
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
648
 
      _ex);SIDL_CHECK(*_ex);
 
646
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
647
      *_ex);
649
648
 
650
649
    /* unpack out and inout arguments */
651
650
 
694
693
    }
695
694
 
696
695
    /* extract return value */
697
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
698
 
      _ex);SIDL_CHECK(*_ex);
 
696
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
697
      *_ex);
699
698
 
700
699
    /* unpack out and inout arguments */
701
700
 
744
743
    }
745
744
 
746
745
    /* extract return value */
747
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
748
 
      _ex);SIDL_CHECK(*_ex);
 
746
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
747
      *_ex);
749
748
 
750
749
    /* unpack out and inout arguments */
751
750
 
793
792
    }
794
793
 
795
794
    /* extract return value */
796
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
797
 
      _ex);SIDL_CHECK(*_ex);
 
795
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
796
      *_ex);
798
797
 
799
798
    /* unpack out and inout arguments */
800
799
 
842
841
    }
843
842
 
844
843
    /* extract return value */
845
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
846
 
      _ex);SIDL_CHECK(*_ex);
 
844
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
845
      *_ex);
847
846
 
848
847
    /* unpack out and inout arguments */
849
848
 
890
889
    }
891
890
 
892
891
    /* extract return value */
893
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
894
 
      _ex);SIDL_CHECK(*_ex);
 
892
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
893
      *_ex);
895
894
 
896
895
    /* unpack out and inout arguments */
897
896
    sidl_rmi_Response_unpackInt( _rsvp, "num_iterations", num_iterations,     \
940
939
    }
941
940
 
942
941
    /* extract return value */
943
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
944
 
      _ex);SIDL_CHECK(*_ex);
 
942
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
943
      *_ex);
945
944
 
946
945
    /* unpack out and inout arguments */
947
 
    sidl_rmi_Response_unpackDouble( _rsvp, "norm", norm,                      \
948
 
      _ex);SIDL_CHECK(*_ex);
 
946
    sidl_rmi_Response_unpackDouble( _rsvp, "norm", norm, _ex);SIDL_CHECK(     \
 
947
      *_ex);
949
948
 
950
949
    /* cleanup and return */
951
950
    EXIT:
979
978
    if(mpi_comm){
980
979
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm,   \
981
980
        _ex);SIDL_CHECK(*_ex);
982
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url,                 \
983
 
        _ex);SIDL_CHECK(*_ex);
 
981
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url, _ex);SIDL_CHECK(\
 
982
        *_ex);
984
983
      free((void*)_url);
985
984
    } else {
986
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL,                 \
987
 
        _ex);SIDL_CHECK(*_ex);
 
985
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL, _ex);SIDL_CHECK(\
 
986
        *_ex);
988
987
    }
989
988
 
990
989
    /* send actual RMI request */
1000
999
    }
1001
1000
 
1002
1001
    /* extract return value */
1003
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1004
 
      _ex);SIDL_CHECK(*_ex);
 
1002
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1003
      *_ex);
1005
1004
 
1006
1005
    /* unpack out and inout arguments */
1007
1006
 
1093
1092
    }
1094
1093
 
1095
1094
    /* extract return value */
1096
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1097
 
      _ex);SIDL_CHECK(*_ex);
 
1095
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1096
      *_ex);
1098
1097
 
1099
1098
    /* unpack out and inout arguments */
1100
1099
 
1129
1128
 
1130
1129
    /* pack in and inout arguments */
1131
1130
    sidl_rmi_Invocation_packString( _inv, "name", name, _ex);SIDL_CHECK(*_ex);
1132
 
    sidl_rmi_Invocation_packDouble( _inv, "value", value,                     \
1133
 
      _ex);SIDL_CHECK(*_ex);
 
1131
    sidl_rmi_Invocation_packDouble( _inv, "value", value, _ex);SIDL_CHECK(    \
 
1132
      *_ex);
1134
1133
 
1135
1134
    /* send actual RMI request */
1136
1135
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
1145
1144
    }
1146
1145
 
1147
1146
    /* extract return value */
1148
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1149
 
      _ex);SIDL_CHECK(*_ex);
 
1147
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1148
      *_ex);
1150
1149
 
1151
1150
    /* unpack out and inout arguments */
1152
1151
 
1181
1180
 
1182
1181
    /* pack in and inout arguments */
1183
1182
    sidl_rmi_Invocation_packString( _inv, "name", name, _ex);SIDL_CHECK(*_ex);
1184
 
    sidl_rmi_Invocation_packString( _inv, "value", value,                     \
1185
 
      _ex);SIDL_CHECK(*_ex);
 
1183
    sidl_rmi_Invocation_packString( _inv, "value", value, _ex);SIDL_CHECK(    \
 
1184
      *_ex);
1186
1185
 
1187
1186
    /* send actual RMI request */
1188
1187
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
1197
1196
    }
1198
1197
 
1199
1198
    /* extract return value */
1200
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1201
 
      _ex);SIDL_CHECK(*_ex);
 
1199
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1200
      *_ex);
1202
1201
 
1203
1202
    /* unpack out and inout arguments */
1204
1203
 
1249
1248
    }
1250
1249
 
1251
1250
    /* extract return value */
1252
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1253
 
      _ex);SIDL_CHECK(*_ex);
 
1251
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1252
      *_ex);
1254
1253
 
1255
1254
    /* unpack out and inout arguments */
1256
1255
 
1301
1300
    }
1302
1301
 
1303
1302
    /* extract return value */
1304
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1305
 
      _ex);SIDL_CHECK(*_ex);
 
1303
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1304
      *_ex);
1306
1305
 
1307
1306
    /* unpack out and inout arguments */
1308
1307
 
1353
1352
    }
1354
1353
 
1355
1354
    /* extract return value */
1356
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1357
 
      _ex);SIDL_CHECK(*_ex);
 
1355
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1356
      *_ex);
1358
1357
 
1359
1358
    /* unpack out and inout arguments */
1360
1359
 
1405
1404
    }
1406
1405
 
1407
1406
    /* extract return value */
1408
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1409
 
      _ex);SIDL_CHECK(*_ex);
 
1407
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1408
      *_ex);
1410
1409
 
1411
1410
    /* unpack out and inout arguments */
1412
1411
 
1455
1454
    }
1456
1455
 
1457
1456
    /* extract return value */
1458
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1459
 
      _ex);SIDL_CHECK(*_ex);
 
1457
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1458
      *_ex);
1460
1459
 
1461
1460
    /* unpack out and inout arguments */
1462
1461
    sidl_rmi_Response_unpackInt( _rsvp, "value", value, _ex);SIDL_CHECK(*_ex);
1506
1505
    }
1507
1506
 
1508
1507
    /* extract return value */
1509
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1510
 
      _ex);SIDL_CHECK(*_ex);
 
1508
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1509
      *_ex);
1511
1510
 
1512
1511
    /* unpack out and inout arguments */
1513
 
    sidl_rmi_Response_unpackDouble( _rsvp, "value", value,                    \
1514
 
      _ex);SIDL_CHECK(*_ex);
 
1512
    sidl_rmi_Response_unpackDouble( _rsvp, "value", value, _ex);SIDL_CHECK(   \
 
1513
      *_ex);
1515
1514
 
1516
1515
    /* cleanup and return */
1517
1516
    EXIT:
1573
1572
    }
1574
1573
 
1575
1574
    /* extract return value */
1576
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1577
 
      _ex);SIDL_CHECK(*_ex);
 
1575
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1576
      *_ex);
1578
1577
 
1579
1578
    /* unpack out and inout arguments */
1580
1579
 
1630
1629
      SIDL_CHECK(*_ex);
1631
1630
      (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((                       \
1632
1631
        sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
1633
 
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,                    \
1634
 
        _ex);SIDL_CHECK(*_ex); 
 
1632
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(   \
 
1633
        *_ex); 
1635
1634
    }
1636
1635
 
1637
1636
    /* send actual RMI request */
1647
1646
    }
1648
1647
 
1649
1648
    /* extract return value */
1650
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1651
 
      _ex);SIDL_CHECK(*_ex);
 
1649
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1650
      *_ex);
1652
1651
 
1653
1652
    /* unpack out and inout arguments */
1654
1653
    sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
1706
1705
      SIDL_CHECK(*_ex);
1707
1706
      (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((                       \
1708
1707
        sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
1709
 
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,                    \
1710
 
        _ex);SIDL_CHECK(*_ex); 
 
1708
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(   \
 
1709
        *_ex); 
1711
1710
    }
1712
1711
 
1713
1712
    /* send actual RMI request */
1723
1722
    }
1724
1723
 
1725
1724
    /* extract return value */
1726
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1727
 
      _ex);SIDL_CHECK(*_ex);
 
1725
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1726
      *_ex);
1728
1727
 
1729
1728
    /* unpack out and inout arguments */
1730
1729
    sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
1797
1796
 
1798
1797
  e0->f__cast                    = (void* (*)(void*,const char*,              \
1799
1798
    sidl_BaseInterface*)) epv->f__cast;
1800
 
  e0->f__delete                  = (void (*)(void*,                           \
1801
 
    sidl_BaseInterface*)) epv->f__delete;
1802
 
  e0->f__getURL                  = (char* (*)(void*,                          \
1803
 
    sidl_BaseInterface*)) epv->f__getURL;
1804
 
  e0->f__raddRef                 = (void (*)(void*,                           \
1805
 
    sidl_BaseInterface*)) epv->f__raddRef;
1806
 
  e0->f__isRemote                = (sidl_bool (*)(void*,                      \
1807
 
    sidl_BaseInterface*)) epv->f__isRemote;
 
1799
  e0->f__delete                  = (void (*)(void*,sidl_BaseInterface*))      \
 
1800
    epv->f__delete;
 
1801
  e0->f__getURL                  = (char* (*)(void*,sidl_BaseInterface*))     \
 
1802
    epv->f__getURL;
 
1803
  e0->f__raddRef                 = (void (*)(void*,sidl_BaseInterface*))      \
 
1804
    epv->f__raddRef;
 
1805
  e0->f__isRemote                = (sidl_bool (*)(void*,sidl_BaseInterface*)) \
 
1806
    epv->f__isRemote;
1808
1807
  e0->f__set_hooks               = (void (*)(void*,int32_t,                   \
1809
1808
    sidl_BaseInterface*)) epv->f__set_hooks;
1810
 
  e0->f__exec                    = (void (*)(void*,const char*,               \
1811
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1812
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1813
 
  e0->f_SetCommunicator          = (int32_t (*)(void*,                        \
1814
 
    struct bHYPRE_MPICommunicator__object*,                                   \
1815
 
    struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
1816
 
  e0->f_Destroy                  = (void (*)(void*,                           \
1817
 
    struct sidl_BaseInterface__object **)) epv->f_Destroy;
 
1809
  e0->f__exec                    = (void (*)(void*,const char*,struct         \
 
1810
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
 
1811
    sidl_BaseInterface__object **)) epv->f__exec;
 
1812
  e0->f_SetCommunicator          = (int32_t (*)(void*,struct                  \
 
1813
    bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **))    \
 
1814
    epv->f_SetCommunicator;
 
1815
  e0->f_Destroy                  = (void (*)(void*,struct                     \
 
1816
    sidl_BaseInterface__object **)) epv->f_Destroy;
1818
1817
  e0->f_SetIntParameter          = (int32_t (*)(void*,const char*,int32_t,    \
1819
1818
    struct sidl_BaseInterface__object **)) epv->f_SetIntParameter;
1820
1819
  e0->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,     \
1821
1820
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
1822
1821
  e0->f_SetStringParameter       = (int32_t (*)(void*,const char*,const char*,\
1823
1822
    struct sidl_BaseInterface__object **)) epv->f_SetStringParameter;
1824
 
  e0->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,            \
1825
 
    struct sidl_int__array*,                                                  \
1826
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray1Parameter;
1827
 
  e0->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,            \
1828
 
    struct sidl_int__array*,                                                  \
1829
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray2Parameter;
1830
 
  e0->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,            \
1831
 
    struct sidl_double__array*,                                               \
1832
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray1Parameter;
1833
 
  e0->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,            \
1834
 
    struct sidl_double__array*,                                               \
1835
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray2Parameter;
 
1823
  e0->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,struct      \
 
1824
    sidl_int__array*,struct sidl_BaseInterface__object **))                   \
 
1825
    epv->f_SetIntArray1Parameter;
 
1826
  e0->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,struct      \
 
1827
    sidl_int__array*,struct sidl_BaseInterface__object **))                   \
 
1828
    epv->f_SetIntArray2Parameter;
 
1829
  e0->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,struct      \
 
1830
    sidl_double__array*,struct sidl_BaseInterface__object **))                \
 
1831
    epv->f_SetDoubleArray1Parameter;
 
1832
  e0->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,struct      \
 
1833
    sidl_double__array*,struct sidl_BaseInterface__object **))                \
 
1834
    epv->f_SetDoubleArray2Parameter;
1836
1835
  e0->f_GetIntValue              = (int32_t (*)(void*,const char*,int32_t*,   \
1837
1836
    struct sidl_BaseInterface__object **)) epv->f_GetIntValue;
1838
1837
  e0->f_GetDoubleValue           = (int32_t (*)(void*,const char*,double*,    \
1839
1838
    struct sidl_BaseInterface__object **)) epv->f_GetDoubleValue;
1840
 
  e0->f_Setup                    = (int32_t (*)(void*,                        \
1841
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,              \
1842
 
    struct sidl_BaseInterface__object **)) epv->f_Setup;
1843
 
  e0->f_Apply                    = (int32_t (*)(void*,                        \
1844
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,             \
1845
 
    struct sidl_BaseInterface__object **)) epv->f_Apply;
1846
 
  e0->f_ApplyAdjoint             = (int32_t (*)(void*,                        \
1847
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,             \
1848
 
    struct sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
1849
 
  e0->f_addRef                   = (void (*)(void*,                           \
1850
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1851
 
  e0->f_deleteRef                = (void (*)(void*,                           \
1852
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1853
 
  e0->f_isSame                   = (sidl_bool (*)(void*,                      \
1854
 
    struct sidl_BaseInterface__object*,                                       \
1855
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1856
 
  e0->f_isType                   = (sidl_bool (*)(void*,const char*,          \
1857
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
1839
  e0->f_Setup                    = (int32_t (*)(void*,struct                  \
 
1840
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,struct               \
 
1841
    sidl_BaseInterface__object **)) epv->f_Setup;
 
1842
  e0->f_Apply                    = (int32_t (*)(void*,struct                  \
 
1843
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct              \
 
1844
    sidl_BaseInterface__object **)) epv->f_Apply;
 
1845
  e0->f_ApplyAdjoint             = (int32_t (*)(void*,struct                  \
 
1846
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct              \
 
1847
    sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
 
1848
  e0->f_addRef                   = (void (*)(void*,struct                     \
 
1849
    sidl_BaseInterface__object **)) epv->f_addRef;
 
1850
  e0->f_deleteRef                = (void (*)(void*,struct                     \
 
1851
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1852
  e0->f_isSame                   = (sidl_bool (*)(void*,struct                \
 
1853
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1854
    epv->f_isSame;
 
1855
  e0->f_isType                   = (sidl_bool (*)(void*,const char*,struct    \
 
1856
    sidl_BaseInterface__object **)) epv->f_isType;
1858
1857
  e0->f_getClassInfo             = (struct sidl_ClassInfo__object* (*)(void*, \
1859
1858
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
1860
1859
 
1861
1860
  e1->f__cast                    = (void* (*)(void*,const char*,              \
1862
1861
    sidl_BaseInterface*)) epv->f__cast;
1863
 
  e1->f__delete                  = (void (*)(void*,                           \
1864
 
    sidl_BaseInterface*)) epv->f__delete;
1865
 
  e1->f__getURL                  = (char* (*)(void*,                          \
1866
 
    sidl_BaseInterface*)) epv->f__getURL;
1867
 
  e1->f__raddRef                 = (void (*)(void*,                           \
1868
 
    sidl_BaseInterface*)) epv->f__raddRef;
1869
 
  e1->f__isRemote                = (sidl_bool (*)(void*,                      \
1870
 
    sidl_BaseInterface*)) epv->f__isRemote;
 
1862
  e1->f__delete                  = (void (*)(void*,sidl_BaseInterface*))      \
 
1863
    epv->f__delete;
 
1864
  e1->f__getURL                  = (char* (*)(void*,sidl_BaseInterface*))     \
 
1865
    epv->f__getURL;
 
1866
  e1->f__raddRef                 = (void (*)(void*,sidl_BaseInterface*))      \
 
1867
    epv->f__raddRef;
 
1868
  e1->f__isRemote                = (sidl_bool (*)(void*,sidl_BaseInterface*)) \
 
1869
    epv->f__isRemote;
1871
1870
  e1->f__set_hooks               = (void (*)(void*,int32_t,                   \
1872
1871
    sidl_BaseInterface*)) epv->f__set_hooks;
1873
 
  e1->f__exec                    = (void (*)(void*,const char*,               \
1874
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1875
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1876
 
  e1->f_SetOperator              = (int32_t (*)(void*,                        \
1877
 
    struct bHYPRE_Operator__object*,                                          \
1878
 
    struct sidl_BaseInterface__object **)) epv->f_SetOperator;
1879
 
  e1->f_SetTolerance             = (int32_t (*)(void*,double,                 \
1880
 
    struct sidl_BaseInterface__object **)) epv->f_SetTolerance;
1881
 
  e1->f_SetMaxIterations         = (int32_t (*)(void*,int32_t,                \
1882
 
    struct sidl_BaseInterface__object **)) epv->f_SetMaxIterations;
1883
 
  e1->f_SetLogging               = (int32_t (*)(void*,int32_t,                \
1884
 
    struct sidl_BaseInterface__object **)) epv->f_SetLogging;
1885
 
  e1->f_SetPrintLevel            = (int32_t (*)(void*,int32_t,                \
1886
 
    struct sidl_BaseInterface__object **)) epv->f_SetPrintLevel;
1887
 
  e1->f_GetNumIterations         = (int32_t (*)(void*,int32_t*,               \
1888
 
    struct sidl_BaseInterface__object **)) epv->f_GetNumIterations;
1889
 
  e1->f_GetRelResidualNorm       = (int32_t (*)(void*,double*,                \
1890
 
    struct sidl_BaseInterface__object **)) epv->f_GetRelResidualNorm;
1891
 
  e1->f_SetCommunicator          = (int32_t (*)(void*,                        \
1892
 
    struct bHYPRE_MPICommunicator__object*,                                   \
1893
 
    struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
1894
 
  e1->f_Destroy                  = (void (*)(void*,                           \
1895
 
    struct sidl_BaseInterface__object **)) epv->f_Destroy;
 
1872
  e1->f__exec                    = (void (*)(void*,const char*,struct         \
 
1873
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
 
1874
    sidl_BaseInterface__object **)) epv->f__exec;
 
1875
  e1->f_SetOperator              = (int32_t (*)(void*,struct                  \
 
1876
    bHYPRE_Operator__object*,struct sidl_BaseInterface__object **))           \
 
1877
    epv->f_SetOperator;
 
1878
  e1->f_SetTolerance             = (int32_t (*)(void*,double,struct           \
 
1879
    sidl_BaseInterface__object **)) epv->f_SetTolerance;
 
1880
  e1->f_SetMaxIterations         = (int32_t (*)(void*,int32_t,struct          \
 
1881
    sidl_BaseInterface__object **)) epv->f_SetMaxIterations;
 
1882
  e1->f_SetLogging               = (int32_t (*)(void*,int32_t,struct          \
 
1883
    sidl_BaseInterface__object **)) epv->f_SetLogging;
 
1884
  e1->f_SetPrintLevel            = (int32_t (*)(void*,int32_t,struct          \
 
1885
    sidl_BaseInterface__object **)) epv->f_SetPrintLevel;
 
1886
  e1->f_GetNumIterations         = (int32_t (*)(void*,int32_t*,struct         \
 
1887
    sidl_BaseInterface__object **)) epv->f_GetNumIterations;
 
1888
  e1->f_GetRelResidualNorm       = (int32_t (*)(void*,double*,struct          \
 
1889
    sidl_BaseInterface__object **)) epv->f_GetRelResidualNorm;
 
1890
  e1->f_SetCommunicator          = (int32_t (*)(void*,struct                  \
 
1891
    bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **))    \
 
1892
    epv->f_SetCommunicator;
 
1893
  e1->f_Destroy                  = (void (*)(void*,struct                     \
 
1894
    sidl_BaseInterface__object **)) epv->f_Destroy;
1896
1895
  e1->f_SetIntParameter          = (int32_t (*)(void*,const char*,int32_t,    \
1897
1896
    struct sidl_BaseInterface__object **)) epv->f_SetIntParameter;
1898
1897
  e1->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,     \
1899
1898
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
1900
1899
  e1->f_SetStringParameter       = (int32_t (*)(void*,const char*,const char*,\
1901
1900
    struct sidl_BaseInterface__object **)) epv->f_SetStringParameter;
1902
 
  e1->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,            \
1903
 
    struct sidl_int__array*,                                                  \
1904
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray1Parameter;
1905
 
  e1->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,            \
1906
 
    struct sidl_int__array*,                                                  \
1907
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray2Parameter;
1908
 
  e1->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,            \
1909
 
    struct sidl_double__array*,                                               \
1910
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray1Parameter;
1911
 
  e1->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,            \
1912
 
    struct sidl_double__array*,                                               \
1913
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray2Parameter;
 
1901
  e1->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,struct      \
 
1902
    sidl_int__array*,struct sidl_BaseInterface__object **))                   \
 
1903
    epv->f_SetIntArray1Parameter;
 
1904
  e1->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,struct      \
 
1905
    sidl_int__array*,struct sidl_BaseInterface__object **))                   \
 
1906
    epv->f_SetIntArray2Parameter;
 
1907
  e1->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,struct      \
 
1908
    sidl_double__array*,struct sidl_BaseInterface__object **))                \
 
1909
    epv->f_SetDoubleArray1Parameter;
 
1910
  e1->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,struct      \
 
1911
    sidl_double__array*,struct sidl_BaseInterface__object **))                \
 
1912
    epv->f_SetDoubleArray2Parameter;
1914
1913
  e1->f_GetIntValue              = (int32_t (*)(void*,const char*,int32_t*,   \
1915
1914
    struct sidl_BaseInterface__object **)) epv->f_GetIntValue;
1916
1915
  e1->f_GetDoubleValue           = (int32_t (*)(void*,const char*,double*,    \
1917
1916
    struct sidl_BaseInterface__object **)) epv->f_GetDoubleValue;
1918
 
  e1->f_Setup                    = (int32_t (*)(void*,                        \
1919
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,              \
1920
 
    struct sidl_BaseInterface__object **)) epv->f_Setup;
1921
 
  e1->f_Apply                    = (int32_t (*)(void*,                        \
1922
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,             \
1923
 
    struct sidl_BaseInterface__object **)) epv->f_Apply;
1924
 
  e1->f_ApplyAdjoint             = (int32_t (*)(void*,                        \
1925
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,             \
1926
 
    struct sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
1927
 
  e1->f_addRef                   = (void (*)(void*,                           \
1928
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1929
 
  e1->f_deleteRef                = (void (*)(void*,                           \
1930
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1931
 
  e1->f_isSame                   = (sidl_bool (*)(void*,                      \
1932
 
    struct sidl_BaseInterface__object*,                                       \
1933
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1934
 
  e1->f_isType                   = (sidl_bool (*)(void*,const char*,          \
1935
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
1917
  e1->f_Setup                    = (int32_t (*)(void*,struct                  \
 
1918
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,struct               \
 
1919
    sidl_BaseInterface__object **)) epv->f_Setup;
 
1920
  e1->f_Apply                    = (int32_t (*)(void*,struct                  \
 
1921
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct              \
 
1922
    sidl_BaseInterface__object **)) epv->f_Apply;
 
1923
  e1->f_ApplyAdjoint             = (int32_t (*)(void*,struct                  \
 
1924
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct              \
 
1925
    sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
 
1926
  e1->f_addRef                   = (void (*)(void*,struct                     \
 
1927
    sidl_BaseInterface__object **)) epv->f_addRef;
 
1928
  e1->f_deleteRef                = (void (*)(void*,struct                     \
 
1929
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1930
  e1->f_isSame                   = (sidl_bool (*)(void*,struct                \
 
1931
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1932
    epv->f_isSame;
 
1933
  e1->f_isType                   = (sidl_bool (*)(void*,const char*,struct    \
 
1934
    sidl_BaseInterface__object **)) epv->f_isType;
1936
1935
  e1->f_getClassInfo             = (struct sidl_ClassInfo__object* (*)(void*, \
1937
1936
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
1938
1937
 
1949
1948
  e2->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t,      \
1950
1949
    sidl_BaseInterface*)) epv->f__set_hooks;
1951
1950
  e2->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,  \
1952
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1953
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1954
 
  e2->f_addRef       = (void (*)(struct sidl_BaseClass__object*,              \
1955
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1956
 
  e2->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,              \
1957
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1958
 
  e2->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,         \
1959
 
    struct sidl_BaseInterface__object*,                                       \
1960
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1961
 
  e2->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,         \
1962
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
1951
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct      \
 
1952
    sidl_BaseInterface__object **)) epv->f__exec;
 
1953
  e2->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct        \
 
1954
    sidl_BaseInterface__object **)) epv->f_addRef;
 
1955
  e2->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct        \
 
1956
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1957
  e2->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct   \
 
1958
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1959
    epv->f_isSame;
 
1960
  e2->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const    \
 
1961
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
1963
1962
  e2->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct             \
1964
 
    sidl_BaseClass__object*,                                                  \
1965
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1963
    sidl_BaseClass__object*,struct sidl_BaseInterface__object **))            \
 
1964
    epv->f_getClassInfo;
1966
1965
 
1967
 
  e3->f__cast        = (void* (*)(void*,const char*,                          \
1968
 
    sidl_BaseInterface*)) epv->f__cast;
 
1966
  e3->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*))     \
 
1967
    epv->f__cast;
1969
1968
  e3->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
1970
1969
  e3->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
1971
1970
  e3->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
1972
 
  e3->f__isRemote    = (sidl_bool (*)(void*,                                  \
1973
 
    sidl_BaseInterface*)) epv->f__isRemote;
1974
 
  e3->f__set_hooks   = (void (*)(void*,int32_t,                               \
1975
 
    sidl_BaseInterface*)) epv->f__set_hooks;
1976
 
  e3->f__exec        = (void (*)(void*,const char*,                           \
1977
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1978
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1979
 
  e3->f_addRef       = (void (*)(void*,                                       \
1980
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1981
 
  e3->f_deleteRef    = (void (*)(void*,                                       \
1982
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1983
 
  e3->f_isSame       = (sidl_bool (*)(void*,                                  \
1984
 
    struct sidl_BaseInterface__object*,                                       \
1985
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1986
 
  e3->f_isType       = (sidl_bool (*)(void*,const char*,                      \
1987
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
1988
 
  e3->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,             \
1989
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1971
  e3->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*))             \
 
1972
    epv->f__isRemote;
 
1973
  e3->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*))         \
 
1974
    epv->f__set_hooks;
 
1975
  e3->f__exec        = (void (*)(void*,const char*,struct                     \
 
1976
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
 
1977
    sidl_BaseInterface__object **)) epv->f__exec;
 
1978
  e3->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1979
    epv->f_addRef;
 
1980
  e3->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1981
    epv->f_deleteRef;
 
1982
  e3->f_isSame       = (sidl_bool (*)(void*,struct                            \
 
1983
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1984
    epv->f_isSame;
 
1985
  e3->f_isType       = (sidl_bool (*)(void*,const char*,struct                \
 
1986
    sidl_BaseInterface__object **)) epv->f_isType;
 
1987
  e3->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct       \
 
1988
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
1990
1989
 
1991
1990
  s_remote_initialized = 1;
1992
1991
}
2009
2008
  if(url == NULL) {return NULL;}
2010
2009
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
2011
2010
  if(objectID) {
2012
 
    sidl_BaseInterface bi =                                                   \
2013
 
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(      \
 
2011
    sidl_BaseInterface bi = (                                                 \
 
2012
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(       \
2014
2013
      objectID, _ex); SIDL_CHECK(*_ex);
2015
2014
    return bHYPRE_Euclid__rmicast(bi,_ex);SIDL_CHECK(*_ex);
2016
2015
  }
2017
 
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar,                \
2018
 
    _ex ); SIDL_CHECK(*_ex);
 
2016
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex );         \
 
2017
    SIDL_CHECK(*_ex);
2019
2018
  if ( instance == NULL) { return NULL; }
2020
2019
  self =
2021
2020
    (struct bHYPRE_Euclid__object*) malloc(
2060
2059
/* Create an instance that uses an already existing  */
2061
2060
/* InstanceHandle to connect to an existing remote object. */
2062
2061
static struct bHYPRE_Euclid__object*
2063
 
bHYPRE_Euclid__IHConnect(sidl_rmi_InstanceHandle instance,                    \
2064
 
  sidl_BaseInterface *_ex)
 
2062
bHYPRE_Euclid__IHConnect(sidl_rmi_InstanceHandle instance, sidl_BaseInterface \
 
2063
  *_ex)
2065
2064
{
2066
2065
  struct bHYPRE_Euclid__object* self;
2067
2066
 
2121
2120
  struct sidl_BaseClass__object* s1;
2122
2121
 
2123
2122
  struct bHYPRE_Euclid__remote* r_obj;
2124
 
  sidl_rmi_InstanceHandle instance =                                          \
2125
 
    sidl_rmi_ProtocolFactory_createInstance(url, "bHYPRE.Euclid",             \
2126
 
    _ex ); SIDL_CHECK(*_ex);
 
2123
  sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance( \
 
2124
    url, "bHYPRE.Euclid", _ex ); SIDL_CHECK(*_ex);
2127
2125
  if ( instance == NULL) { return NULL; }
2128
2126
  self =
2129
2127
    (struct bHYPRE_Euclid__object*) malloc(
2180
2178
 
2181
2179
  *_ex = NULL;
2182
2180
  if(!connect_loaded) {
2183
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.Euclid",                 \
2184
 
      (void*)bHYPRE_Euclid__IHConnect, _ex);
 
2181
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.Euclid", (               \
 
2182
      void*)bHYPRE_Euclid__IHConnect, _ex);
2185
2183
    connect_loaded = 1;
2186
2184
  }
2187
2185
  if (obj != NULL) {
2202
2200
 */
2203
2201
 
2204
2202
struct bHYPRE_Euclid__object*
2205
 
bHYPRE_Euclid__connectI(const char* url, sidl_bool ar,                        \
2206
 
  struct sidl_BaseInterface__object **_ex)
 
2203
bHYPRE_Euclid__connectI(const char* url, sidl_bool ar, struct                 \
 
2204
  sidl_BaseInterface__object **_ex)
2207
2205
{
2208
2206
  return bHYPRE_Euclid__remoteConnect(url, ar, _ex);
2209
2207
}
2210
2208
 
2211
2209
static PyObject *
2212
 
pStub_Euclid__connect(PyObject *_ignored, PyObject *_args,                    \
2213
 
  PyObject *_kwdict) {
 
2210
pStub_Euclid__connect(PyObject *_ignored, PyObject *_args, PyObject *_kwdict) \
 
2211
  {
2214
2212
  PyObject *_return_value = NULL;
2215
2213
  struct bHYPRE_Euclid__object* self = NULL;
2216
2214
  char* url = NULL;
2233
2231
      sidl_PyExceptionCast(_exception, "sidl.rmi.NetworkException"))) {
2234
2232
        struct sidl_BaseInterface__object *throwaway_exception;
2235
2233
        PyObject *_obj = sidl_rmi_NetworkException__wrap(_ex0);
2236
 
        PyObject *_args = PyTuple_New(1);
2237
 
        PyTuple_SetItem(_args, 0, _obj);
2238
 
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _args);
 
2234
        PyObject *_eargs = PyTuple_New(1);
 
2235
        PyTuple_SetItem(_eargs, 0, _obj);
 
2236
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _eargs);
2239
2237
        PyErr_SetObject(sidl_rmi_NetworkException__type, _obj);
2240
2238
        Py_XDECREF(_obj);
2241
2239
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
2242
2240
          &throwaway_exception);
2243
 
        Py_XDECREF(_args);
 
2241
        Py_XDECREF(_eargs);
2244
2242
      }
2245
2243
    }
2246
2244
    else {
2287
2285
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2288
2286
        struct sidl_BaseInterface__object *throwaway_exception;
2289
2287
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2290
 
        PyObject *_args = PyTuple_New(1);
2291
 
        PyTuple_SetItem(_args, 0, _obj);
2292
 
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2288
        PyObject *_eargs = PyTuple_New(1);
 
2289
        PyTuple_SetItem(_eargs, 0, _obj);
 
2290
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2293
2291
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
2294
2292
        Py_XDECREF(_obj);
2295
2293
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
2296
2294
          &throwaway_exception);
2297
 
        Py_XDECREF(_args);
 
2295
        Py_XDECREF(_eargs);
2298
2296
      }
2299
2297
    }
2300
2298
    else {
2309
2307
}
2310
2308
 
2311
2309
static PyObject *
2312
 
pStub_Euclid_SetParameters(PyObject *_self, PyObject *_args,                  \
2313
 
  PyObject *_kwdict) {
 
2310
pStub_Euclid_SetParameters(PyObject *_self, PyObject *_args, PyObject         \
 
2311
  *_kwdict) {
2314
2312
  PyObject *_return_value = NULL;
2315
2313
  struct bHYPRE_Euclid__object *_self_ior =
2316
2314
    ((struct bHYPRE_Euclid__object *)
2346
2344
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2347
2345
          struct sidl_BaseInterface__object *throwaway_exception;
2348
2346
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2349
 
          PyObject *_args = PyTuple_New(1);
2350
 
          PyTuple_SetItem(_args, 0, _obj);
2351
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2347
          PyObject *_eargs = PyTuple_New(1);
 
2348
          PyTuple_SetItem(_eargs, 0, _obj);
 
2349
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2352
2350
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2353
2351
          Py_XDECREF(_obj);
2354
2352
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2355
2353
            &throwaway_exception);
2356
 
          Py_XDECREF(_args);
 
2354
          Py_XDECREF(_eargs);
2357
2355
        }
2358
2356
      }
2359
2357
      else {
2361
2359
          "lz",
2362
2360
          _proxy__return,
2363
2361
          argv);
2364
 
      }
2365
 
      free((void *)argv);
 
2362
      free((void *)argv);}
2366
2363
    }
2367
2364
    {
2368
2365
      struct sidl_BaseInterface__object *throwaway_exception;
2412
2409
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2413
2410
          struct sidl_BaseInterface__object *throwaway_exception;
2414
2411
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2415
 
          PyObject *_args = PyTuple_New(1);
2416
 
          PyTuple_SetItem(_args, 0, _obj);
2417
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2412
          PyObject *_eargs = PyTuple_New(1);
 
2413
          PyTuple_SetItem(_eargs, 0, _obj);
 
2414
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2418
2415
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2419
2416
          Py_XDECREF(_obj);
2420
2417
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2421
2418
            &throwaway_exception);
2422
 
          Py_XDECREF(_args);
 
2419
          Py_XDECREF(_eargs);
2423
2420
        }
2424
2421
      }
2425
2422
      else {
2466
2463
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2467
2464
          struct sidl_BaseInterface__object *throwaway_exception;
2468
2465
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2469
 
          PyObject *_args = PyTuple_New(1);
2470
 
          PyTuple_SetItem(_args, 0, _obj);
2471
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2466
          PyObject *_eargs = PyTuple_New(1);
 
2467
          PyTuple_SetItem(_eargs, 0, _obj);
 
2468
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2472
2469
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2473
2470
          Py_XDECREF(_obj);
2474
2471
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2475
2472
            &throwaway_exception);
2476
 
          Py_XDECREF(_args);
 
2473
          Py_XDECREF(_eargs);
2477
2474
        }
2478
2475
      }
2479
2476
      else {
2480
2477
        _return_value = Py_BuildValue(
2481
2478
          "z",
2482
2479
          _return);
 
2480
        free((void *)_return);
2483
2481
      }
2484
 
      free((void *)_return);
2485
2482
    }
2486
2483
    {
2487
2484
      struct sidl_BaseInterface__object *throwaway_exception;
2522
2519
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2523
2520
          struct sidl_BaseInterface__object *throwaway_exception;
2524
2521
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2525
 
          PyObject *_args = PyTuple_New(1);
2526
 
          PyTuple_SetItem(_args, 0, _obj);
2527
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2522
          PyObject *_eargs = PyTuple_New(1);
 
2523
          PyTuple_SetItem(_eargs, 0, _obj);
 
2524
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2528
2525
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2529
2526
          Py_XDECREF(_obj);
2530
2527
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2531
2528
            &throwaway_exception);
2532
 
          Py_XDECREF(_args);
 
2529
          Py_XDECREF(_eargs);
2533
2530
        }
2534
2531
      }
2535
2532
      else {
2577
2574
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2578
2575
          struct sidl_BaseInterface__object *throwaway_exception;
2579
2576
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2580
 
          PyObject *_args = PyTuple_New(1);
2581
 
          PyTuple_SetItem(_args, 0, _obj);
2582
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2577
          PyObject *_eargs = PyTuple_New(1);
 
2578
          PyTuple_SetItem(_eargs, 0, _obj);
 
2579
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2583
2580
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2584
2581
          Py_XDECREF(_obj);
2585
2582
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2586
2583
            &throwaway_exception);
2587
 
          Py_XDECREF(_args);
 
2584
          Py_XDECREF(_eargs);
2588
2585
        }
2589
2586
      }
2590
2587
      else {
2634
2631
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2635
2632
          struct sidl_BaseInterface__object *throwaway_exception;
2636
2633
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2637
 
          PyObject *_args = PyTuple_New(1);
2638
 
          PyTuple_SetItem(_args, 0, _obj);
2639
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2634
          PyObject *_eargs = PyTuple_New(1);
 
2635
          PyTuple_SetItem(_eargs, 0, _obj);
 
2636
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2640
2637
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2641
2638
          Py_XDECREF(_obj);
2642
2639
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2643
2640
            &throwaway_exception);
2644
 
          Py_XDECREF(_args);
 
2641
          Py_XDECREF(_eargs);
2645
2642
        }
2646
2643
      }
2647
2644
      else {
2662
2659
}
2663
2660
 
2664
2661
static PyObject *
2665
 
pStub_Euclid__set_hooks_static(PyObject *_ignored, PyObject *_args,           \
2666
 
  PyObject *_kwdict) {
 
2662
pStub_Euclid__set_hooks_static(PyObject *_ignored, PyObject *_args, PyObject  \
 
2663
  *_kwdict) {
2667
2664
  PyObject *_return_value = NULL;
2668
2665
  sidl_bool on = (sidl_bool) 0;
2669
2666
  struct sidl_BaseInterface__object *_exception = NULL;
2687
2684
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2688
2685
        struct sidl_BaseInterface__object *throwaway_exception;
2689
2686
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2690
 
        PyObject *_args = PyTuple_New(1);
2691
 
        PyTuple_SetItem(_args, 0, _obj);
2692
 
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2687
        PyObject *_eargs = PyTuple_New(1);
 
2688
        PyTuple_SetItem(_eargs, 0, _obj);
 
2689
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2693
2690
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
2694
2691
        Py_XDECREF(_obj);
2695
2692
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
2696
2693
          &throwaway_exception);
2697
 
        Py_XDECREF(_args);
 
2694
        Py_XDECREF(_eargs);
2698
2695
      }
2699
2696
    }
2700
2697
    else {
2714
2711
  char* url = NULL;
2715
2712
  PyObject * implObj = NULL;
2716
2713
  static char *_kwlist[] = {"sobj",  "url", "impl", NULL };
2717
 
  int _okay = PyArg_ParseTupleAndKeywords(args, kwds, "|O&zO", _kwlist,       \
2718
 
    (void *)bHYPRE_Euclid__convert, &optarg, &url, &implObj);
 
2714
  int _okay = PyArg_ParseTupleAndKeywords(args, kwds, "|O&zO", _kwlist, (void \
 
2715
    *)bHYPRE_Euclid__convert, &optarg, &url, &implObj);
2719
2716
  if (_okay) {
2720
2717
    if (!optarg && !url && !implObj) {
2721
2718
      struct sidl_BaseInterface__object *_exception;
2728
2725
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2729
2726
            struct sidl_BaseInterface__object *throwaway_exception;
2730
2727
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2731
 
            PyObject *_args = PyTuple_New(1);
2732
 
            PyTuple_SetItem(_args, 0, _obj);
2733
 
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2728
            PyObject *_eargs = PyTuple_New(1);
 
2729
            PyTuple_SetItem(_eargs, 0, _obj);
 
2730
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2734
2731
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
2735
2732
            Py_XDECREF(_obj);
2736
2733
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,         \
2737
2734
              &throwaway_exception);
2738
 
            Py_XDECREF(_args);
 
2735
            Py_XDECREF(_eargs);
2739
2736
          }
2740
2737
          return -1;
2741
2738
        }
2753
2750
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2754
2751
            struct sidl_BaseInterface__object *throwaway_exception;
2755
2752
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2756
 
            PyObject *_args = PyTuple_New(1);
2757
 
            PyTuple_SetItem(_args, 0, _obj);
2758
 
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2753
            PyObject *_eargs = PyTuple_New(1);
 
2754
            PyTuple_SetItem(_eargs, 0, _obj);
 
2755
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2759
2756
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
2760
2757
            Py_XDECREF(_obj);
2761
2758
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,         \
2762
2759
              &throwaway_exception);
2763
 
            Py_XDECREF(_args);
 
2760
            Py_XDECREF(_eargs);
2764
2761
          }
2765
2762
          return -1;
2766
2763
        }
2776
2773
      sidl_PyExceptionCast(_exception, "sidl.rmi.NetworkException"))) {
2777
2774
        struct sidl_BaseInterface__object *throwaway_exception;
2778
2775
        PyObject *_obj = sidl_rmi_NetworkException__wrap(_ex0);
2779
 
        PyObject *_args = PyTuple_New(1);
2780
 
        PyTuple_SetItem(_args, 0, _obj);
2781
 
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _args);
 
2776
        PyObject *_eargs = PyTuple_New(1);
 
2777
        PyTuple_SetItem(_eargs, 0, _obj);
 
2778
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _eargs);
2782
2779
        PyErr_SetObject(sidl_rmi_NetworkException__type, _obj);
2783
2780
        Py_XDECREF(_obj);
2784
2781
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
2785
2782
          &throwaway_exception);
2786
 
        Py_XDECREF(_args);
 
2783
        Py_XDECREF(_eargs);
2787
2784
      }
2788
2785
      return -1;
2789
2786
    }
2812
2809
   (bHYPRE.Euclid _return)\n\
2813
2810
RAISES\n\
2814
2811
    sidl.RuntimeException\n\
2815
 
"
 
2812
\n\
 
2813
\
 
2814
 This function is the preferred way to create a Euclid solver. "
2816
2815
   },
2817
2816
  { "_connect", (PyCFunction)pStub_Euclid__connect,
2818
2817
  (METH_VARARGS | METH_KEYWORDS),
2944
2943
Objects of this type can be cast to Solver objects using the\n\
2945
2944
{\\tt \\_\\_cast} methods.\n\
2946
2945
\n\
2947
 
RDF: Documentation goes here.\n\
2948
2946
Although the usual Solver SetParameter functions are available,\n\
2949
2947
a Euclid-stype parameter-setting function is also available, SetParameters.", /* tp_doc */
2950
2948
  0,      /* tp_traverse */
3178
3176
Objects of this type can be cast to Solver objects using the\n\
3179
3177
{\\tt \\_\\_cast} methods.\n\
3180
3178
\n\
3181
 
RDF: Documentation goes here.\n\
3182
3179
Although the usual Solver SetParameter functions are available,\n\
3183
3180
a Euclid-stype parameter-setting function is also available, SetParameters."
3184
3181
  );
3185
3182
  dict = PyModule_GetDict(module);
3186
3183
  ExternalAPI[bHYPRE_Euclid__wrap_NUM] = (void*)bHYPRE_Euclid__wrap;
3187
3184
  ExternalAPI[bHYPRE_Euclid__convert_NUM] = (void*)bHYPRE_Euclid__convert;
3188
 
  ExternalAPI[bHYPRE_Euclid__convert_python_array_NUM] =                      \
3189
 
    (void*)bHYPRE_Euclid__convert_python_array;
3190
 
  ExternalAPI[bHYPRE_Euclid__convert_sidl_array_NUM] =                        \
3191
 
    (void*)bHYPRE_Euclid__convert_sidl_array;
 
3185
  ExternalAPI[bHYPRE_Euclid__convert_python_array_NUM] = (                    \
 
3186
    void*)bHYPRE_Euclid__convert_python_array;
 
3187
  ExternalAPI[bHYPRE_Euclid__convert_sidl_array_NUM] = (                      \
 
3188
    void*)bHYPRE_Euclid__convert_sidl_array;
3192
3189
  ExternalAPI[bHYPRE_Euclid__weakRef_NUM] = (void*)bHYPRE_Euclid__weakRef;
3193
3190
  ExternalAPI[bHYPRE_Euclid_deref_NUM] = (void*)bHYPRE_Euclid_deref;
3194
3191
  ExternalAPI[bHYPRE_Euclid__newRef_NUM] = (void*)bHYPRE_Euclid__newRef;
3215
3212
  sidl_BaseClass__import();
3216
3213
  _bHYPRE_EuclidType.tp_base = sidl_BaseClass_PyType();
3217
3214
  _bHYPRE_EuclidType.tp_bases = PyTuple_New(2);
3218
 
  PyTuple_SetItem(_bHYPRE_EuclidType.tp_bases,0,                              \
3219
 
    (PyObject *)sidl_BaseClass_PyType());
3220
 
  PyTuple_SetItem(_bHYPRE_EuclidType.tp_bases,1,                              \
3221
 
    (PyObject *)bHYPRE_Solver_PyType());
 
3215
  PyTuple_SetItem(_bHYPRE_EuclidType.tp_bases,0, (PyObject                    \
 
3216
    *)sidl_BaseClass_PyType());
 
3217
  PyTuple_SetItem(_bHYPRE_EuclidType.tp_bases,1, (PyObject                    \
 
3218
    *)bHYPRE_Solver_PyType());
3222
3219
  if (PyType_Ready(&_bHYPRE_EuclidType) < 0) {
3223
3220
    PyErr_Print();
3224
3221
    fprintf(stderr, "PyType_Ready on bHYPRE.Euclid failed.\n");
3263
3260
    Py_FatalError("Cannot load implementation for sidl class bHYPRE.Euclid");
3264
3261
  }
3265
3262
 
3266
 
  sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.Euclid",                   \
3267
 
    (void*)bHYPRE_Euclid__IHConnect, &throwaway_exception);
 
3263
  sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.Euclid", (                 \
 
3264
    void*)bHYPRE_Euclid__IHConnect, &throwaway_exception);
3268
3265
}