cbc-wrapper 2.9.9 → 2.9.9.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 6b421327ceba58d263c08464b555eaaa3a6ba179
4
- data.tar.gz: 6292a774f0ae034ee79a16ce10e6f80daf82d1eb
3
+ metadata.gz: 460543a4e3b6e79e7dba5f2eb62eb0d5f7d2c1ba
4
+ data.tar.gz: a0d8ce6a6cf2df3b363b1a50b068b138d6c03aaa
5
5
  SHA512:
6
- metadata.gz: 4eef24ec3cd8cfbf93b3a5101a7a8721e740343772d3e66d5cbae31226f362b624d3405d992cad5bc21725ba9780c9fc4c7723f4af31cad2d28fe6bb3210d2c6
7
- data.tar.gz: 5417820e85a4e832cd820b76e4502489bfbb0c29d9b9b4bfb8890dea102d1b7263395eea31cdfd7cc89b716f675979d2015505e1747cdef39e07cf0f2006f58b
6
+ metadata.gz: ce75ac1697e9a7aa418a5b565ba99f020603ca030444be1356f4ca89b947af2ab77e69239770db75f5c6bd473be4ba7721f3bfb2d77f8306f8ac42782f9d53c7
7
+ data.tar.gz: 01b79d34916760949885b0e2b82bed311465698c82731276782573a0d4789a6640cd3b1ecbf1dce0ea8ecc9957aece2550bf375f377c16be6da5a4418fdb40f4
@@ -1,6 +1,6 @@
1
1
  /* ----------------------------------------------------------------------------
2
2
  * This file was automatically generated by SWIG (http://www.swig.org).
3
- * Version 2.0.11
3
+ * Version 3.0.8
4
4
  *
5
5
  * This file is not intended to be easily readable and contains a number of
6
6
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -8,7 +8,11 @@
8
8
  * interface file instead.
9
9
  * ----------------------------------------------------------------------------- */
10
10
 
11
+
12
+ #ifndef SWIGRUBY
11
13
  #define SWIGRUBY
14
+ #endif
15
+
12
16
 
13
17
  /* -----------------------------------------------------------------------------
14
18
  * This section contains generic SWIG labels for method/variable
@@ -118,6 +122,19 @@
118
122
  # define _SCL_SECURE_NO_DEPRECATE
119
123
  #endif
120
124
 
125
+ /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
126
+ #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
127
+ # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
128
+ #endif
129
+
130
+ /* Intel's compiler complains if a variable which was never initialised is
131
+ * cast to void, which is a common idiom which we use to indicate that we
132
+ * are aware a variable isn't used. So we just silence that warning.
133
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
134
+ */
135
+ #ifdef __INTEL_COMPILER
136
+ # pragma warning disable 592
137
+ #endif
121
138
 
122
139
  /* -----------------------------------------------------------------------------
123
140
  * This section contains generic SWIG labels for method/variable
@@ -227,6 +244,19 @@
227
244
  # define _SCL_SECURE_NO_DEPRECATE
228
245
  #endif
229
246
 
247
+ /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
248
+ #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
249
+ # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
250
+ #endif
251
+
252
+ /* Intel's compiler complains if a variable which was never initialised is
253
+ * cast to void, which is a common idiom which we use to indicate that we
254
+ * are aware a variable isn't used. So we just silence that warning.
255
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
256
+ */
257
+ #ifdef __INTEL_COMPILER
258
+ # pragma warning disable 592
259
+ #endif
230
260
 
231
261
  /* -----------------------------------------------------------------------------
232
262
  * swigrun.swg
@@ -634,14 +664,14 @@ SWIG_MangledTypeQueryModule(swig_module_info *start,
634
664
  swig_module_info *iter = start;
635
665
  do {
636
666
  if (iter->size) {
637
- register size_t l = 0;
638
- register size_t r = iter->size - 1;
667
+ size_t l = 0;
668
+ size_t r = iter->size - 1;
639
669
  do {
640
670
  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
641
- register size_t i = (l + r) >> 1;
671
+ size_t i = (l + r) >> 1;
642
672
  const char *iname = iter->types[i]->name;
643
673
  if (iname) {
644
- register int compare = strcmp(name, iname);
674
+ int compare = strcmp(name, iname);
645
675
  if (compare == 0) {
646
676
  return iter->types[i];
647
677
  } else if (compare < 0) {
@@ -685,7 +715,7 @@ SWIG_TypeQueryModule(swig_module_info *start,
685
715
  of the str field (the human readable name) */
686
716
  swig_module_info *iter = start;
687
717
  do {
688
- register size_t i = 0;
718
+ size_t i = 0;
689
719
  for (; i < iter->size; ++i) {
690
720
  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
691
721
  return iter->types[i];
@@ -704,10 +734,10 @@ SWIG_TypeQueryModule(swig_module_info *start,
704
734
  SWIGRUNTIME char *
705
735
  SWIG_PackData(char *c, void *ptr, size_t sz) {
706
736
  static const char hex[17] = "0123456789abcdef";
707
- register const unsigned char *u = (unsigned char *) ptr;
708
- register const unsigned char *eu = u + sz;
737
+ const unsigned char *u = (unsigned char *) ptr;
738
+ const unsigned char *eu = u + sz;
709
739
  for (; u != eu; ++u) {
710
- register unsigned char uu = *u;
740
+ unsigned char uu = *u;
711
741
  *(c++) = hex[(uu & 0xf0) >> 4];
712
742
  *(c++) = hex[uu & 0xf];
713
743
  }
@@ -719,11 +749,11 @@ SWIG_PackData(char *c, void *ptr, size_t sz) {
719
749
  */
720
750
  SWIGRUNTIME const char *
721
751
  SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
722
- register unsigned char *u = (unsigned char *) ptr;
723
- register const unsigned char *eu = u + sz;
752
+ unsigned char *u = (unsigned char *) ptr;
753
+ const unsigned char *eu = u + sz;
724
754
  for (; u != eu; ++u) {
725
- register char d = *(c++);
726
- register unsigned char uu;
755
+ char d = *(c++);
756
+ unsigned char uu;
727
757
  if ((d >= '0') && (d <= '9'))
728
758
  uu = ((d - '0') << 4);
729
759
  else if ((d >= 'a') && (d <= 'f'))
@@ -1144,6 +1174,11 @@ void Ruby_Format_OverloadedError(
1144
1174
  extern "C" {
1145
1175
  #endif
1146
1176
 
1177
+ #if !defined(ST_DATA_T_DEFINED)
1178
+ /* Needs to be explicitly included for Ruby 1.8 and earlier */
1179
+ #include <st.h>
1180
+ #endif
1181
+
1147
1182
  /* Ruby 1.8 actually assumes the first case. */
1148
1183
  #if SIZEOF_VOIDP == SIZEOF_LONG
1149
1184
  # define SWIG2NUM(v) LONG2NUM((unsigned long)v)
@@ -1155,19 +1190,19 @@ extern "C" {
1155
1190
  # error sizeof(void*) is not the same as long or long long
1156
1191
  #endif
1157
1192
 
1158
-
1159
- /* Global Ruby hash table to store Trackings from C/C++
1193
+ /* Global hash table to store Trackings from C/C++
1160
1194
  structs to Ruby Objects.
1161
1195
  */
1162
- static VALUE swig_ruby_trackings = Qnil;
1196
+ static st_table* swig_ruby_trackings = NULL;
1197
+
1198
+ static VALUE swig_ruby_trackings_count(ANYARGS) {
1199
+ return SWIG2NUM(swig_ruby_trackings->num_entries);
1200
+ }
1163
1201
 
1164
- /* Global variable that stores a reference to the ruby
1165
- hash table delete function. */
1166
- static ID swig_ruby_hash_delete;
1167
1202
 
1168
- /* Setup a Ruby hash table to store Trackings */
1203
+ /* Setup a hash table to store Trackings */
1169
1204
  SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
1170
- /* Create a ruby hash table to store Trackings from C++
1205
+ /* Create a hash table to store Trackings from C++
1171
1206
  objects to Ruby objects. */
1172
1207
 
1173
1208
  /* Try to see if some other .so has already created a
@@ -1176,88 +1211,46 @@ SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
1176
1211
  This is done to allow multiple DSOs to share the same
1177
1212
  tracking table.
1178
1213
  */
1179
- ID trackings_id = rb_intern( "@__trackings__" );
1214
+ VALUE trackings_value = Qnil;
1215
+ /* change the variable name so that we can mix modules
1216
+ compiled with older SWIG's - this used to be called "@__trackings__" */
1217
+ ID trackings_id = rb_intern( "@__safetrackings__" );
1180
1218
  VALUE verbose = rb_gv_get("VERBOSE");
1181
1219
  rb_gv_set("VERBOSE", Qfalse);
1182
- swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
1220
+ trackings_value = rb_ivar_get( _mSWIG, trackings_id );
1183
1221
  rb_gv_set("VERBOSE", verbose);
1184
1222
 
1185
- /* No, it hasn't. Create one ourselves */
1186
- if ( swig_ruby_trackings == Qnil )
1187
- {
1188
- swig_ruby_trackings = rb_hash_new();
1189
- rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
1190
- }
1191
-
1192
- /* Now store a reference to the hash table delete function
1193
- so that we only have to look it up once.*/
1194
- swig_ruby_hash_delete = rb_intern("delete");
1195
- }
1196
-
1197
- /* Get a Ruby number to reference a pointer */
1198
- SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
1199
- /* We cast the pointer to an unsigned long
1200
- and then store a reference to it using
1201
- a Ruby number object. */
1202
-
1203
- /* Convert the pointer to a Ruby number */
1204
- return SWIG2NUM(ptr);
1205
- }
1206
-
1207
- /* Get a Ruby number to reference an object */
1208
- SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
1209
- /* We cast the object to an unsigned long
1210
- and then store a reference to it using
1211
- a Ruby number object. */
1212
-
1213
- /* Convert the Object to a Ruby number */
1214
- return SWIG2NUM(object);
1215
- }
1216
-
1217
- /* Get a Ruby object from a previously stored reference */
1218
- SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
1219
- /* The provided Ruby number object is a reference
1220
- to the Ruby object we want.*/
1223
+ /* The trick here is that we have to store the hash table
1224
+ pointer in a Ruby variable. We do not want Ruby's GC to
1225
+ treat this pointer as a Ruby object, so we convert it to
1226
+ a Ruby numeric value. */
1227
+ if (trackings_value == Qnil) {
1228
+ /* No, it hasn't. Create one ourselves */
1229
+ swig_ruby_trackings = st_init_numtable();
1230
+ rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
1231
+ } else {
1232
+ swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
1233
+ }
1221
1234
 
1222
- /* Convert the Ruby number to a Ruby object */
1223
- return NUM2SWIG(reference);
1235
+ rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", swig_ruby_trackings_count, NULL);
1224
1236
  }
1225
1237
 
1226
1238
  /* Add a Tracking from a C/C++ struct to a Ruby object */
1227
1239
  SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
1228
- /* In a Ruby hash table we store the pointer and
1229
- the associated Ruby object. The trick here is
1230
- that we cannot store the Ruby object directly - if
1231
- we do then it cannot be garbage collected. So
1232
- instead we typecast it as a unsigned long and
1233
- convert it to a Ruby number object.*/
1234
-
1235
- /* Get a reference to the pointer as a Ruby number */
1236
- VALUE key = SWIG_RubyPtrToReference(ptr);
1237
-
1238
- /* Get a reference to the Ruby object as a Ruby number */
1239
- VALUE value = SWIG_RubyObjectToReference(object);
1240
-
1241
1240
  /* Store the mapping to the global hash table. */
1242
- rb_hash_aset(swig_ruby_trackings, key, value);
1241
+ st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
1243
1242
  }
1244
1243
 
1245
1244
  /* Get the Ruby object that owns the specified C/C++ struct */
1246
1245
  SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
1247
- /* Get a reference to the pointer as a Ruby number */
1248
- VALUE key = SWIG_RubyPtrToReference(ptr);
1249
-
1250
1246
  /* Now lookup the value stored in the global hash table */
1251
- VALUE value = rb_hash_aref(swig_ruby_trackings, key);
1252
-
1253
- if (value == Qnil) {
1254
- /* No object exists - return nil. */
1247
+ VALUE value;
1248
+
1249
+ if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
1250
+ return value;
1251
+ } else {
1255
1252
  return Qnil;
1256
1253
  }
1257
- else {
1258
- /* Convert this value to Ruby object */
1259
- return SWIG_RubyReferenceToObject(value);
1260
- }
1261
1254
  }
1262
1255
 
1263
1256
  /* Remove a Tracking from a C/C++ struct to a Ruby object. It
@@ -1265,12 +1258,8 @@ SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
1265
1258
  since the same memory address may be reused later to create
1266
1259
  a new object. */
1267
1260
  SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
1268
- /* Get a reference to the pointer as a Ruby number */
1269
- VALUE key = SWIG_RubyPtrToReference(ptr);
1270
-
1271
- /* Delete the object from the hash table by calling Ruby's
1272
- do this we need to call the Hash.delete method.*/
1273
- rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
1261
+ /* Delete the object from the hash table */
1262
+ st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
1274
1263
  }
1275
1264
 
1276
1265
  /* This is a helper method that unlinks a Ruby object from its
@@ -1280,10 +1269,25 @@ SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
1280
1269
  VALUE object = SWIG_RubyInstanceFor(ptr);
1281
1270
 
1282
1271
  if (object != Qnil) {
1272
+ if (TYPE(object) != T_DATA)
1273
+ abort();
1283
1274
  DATA_PTR(object) = 0;
1284
1275
  }
1285
1276
  }
1286
1277
 
1278
+ /* This is a helper method that iterates over all the trackings
1279
+ passing the C++ object pointer and its related Ruby object
1280
+ to the passed callback function. */
1281
+
1282
+ /* Proxy method to abstract the internal trackings datatype */
1283
+ static int swig_ruby_internal_iterate_callback(void* ptr, VALUE obj, void(*meth)(void* ptr, VALUE obj)) {
1284
+ (*meth)(ptr, obj);
1285
+ return ST_CONTINUE;
1286
+ }
1287
+
1288
+ SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
1289
+ st_foreach(swig_ruby_trackings, (int (*)(ANYARGS))&swig_ruby_internal_iterate_callback, (st_data_t)meth);
1290
+ }
1287
1291
 
1288
1292
  #ifdef __cplusplus
1289
1293
  }
@@ -1342,7 +1346,7 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
1342
1346
  #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1343
1347
  #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
1344
1348
  #define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own)
1345
- #define swig_owntype ruby_owntype
1349
+ #define swig_owntype swig_ruby_owntype
1346
1350
 
1347
1351
  /* for raw packed data */
1348
1352
  #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
@@ -1479,14 +1483,13 @@ SWIG_Ruby_InitRuntime(void)
1479
1483
  SWIGRUNTIME void
1480
1484
  SWIG_Ruby_define_class(swig_type_info *type)
1481
1485
  {
1482
- VALUE klass;
1483
1486
  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1484
1487
  sprintf(klass_name, "TYPE%s", type->name);
1485
1488
  if (NIL_P(_cSWIG_Pointer)) {
1486
1489
  _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
1487
1490
  rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
1488
1491
  }
1489
- klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
1492
+ rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
1490
1493
  free((void *) klass_name);
1491
1494
  }
1492
1495
 
@@ -1567,22 +1570,24 @@ SWIG_Ruby_MangleStr(VALUE obj)
1567
1570
  }
1568
1571
 
1569
1572
  /* Acquire a pointer value */
1570
- typedef void (*ruby_owntype)(void*);
1573
+ typedef struct {
1574
+ void (*datafree)(void *);
1575
+ int own;
1576
+ } swig_ruby_owntype;
1571
1577
 
1572
- SWIGRUNTIME ruby_owntype
1573
- SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
1578
+ SWIGRUNTIME swig_ruby_owntype
1579
+ SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
1580
+ swig_ruby_owntype oldown = {0, 0};
1574
1581
  if (obj) {
1575
- ruby_owntype oldown = RDATA(obj)->dfree;
1576
- RDATA(obj)->dfree = own;
1577
- return oldown;
1578
- } else {
1579
- return 0;
1582
+ oldown.datafree = RDATA(obj)->dfree;
1583
+ RDATA(obj)->dfree = own.datafree;
1580
1584
  }
1585
+ return oldown;
1581
1586
  }
1582
1587
 
1583
1588
  /* Convert a pointer value */
1584
1589
  SWIGRUNTIME int
1585
- SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
1590
+ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
1586
1591
  {
1587
1592
  char *c;
1588
1593
  swig_cast_info *tc;
@@ -1590,7 +1595,8 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
1590
1595
 
1591
1596
  /* Grab the pointer */
1592
1597
  if (NIL_P(obj)) {
1593
- *ptr = 0;
1598
+ if (ptr)
1599
+ *ptr = 0;
1594
1600
  return SWIG_OK;
1595
1601
  } else {
1596
1602
  if (TYPE(obj) != T_DATA) {
@@ -1599,7 +1605,10 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
1599
1605
  Data_Get_Struct(obj, void, vptr);
1600
1606
  }
1601
1607
 
1602
- if (own) *own = RDATA(obj)->dfree;
1608
+ if (own) {
1609
+ own->datafree = RDATA(obj)->dfree;
1610
+ own->own = 0;
1611
+ }
1603
1612
 
1604
1613
  /* Check to see if the input object is giving up ownership
1605
1614
  of the underlying C struct or C++ object. If so then we
@@ -1628,16 +1637,6 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
1628
1637
 
1629
1638
  /* Do type-checking if type info was provided */
1630
1639
  if (ty) {
1631
- if (ty->clientdata) {
1632
- if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
1633
- if (vptr == 0) {
1634
- /* The object has already been deleted */
1635
- return SWIG_ObjectPreviouslyDeletedError;
1636
- }
1637
- *ptr = vptr;
1638
- return SWIG_OK;
1639
- }
1640
- }
1641
1640
  if ((c = SWIG_MangleStr(obj)) == NULL) {
1642
1641
  return SWIG_ERROR;
1643
1642
  }
@@ -1645,12 +1644,27 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
1645
1644
  if (!tc) {
1646
1645
  return SWIG_ERROR;
1647
1646
  } else {
1648
- int newmemory = 0;
1649
- *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
1650
- assert(!newmemory); /* newmemory handling not yet implemented */
1647
+ if (vptr == 0) {
1648
+ /* The object has already been deleted */
1649
+ return SWIG_ObjectPreviouslyDeletedError;
1650
+ }
1651
+ if (ptr) {
1652
+ if (tc->type == ty) {
1653
+ *ptr = vptr;
1654
+ } else {
1655
+ int newmemory = 0;
1656
+ *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
1657
+ if (newmemory == SWIG_CAST_NEW_MEMORY) {
1658
+ assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1659
+ if (own)
1660
+ own->own = own->own | SWIG_CAST_NEW_MEMORY;
1661
+ }
1662
+ }
1663
+ }
1651
1664
  }
1652
1665
  } else {
1653
- *ptr = vptr;
1666
+ if (ptr)
1667
+ *ptr = vptr;
1654
1668
  }
1655
1669
 
1656
1670
  return SWIG_OK;
@@ -1801,7 +1815,7 @@ static VALUE mCbc_wrapper;
1801
1815
  #define SWIG_RUBY_THREAD_END_BLOCK
1802
1816
 
1803
1817
 
1804
- #define SWIGVERSION 0x020011
1818
+ #define SWIGVERSION 0x030008
1805
1819
  #define SWIG_VERSION SWIGVERSION
1806
1820
 
1807
1821
 
@@ -1813,7 +1827,7 @@ static VALUE mCbc_wrapper;
1813
1827
  extern "C" {
1814
1828
  #endif
1815
1829
 
1816
- // Ruby 1.9 changed the file name of this header
1830
+ /* Ruby 1.9 changed the file name of this header */
1817
1831
  #ifdef HAVE_RUBY_IO_H
1818
1832
  #include "ruby/io.h"
1819
1833
  #else
@@ -1851,7 +1865,7 @@ SWIG_ruby_failed(void)
1851
1865
  }
1852
1866
 
1853
1867
 
1854
- /*@SWIG:/usr/share/swig2.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
1868
+ /*@SWIG:/usr/local/Cellar/swig/3.0.8/share/swig/3.0.8/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
1855
1869
  SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
1856
1870
  {
1857
1871
  VALUE obj = args[0];
@@ -1916,7 +1930,7 @@ SWIG_From_int (int value)
1916
1930
  }
1917
1931
 
1918
1932
 
1919
- /*@SWIG:/usr/share/swig2.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
1933
+ /*@SWIG:/usr/local/Cellar/swig/3.0.8/share/swig/3.0.8/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
1920
1934
  SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
1921
1935
  {
1922
1936
  VALUE obj = args[0];
@@ -1982,13 +1996,13 @@ SWIGINTERN double DoubleArray___getitem__(DoubleArray *self,size_t index){
1982
1996
  #define SWIG_From_double rb_float_new
1983
1997
 
1984
1998
 
1985
- /*@SWIG:/usr/share/swig2.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
1999
+ /*@SWIG:/usr/local/Cellar/swig/3.0.8/share/swig/3.0.8/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
1986
2000
  SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
1987
2001
  {
1988
2002
  VALUE obj = args[0];
1989
2003
  VALUE type = TYPE(obj);
1990
2004
  double *res = (double *)(args[1]);
1991
- *res = NUM2DBL(obj);
2005
+ *res = NUM2DBL(obj); (void)type;
1992
2006
  return obj;
1993
2007
  }
1994
2008
  /*@SWIG@*/
@@ -2153,7 +2167,8 @@ SWIGINTERN void delete_IntArray(IntArray *self){
2153
2167
  free((char*)self);
2154
2168
  }
2155
2169
  SWIGINTERN void
2156
- free_IntArray(IntArray *arg1) {
2170
+ free_IntArray(void *self) {
2171
+ IntArray *arg1 = (IntArray *)self;
2157
2172
  delete_IntArray(arg1);
2158
2173
  }
2159
2174
 
@@ -2338,7 +2353,8 @@ SWIGINTERN void delete_DoubleArray(DoubleArray *self){
2338
2353
  free((char*)self);
2339
2354
  }
2340
2355
  SWIGINTERN void
2341
- free_DoubleArray(DoubleArray *arg1) {
2356
+ free_DoubleArray(void *self) {
2357
+ DoubleArray *arg1 = (DoubleArray *)self;
2342
2358
  delete_DoubleArray(arg1);
2343
2359
  }
2344
2360
 
@@ -4286,7 +4302,7 @@ static swig_cast_info *swig_cast_initial[] = {
4286
4302
  * array with the correct data and linking the correct swig_cast_info
4287
4303
  * structures together.
4288
4304
  *
4289
- * The generated swig_type_info structures are assigned staticly to an initial
4305
+ * The generated swig_type_info structures are assigned statically to an initial
4290
4306
  * array. We just loop through that array, and handle each type individually.
4291
4307
  * First we lookup if this type has been already loaded, and if so, use the
4292
4308
  * loaded structure instead of the generated one. Then we have to fill in the
@@ -4330,7 +4346,7 @@ SWIGRUNTIME void
4330
4346
  SWIG_InitializeModule(void *clientdata) {
4331
4347
  size_t i;
4332
4348
  swig_module_info *module_head, *iter;
4333
- int found, init;
4349
+ int init;
4334
4350
 
4335
4351
  /* check to see if the circular list has been setup, if not, set it up */
4336
4352
  if (swig_module.next==0) {
@@ -4349,22 +4365,18 @@ SWIG_InitializeModule(void *clientdata) {
4349
4365
  /* This is the first module loaded for this interpreter */
4350
4366
  /* so set the swig module into the interpreter */
4351
4367
  SWIG_SetModule(clientdata, &swig_module);
4352
- module_head = &swig_module;
4353
4368
  } else {
4354
4369
  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4355
- found=0;
4356
4370
  iter=module_head;
4357
4371
  do {
4358
4372
  if (iter==&swig_module) {
4359
- found=1;
4360
- break;
4373
+ /* Our module is already in the list, so there's nothing more to do. */
4374
+ return;
4361
4375
  }
4362
4376
  iter=iter->next;
4363
4377
  } while (iter!= module_head);
4364
4378
 
4365
- /* if the is found in the list, then all is done and we may leave */
4366
- if (found) return;
4367
- /* otherwise we must add out module into the list */
4379
+ /* otherwise we must add our module into the list */
4368
4380
  swig_module.next = module_head->next;
4369
4381
  module_head->next = &swig_module;
4370
4382
  }
@@ -1,3 +1,3 @@
1
1
  module CbcWrapper
2
- VERSION = "2.9.9"
2
+ VERSION = "2.9.9.2"
3
3
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: cbc-wrapper
3
3
  version: !ruby/object:Gem::Version
4
- version: 2.9.9
4
+ version: 2.9.9.2
5
5
  platform: ruby
6
6
  authors:
7
7
  - Guillaume Verger
8
8
  autorequire:
9
9
  bindir: exe
10
10
  cert_chain: []
11
- date: 2017-08-02 00:00:00.000000000 Z
11
+ date: 2017-08-03 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: bundler
@@ -115,4 +115,3 @@ signing_key:
115
115
  specification_version: 4
116
116
  summary: Bare wrapper around Cbc Linear Programming Solver made with SWIG
117
117
  test_files: []
118
- has_rdoc: