rbcdio 0.02 → 0.03

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.
@@ -1,6 +1,6 @@
1
1
  /* ----------------------------------------------------------------------------
2
2
  * This file was automatically generated by SWIG (http://www.swig.org).
3
- * Version 1.3.31
3
+ * Version 1.3.33
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
@@ -16,14 +16,14 @@
16
16
 
17
17
  /* template workaround for compilers that cannot correctly implement the C++ standard */
18
18
  #ifndef SWIGTEMPLATEDISAMBIGUATOR
19
- # if defined(__SUNPRO_CC)
20
- # if (__SUNPRO_CC <= 0x560)
21
- # define SWIGTEMPLATEDISAMBIGUATOR template
22
- # else
23
- # define SWIGTEMPLATEDISAMBIGUATOR
24
- # endif
19
+ # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
20
+ # define SWIGTEMPLATEDISAMBIGUATOR template
21
+ # elif defined(__HP_aCC)
22
+ /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
23
+ /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
24
+ # define SWIGTEMPLATEDISAMBIGUATOR template
25
25
  # else
26
- # define SWIGTEMPLATEDISAMBIGUATOR
26
+ # define SWIGTEMPLATEDISAMBIGUATOR
27
27
  # endif
28
28
  #endif
29
29
 
@@ -106,6 +106,12 @@
106
106
  # define _CRT_SECURE_NO_DEPRECATE
107
107
  #endif
108
108
 
109
+ /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
110
+ #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
111
+ # define _SCL_SECURE_NO_DEPRECATE
112
+ #endif
113
+
114
+
109
115
  /* -----------------------------------------------------------------------------
110
116
  * This section contains generic SWIG labels for method/variable
111
117
  * declarations/attributes, and other compiler dependent labels.
@@ -113,14 +119,14 @@
113
119
 
114
120
  /* template workaround for compilers that cannot correctly implement the C++ standard */
115
121
  #ifndef SWIGTEMPLATEDISAMBIGUATOR
116
- # if defined(__SUNPRO_CC)
117
- # if (__SUNPRO_CC <= 0x560)
118
- # define SWIGTEMPLATEDISAMBIGUATOR template
119
- # else
120
- # define SWIGTEMPLATEDISAMBIGUATOR
121
- # endif
122
+ # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
123
+ # define SWIGTEMPLATEDISAMBIGUATOR template
124
+ # elif defined(__HP_aCC)
125
+ /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
126
+ /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
127
+ # define SWIGTEMPLATEDISAMBIGUATOR template
122
128
  # else
123
- # define SWIGTEMPLATEDISAMBIGUATOR
129
+ # define SWIGTEMPLATEDISAMBIGUATOR
124
130
  # endif
125
131
  #endif
126
132
 
@@ -203,6 +209,12 @@
203
209
  # define _CRT_SECURE_NO_DEPRECATE
204
210
  #endif
205
211
 
212
+ /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
213
+ #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
214
+ # define _SCL_SECURE_NO_DEPRECATE
215
+ #endif
216
+
217
+
206
218
  /* -----------------------------------------------------------------------------
207
219
  * swigrun.swg
208
220
  *
@@ -435,7 +447,7 @@ SWIG_TypeNameComp(const char *f1, const char *l1,
435
447
  while ((*f2 == ' ') && (f2 != l2)) ++f2;
436
448
  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
437
449
  }
438
- return (l1 - f1) - (l2 - f2);
450
+ return (int)((l1 - f1) - (l2 - f2));
439
451
  }
440
452
 
441
453
  /*
@@ -791,6 +803,15 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
791
803
 
792
804
  #include <ruby.h>
793
805
 
806
+ /* Remove global macros defined in Ruby's win32.h */
807
+ #ifdef write
808
+ # undef write
809
+ #endif
810
+ #ifdef read
811
+ # undef read
812
+ #endif
813
+
814
+
794
815
  /* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
795
816
  #ifndef NUM2LL
796
817
  #define NUM2LL(x) NUM2LONG((x))
@@ -886,6 +907,7 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
886
907
  #define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
887
908
  #endif
888
909
 
910
+ static VALUE _mSWIG = Qnil;
889
911
 
890
912
  /* -----------------------------------------------------------------------------
891
913
  * error manipulation
@@ -976,7 +998,71 @@ SWIG_Ruby_ErrorType(int SWIG_code) {
976
998
  }
977
999
 
978
1000
 
1001
+ /* This function is called when a user inputs a wrong argument to
1002
+ a method.
1003
+ */
1004
+ SWIGINTERN
1005
+ const char* Ruby_Format_TypeError( const char* msg,
1006
+ const char* type,
1007
+ const char* name,
1008
+ const int argn,
1009
+ VALUE input )
1010
+ {
1011
+ char buf[128];
1012
+ VALUE str;
1013
+ VALUE asStr;
1014
+ if ( msg && *msg )
1015
+ {
1016
+ str = rb_str_new2(msg);
1017
+ }
1018
+ else
1019
+ {
1020
+ str = rb_str_new(NULL, 0);
1021
+ }
1022
+
1023
+ str = rb_str_cat2( str, "Expected argument " );
1024
+ sprintf( buf, "%d of type ", argn-1 );
1025
+ str = rb_str_cat2( str, buf );
1026
+ str = rb_str_cat2( str, type );
1027
+ str = rb_str_cat2( str, ", but got " );
1028
+ str = rb_str_cat2( str, rb_obj_classname(input) );
1029
+ str = rb_str_cat2( str, " " );
1030
+ asStr = rb_inspect(input);
1031
+ if ( RSTRING_LEN(asStr) > 30 )
1032
+ {
1033
+ str = rb_str_cat( str, StringValuePtr(asStr), 30 );
1034
+ str = rb_str_cat2( str, "..." );
1035
+ }
1036
+ else
1037
+ {
1038
+ str = rb_str_append( str, asStr );
1039
+ }
1040
+
1041
+ if ( name )
1042
+ {
1043
+ str = rb_str_cat2( str, "\n\tin SWIG method '" );
1044
+ str = rb_str_cat2( str, name );
1045
+ str = rb_str_cat2( str, "'" );
1046
+ }
1047
+
1048
+ return StringValuePtr( str );
1049
+ }
979
1050
 
1051
+ /* This function is called when an overloaded method fails */
1052
+ SWIGINTERN
1053
+ void Ruby_Format_OverloadedError(
1054
+ const int argc,
1055
+ const int maxargs,
1056
+ const char* method,
1057
+ const char* prototypes
1058
+ )
1059
+ {
1060
+ const char* msg = "Wrong # of arguments";
1061
+ if ( argc <= maxargs ) msg = "Wrong arguments";
1062
+ rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"
1063
+ "Possible C/C++ prototypes are:\n%s",
1064
+ msg, method, prototypes);
1065
+ }
980
1066
 
981
1067
  /* -----------------------------------------------------------------------------
982
1068
  * See the LICENSE file for information on copyright, usage and redistribution
@@ -994,26 +1080,54 @@ SWIG_Ruby_ErrorType(int SWIG_code) {
994
1080
  extern "C" {
995
1081
  #endif
996
1082
 
1083
+ /* Ruby 1.8 actually assumes the first case. */
1084
+ #if SIZEOF_VOIDP == SIZEOF_LONG
1085
+ # define SWIG2NUM(v) LONG2NUM((unsigned long)v)
1086
+ # define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
1087
+ #elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
1088
+ # define SWIG2NUM(v) LL2NUM((unsigned long long)v)
1089
+ # define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
1090
+ #else
1091
+ # error sizeof(void*) is not the same as long or long long
1092
+ #endif
1093
+
997
1094
 
998
1095
  /* Global Ruby hash table to store Trackings from C/C++
999
- structs to Ruby Objects. */
1000
- static VALUE swig_ruby_trackings;
1001
-
1002
- /* Global variable that stores a reference to the ruby
1003
- hash table delete function. */
1004
- static ID swig_ruby_hash_delete = 0;
1096
+ structs to Ruby Objects.
1097
+ */
1098
+ static VALUE swig_ruby_trackings = Qnil;
1099
+
1100
+ /* Global variable that stores a reference to the ruby
1101
+ hash table delete function. */
1102
+ static ID swig_ruby_hash_delete;
1005
1103
 
1006
1104
  /* Setup a Ruby hash table to store Trackings */
1007
1105
  SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
1008
1106
  /* Create a ruby hash table to store Trackings from C++
1009
- objects to Ruby objects. Also make sure to tell
1010
- the garabage collector about the hash table. */
1011
- swig_ruby_trackings = rb_hash_new();
1012
- rb_gc_register_address(&swig_ruby_trackings);
1013
-
1014
- /* Now store a reference to the hash table delete function
1015
- so that we only have to look it up once.*/
1016
- swig_ruby_hash_delete = rb_intern("delete");
1107
+ objects to Ruby objects. */
1108
+
1109
+ /* Try to see if some other .so has already created a
1110
+ tracking hash table, which we keep hidden in an instance var
1111
+ in the SWIG module.
1112
+ This is done to allow multiple DSOs to share the same
1113
+ tracking table.
1114
+ */
1115
+ ID trackings_id = rb_intern( "@__trackings__" );
1116
+ VALUE verbose = rb_gv_get("VERBOSE");
1117
+ rb_gv_set("VERBOSE", Qfalse);
1118
+ swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
1119
+ rb_gv_set("VERBOSE", verbose);
1120
+
1121
+ /* No, it hasn't. Create one ourselves */
1122
+ if ( swig_ruby_trackings == Qnil )
1123
+ {
1124
+ swig_ruby_trackings = rb_hash_new();
1125
+ rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
1126
+ }
1127
+
1128
+ /* Now store a reference to the hash table delete function
1129
+ so that we only have to look it up once.*/
1130
+ swig_ruby_hash_delete = rb_intern("delete");
1017
1131
  }
1018
1132
 
1019
1133
  /* Get a Ruby number to reference a pointer */
@@ -1023,8 +1137,7 @@ SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
1023
1137
  a Ruby number object. */
1024
1138
 
1025
1139
  /* Convert the pointer to a Ruby number */
1026
- unsigned long value = (unsigned long) ptr;
1027
- return LONG2NUM(value);
1140
+ return SWIG2NUM(ptr);
1028
1141
  }
1029
1142
 
1030
1143
  /* Get a Ruby number to reference an object */
@@ -1034,8 +1147,7 @@ SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
1034
1147
  a Ruby number object. */
1035
1148
 
1036
1149
  /* Convert the Object to a Ruby number */
1037
- unsigned long value = (unsigned long) object;
1038
- return LONG2NUM(value);
1150
+ return SWIG2NUM(object);
1039
1151
  }
1040
1152
 
1041
1153
  /* Get a Ruby object from a previously stored reference */
@@ -1043,9 +1155,8 @@ SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
1043
1155
  /* The provided Ruby number object is a reference
1044
1156
  to the Ruby object we want.*/
1045
1157
 
1046
- /* First convert the Ruby number to a C number */
1047
- unsigned long value = NUM2LONG(reference);
1048
- return (VALUE) value;
1158
+ /* Convert the Ruby number to a Ruby object */
1159
+ return NUM2SWIG(reference);
1049
1160
  }
1050
1161
 
1051
1162
  /* Add a Tracking from a C/C++ struct to a Ruby object */
@@ -1137,6 +1248,15 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
1137
1248
  return target;
1138
1249
  }
1139
1250
 
1251
+ /* For ruby1.8.4 and earlier. */
1252
+ #ifndef RUBY_INIT_STACK
1253
+ RUBY_EXTERN void Init_stack(VALUE* addr);
1254
+ # define RUBY_INIT_STACK \
1255
+ VALUE variable_in_this_stack_frame; \
1256
+ Init_stack(&variable_in_this_stack_frame);
1257
+ #endif
1258
+
1259
+
1140
1260
  #ifdef __cplusplus
1141
1261
  }
1142
1262
  #endif
@@ -1208,9 +1328,6 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
1208
1328
 
1209
1329
  #ifdef __cplusplus
1210
1330
  extern "C" {
1211
- #if 0
1212
- } /* cc-mode */
1213
- #endif
1214
1331
  #endif
1215
1332
 
1216
1333
  typedef struct {
@@ -1222,10 +1339,44 @@ typedef struct {
1222
1339
  } swig_class;
1223
1340
 
1224
1341
 
1225
- static VALUE _mSWIG = Qnil;
1342
+ /* Global pointer used to keep some internal SWIG stuff */
1226
1343
  static VALUE _cSWIG_Pointer = Qnil;
1227
1344
  static VALUE swig_runtime_data_type_pointer = Qnil;
1228
1345
 
1346
+ /* Global IDs used to keep some internal SWIG stuff */
1347
+ static ID swig_arity_id = 0;
1348
+ static ID swig_call_id = 0;
1349
+
1350
+ /*
1351
+ If your swig extension is to be run within an embedded ruby and has
1352
+ director callbacks, you should set -DRUBY_EMBEDDED during compilation.
1353
+ This will reset ruby's stack frame on each entry point from the main
1354
+ program the first time a virtual director function is invoked (in a
1355
+ non-recursive way).
1356
+ If this is not done, you run the risk of Ruby trashing the stack.
1357
+ */
1358
+
1359
+ #ifdef RUBY_EMBEDDED
1360
+
1361
+ # define SWIG_INIT_STACK \
1362
+ if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
1363
+ ++swig_virtual_calls;
1364
+ # define SWIG_RELEASE_STACK --swig_virtual_calls;
1365
+ # define Ruby_DirectorTypeMismatchException(x) \
1366
+ rb_raise( rb_eTypeError, x ); return c_result;
1367
+
1368
+ static unsigned int swig_virtual_calls = 0;
1369
+
1370
+ #else /* normal non-embedded extension */
1371
+
1372
+ # define SWIG_INIT_STACK
1373
+ # define SWIG_RELEASE_STACK
1374
+ # define Ruby_DirectorTypeMismatchException(x) \
1375
+ throw Swig::DirectorTypeMismatchException( x );
1376
+
1377
+ #endif /* RUBY_EMBEDDED */
1378
+
1379
+
1229
1380
  SWIGRUNTIME VALUE
1230
1381
  getExceptionClass(void) {
1231
1382
  static int init = 0;
@@ -1257,6 +1408,8 @@ SWIG_Ruby_InitRuntime(void)
1257
1408
  {
1258
1409
  if (_mSWIG == Qnil) {
1259
1410
  _mSWIG = rb_define_module("SWIG");
1411
+ swig_call_id = rb_intern("call");
1412
+ swig_arity_id = rb_intern("arity");
1260
1413
  }
1261
1414
  }
1262
1415
 
@@ -1280,7 +1433,7 @@ SWIGRUNTIME VALUE
1280
1433
  SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
1281
1434
  {
1282
1435
  int own = flags & SWIG_POINTER_OWN;
1283
-
1436
+ int track;
1284
1437
  char *klass_name;
1285
1438
  swig_class *sklass;
1286
1439
  VALUE klass;
@@ -1293,14 +1446,15 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
1293
1446
  sklass = (swig_class *) type->clientdata;
1294
1447
 
1295
1448
  /* Are we tracking this class and have we already returned this Ruby object? */
1296
- if (sklass->trackObjects) {
1449
+ track = sklass->trackObjects;
1450
+ if (track) {
1297
1451
  obj = SWIG_RubyInstanceFor(ptr);
1298
1452
 
1299
1453
  /* Check the object's type and make sure it has the correct type.
1300
1454
  It might not in cases where methods do things like
1301
1455
  downcast methods. */
1302
1456
  if (obj != Qnil) {
1303
- VALUE value = rb_iv_get(obj, "__swigtype__");
1457
+ VALUE value = rb_iv_get(obj, "@__swigtype__");
1304
1458
  char* type_name = RSTRING_PTR(value);
1305
1459
 
1306
1460
  if (strcmp(type->name, type_name) == 0) {
@@ -1310,10 +1464,13 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
1310
1464
  }
1311
1465
 
1312
1466
  /* Create a new Ruby object */
1313
- obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
1467
+ obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark),
1468
+ ( own ? VOIDFUNC(sklass->destroy) :
1469
+ (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
1470
+ ), ptr);
1314
1471
 
1315
1472
  /* If tracking is on for this class then track this object. */
1316
- if (sklass->trackObjects) {
1473
+ if (track) {
1317
1474
  SWIG_RubyAddTracking(ptr, obj);
1318
1475
  }
1319
1476
  } else {
@@ -1323,7 +1480,7 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
1323
1480
  free((void *) klass_name);
1324
1481
  obj = Data_Wrap_Struct(klass, 0, 0, ptr);
1325
1482
  }
1326
- rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
1483
+ rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
1327
1484
 
1328
1485
  return obj;
1329
1486
  }
@@ -1335,7 +1492,7 @@ SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
1335
1492
  VALUE obj;
1336
1493
  swig_class *sklass = (swig_class *) type->clientdata;
1337
1494
  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
1338
- rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
1495
+ rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
1339
1496
  return obj;
1340
1497
  }
1341
1498
 
@@ -1343,7 +1500,7 @@ SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
1343
1500
  SWIGRUNTIMEINLINE char *
1344
1501
  SWIG_Ruby_MangleStr(VALUE obj)
1345
1502
  {
1346
- VALUE stype = rb_iv_get(obj, "__swigtype__");
1503
+ VALUE stype = rb_iv_get(obj, "@__swigtype__");
1347
1504
  return StringValuePtr(stype);
1348
1505
  }
1349
1506
 
@@ -1507,10 +1664,42 @@ SWIG_Ruby_SetModule(swig_module_info *pointer)
1507
1664
  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
1508
1665
  }
1509
1666
 
1667
+ /* This function can be used to check whether a proc or method or similarly
1668
+ callable function has been passed. Usually used in a %typecheck, like:
1669
+
1670
+ %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
1671
+ $result = SWIG_Ruby_isCallable( $input );
1672
+ }
1673
+ */
1674
+ SWIGINTERN
1675
+ int SWIG_Ruby_isCallable( VALUE proc )
1676
+ {
1677
+ if ( rb_respond_to( proc, swig_call_id ) == Qtrue )
1678
+ return 1;
1679
+ return 0;
1680
+ }
1681
+
1682
+ /* This function can be used to check the arity (number of arguments)
1683
+ a proc or method can take. Usually used in a %typecheck.
1684
+ Valid arities will be that equal to minimal or those < 0
1685
+ which indicate a variable number of parameters at the end.
1686
+ */
1687
+ SWIGINTERN
1688
+ int SWIG_Ruby_arity( VALUE proc, int minimal )
1689
+ {
1690
+ if ( rb_respond_to( proc, swig_arity_id ) == Qtrue )
1691
+ {
1692
+ VALUE num = rb_funcall( proc, swig_arity_id, 0 );
1693
+ int arity = NUM2INT(num);
1694
+ if ( arity < 0 && (arity+1) < -minimal ) return 1;
1695
+ if ( arity == minimal ) return 1;
1696
+ return 1;
1697
+ }
1698
+ return 0;
1699
+ }
1700
+
1701
+
1510
1702
  #ifdef __cplusplus
1511
- #if 0
1512
- { /* cc-mode */
1513
- #endif
1514
1703
  }
1515
1704
  #endif
1516
1705
 
@@ -1550,7 +1739,11 @@ static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
1550
1739
 
1551
1740
  static VALUE mRubyiso9660;
1552
1741
 
1553
- #define SWIGVERSION 0x010331
1742
+ #define SWIG_RUBY_THREAD_BEGIN_BLOCK
1743
+ #define SWIG_RUBY_THREAD_END_BLOCK
1744
+
1745
+
1746
+ #define SWIGVERSION 0x010333
1554
1747
  #define SWIG_VERSION SWIGVERSION
1555
1748
 
1556
1749
 
@@ -1565,14 +1758,12 @@ static VALUE mRubyiso9660;
1565
1758
 
1566
1759
 
1567
1760
  #include <limits.h>
1568
- #ifndef LLONG_MIN
1569
- # define LLONG_MIN LONG_LONG_MIN
1570
- #endif
1571
- #ifndef LLONG_MAX
1572
- # define LLONG_MAX LONG_LONG_MAX
1573
- #endif
1574
- #ifndef ULLONG_MAX
1575
- # define ULLONG_MAX ULONG_LONG_MAX
1761
+ #if !defined(SWIG_NO_LLONG_MAX)
1762
+ # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1763
+ # define LLONG_MAX __LONG_LONG_MAX__
1764
+ # define LLONG_MIN (-LLONG_MAX - 1LL)
1765
+ # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1766
+ # endif
1576
1767
  #endif
1577
1768
 
1578
1769
 
@@ -1678,7 +1869,7 @@ SWIG_ruby_failed(void)
1678
1869
  }
1679
1870
 
1680
1871
 
1681
- /*@SWIG:%ruby_aux_method@*/
1872
+ /*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
1682
1873
  SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
1683
1874
  {
1684
1875
  VALUE obj = args[0];
@@ -1723,7 +1914,7 @@ SWIG_AsVal_int (VALUE obj, int *val)
1723
1914
  }
1724
1915
 
1725
1916
 
1726
- /*@SWIG:%ruby_aux_method@*/
1917
+ /*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
1727
1918
  SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
1728
1919
  {
1729
1920
  VALUE obj = args[0];
@@ -1785,11 +1976,11 @@ SWIGINTERN int
1785
1976
  SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
1786
1977
  {
1787
1978
  if (TYPE(obj) == T_STRING) {
1788
-
1789
-
1790
-
1979
+ #if defined(StringValuePtr)
1980
+ char *cstr = StringValuePtr(obj);
1981
+ #else
1791
1982
  char *cstr = STR2CSTR(obj);
1792
-
1983
+ #endif
1793
1984
  size_t size = RSTRING_LEN(obj) + 1;
1794
1985
  if (cptr) {
1795
1986
  if (alloc) {
@@ -2158,26 +2349,26 @@ _wrap_cdio_read_sectors(int argc, VALUE *argv, VALUE self) {
2158
2349
  }
2159
2350
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2160
2351
  if (!SWIG_IsOK(res1)) {
2161
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_read_sectors" "', argument " "1"" of type '" "CdIo_t const *""'");
2352
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_read_sectors", 1, argv[0] ));
2162
2353
  }
2163
2354
  arg1 = (CdIo_t *)(argp1);
2164
2355
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
2165
2356
  if (!SWIG_IsOK(res2)) {
2166
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdio_read_sectors" "', argument " "2"" of type '" "void *""'");
2357
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","cdio_read_sectors", 2, argv[1] ));
2167
2358
  }
2168
2359
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
2169
2360
  if (!SWIG_IsOK(ecode3)) {
2170
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdio_read_sectors" "', argument " "3"" of type '" "lsn_t""'");
2361
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "lsn_t","cdio_read_sectors", 3, argv[2] ));
2171
2362
  }
2172
2363
  arg3 = (lsn_t)(val3);
2173
2364
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
2174
2365
  if (!SWIG_IsOK(ecode4)) {
2175
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cdio_read_sectors" "', argument " "4"" of type '" "cdio_read_mode_t""'");
2366
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "cdio_read_mode_t","cdio_read_sectors", 4, argv[3] ));
2176
2367
  }
2177
2368
  arg4 = (cdio_read_mode_t)(val4);
2178
2369
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[4], &val5);
2179
2370
  if (!SWIG_IsOK(ecode5)) {
2180
- SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cdio_read_sectors" "', argument " "5"" of type '" "unsigned int""'");
2371
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned int","cdio_read_sectors", 5, argv[4] ));
2181
2372
  }
2182
2373
  arg5 = (unsigned int)(val5);
2183
2374
  result = (driver_return_code_t)cdio_read_sectors((CdIo_t const *)arg1,arg2,arg3,arg4,arg5);
@@ -2202,7 +2393,7 @@ _wrap_cdio_eject_media_drive(int argc, VALUE *argv, VALUE self) {
2202
2393
  }
2203
2394
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
2204
2395
  if (!SWIG_IsOK(res1)) {
2205
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_eject_media_drive" "', argument " "1"" of type '" "char const *""'");
2396
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdio_eject_media_drive", 1, argv[0] ));
2206
2397
  }
2207
2398
  arg1 = (char *)(buf1);
2208
2399
  result = (driver_return_code_t)cdio_eject_media_drive((char const *)arg1);
@@ -2215,6 +2406,18 @@ fail:
2215
2406
  }
2216
2407
 
2217
2408
 
2409
+
2410
+ /*
2411
+ Document-method: Rubyiso9660.open_iso
2412
+
2413
+ call-seq:
2414
+ open_iso(psz_path) -> iso9660_t
2415
+
2416
+ open_iso(path)
2417
+ Open an ISO 9660 image for reading. Maybe in the future we will have
2418
+ mode. None is returned on error.
2419
+ .
2420
+ */
2218
2421
  SWIGINTERN VALUE
2219
2422
  _wrap_open_iso(int argc, VALUE *argv, VALUE self) {
2220
2423
  char *arg1 = (char *) 0 ;
@@ -2229,7 +2432,7 @@ _wrap_open_iso(int argc, VALUE *argv, VALUE self) {
2229
2432
  }
2230
2433
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
2231
2434
  if (!SWIG_IsOK(res1)) {
2232
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_open" "', argument " "1"" of type '" "char const *""'");
2435
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","iso9660_open", 1, argv[0] ));
2233
2436
  }
2234
2437
  arg1 = (char *)(buf1);
2235
2438
  result = (iso9660_t *)iso9660_open((char const *)arg1);
@@ -2242,6 +2445,17 @@ fail:
2242
2445
  }
2243
2446
 
2244
2447
 
2448
+
2449
+ /*
2450
+ Document-method: Rubyiso9660.open_ext
2451
+
2452
+ call-seq:
2453
+ open_ext(psz_path, iso_extension_mask) -> iso9660_t
2454
+
2455
+ Open an ISO 9660 image for reading allowing various ISO 9660
2456
+ extensions. Maybe in the future we will have a mode. None is
2457
+ returned on error..
2458
+ */
2245
2459
  SWIGINTERN VALUE
2246
2460
  _wrap_open_ext(int argc, VALUE *argv, VALUE self) {
2247
2461
  char *arg1 = (char *) 0 ;
@@ -2259,12 +2473,12 @@ _wrap_open_ext(int argc, VALUE *argv, VALUE self) {
2259
2473
  }
2260
2474
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
2261
2475
  if (!SWIG_IsOK(res1)) {
2262
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_open_ext" "', argument " "1"" of type '" "char const *""'");
2476
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","iso9660_open_ext", 1, argv[0] ));
2263
2477
  }
2264
2478
  arg1 = (char *)(buf1);
2265
2479
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
2266
2480
  if (!SWIG_IsOK(ecode2)) {
2267
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "iso9660_open_ext" "', argument " "2"" of type '" "iso_extension_mask_t""'");
2481
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "iso_extension_mask_t","iso9660_open_ext", 2, argv[1] ));
2268
2482
  }
2269
2483
  arg2 = (iso_extension_mask_t)(val2);
2270
2484
  result = (iso9660_t *)iso9660_open_ext((char const *)arg1,arg2);
@@ -2277,6 +2491,21 @@ fail:
2277
2491
  }
2278
2492
 
2279
2493
 
2494
+
2495
+ /*
2496
+ Document-method: Rubyiso9660.open_fuzzy
2497
+
2498
+ call-seq:
2499
+ open_fuzzy(psz_path, i_fuzz) -> iso9660_t
2500
+
2501
+ Open an ISO 9660 image for reading with some tolerence for positioning
2502
+ of the ISO9660 image. We scan for ISO_STANDARD_ID and use that to set
2503
+ the eventual offset to adjust by (as long as that is <= i_fuzz).
2504
+
2505
+ Maybe in the future we will have a mode. None is returned on error.
2506
+
2507
+ see iso9660_open.
2508
+ */
2280
2509
  SWIGINTERN VALUE
2281
2510
  _wrap_open_fuzzy(int argc, VALUE *argv, VALUE self) {
2282
2511
  char *arg1 = (char *) 0 ;
@@ -2294,12 +2523,12 @@ _wrap_open_fuzzy(int argc, VALUE *argv, VALUE self) {
2294
2523
  }
2295
2524
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
2296
2525
  if (!SWIG_IsOK(res1)) {
2297
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_open_fuzzy" "', argument " "1"" of type '" "char const *""'");
2526
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","iso9660_open_fuzzy", 1, argv[0] ));
2298
2527
  }
2299
2528
  arg1 = (char *)(buf1);
2300
2529
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
2301
2530
  if (!SWIG_IsOK(ecode2)) {
2302
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "iso9660_open_fuzzy" "', argument " "2"" of type '" "unsigned int""'");
2531
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","iso9660_open_fuzzy", 2, argv[1] ));
2303
2532
  }
2304
2533
  arg2 = (unsigned int)(val2);
2305
2534
  result = (iso9660_t *)iso9660_open_fuzzy((char const *)arg1,arg2);
@@ -2312,6 +2541,22 @@ fail:
2312
2541
  }
2313
2542
 
2314
2543
 
2544
+
2545
+ /*
2546
+ Document-method: Rubyiso9660.iso9660_open_fuzzy_ext
2547
+
2548
+ call-seq:
2549
+ iso9660_open_fuzzy_ext(psz_path, iso_extension_mask, i_fuzz) -> iso9660_t
2550
+
2551
+ Open an ISO 9660 image for reading with some tolerence for positioning
2552
+ of the ISO9660 image. We scan for ISO_STANDARD_ID and use that to set
2553
+ the eventual offset to adjust by (as long as that is <= i_fuzz).
2554
+
2555
+ Maybe in the future we will have a mode. None is returned on error.
2556
+
2557
+ see open_iso
2558
+ .
2559
+ */
2315
2560
  SWIGINTERN VALUE
2316
2561
  _wrap_iso9660_open_fuzzy_ext(int argc, VALUE *argv, VALUE self) {
2317
2562
  char *arg1 = (char *) 0 ;
@@ -2332,17 +2577,17 @@ _wrap_iso9660_open_fuzzy_ext(int argc, VALUE *argv, VALUE self) {
2332
2577
  }
2333
2578
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
2334
2579
  if (!SWIG_IsOK(res1)) {
2335
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_open_fuzzy_ext" "', argument " "1"" of type '" "char const *""'");
2580
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","iso9660_open_fuzzy_ext", 1, argv[0] ));
2336
2581
  }
2337
2582
  arg1 = (char *)(buf1);
2338
2583
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
2339
2584
  if (!SWIG_IsOK(ecode2)) {
2340
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "iso9660_open_fuzzy_ext" "', argument " "2"" of type '" "iso_extension_mask_t""'");
2585
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "iso_extension_mask_t","iso9660_open_fuzzy_ext", 2, argv[1] ));
2341
2586
  }
2342
2587
  arg2 = (iso_extension_mask_t)(val2);
2343
2588
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
2344
2589
  if (!SWIG_IsOK(ecode3)) {
2345
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "iso9660_open_fuzzy_ext" "', argument " "3"" of type '" "unsigned int""'");
2590
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","iso9660_open_fuzzy_ext", 3, argv[2] ));
2346
2591
  }
2347
2592
  arg3 = (unsigned int)(val3);
2348
2593
  result = (iso9660_t *)iso9660_open_fuzzy_ext((char const *)arg1,arg2,arg3);
@@ -2355,6 +2600,19 @@ fail:
2355
2600
  }
2356
2601
 
2357
2602
 
2603
+
2604
+ /*
2605
+ Document-method: Rubyiso9660.ifs_fuzzy_read_superblock
2606
+
2607
+ call-seq:
2608
+ ifs_fuzzy_read_superblock(p_iso, iso_extension_mask, i_fuzz) -> bool
2609
+
2610
+ Read the Super block of an ISO 9660 image but determine framesize
2611
+ and datastart and a possible additional offset. Generally here we are
2612
+ not reading an ISO 9660 image but a CD-Image which contains an ISO 9660
2613
+ filesystem.
2614
+ .
2615
+ */
2358
2616
  SWIGINTERN VALUE
2359
2617
  _wrap_ifs_fuzzy_read_superblock(int argc, VALUE *argv, VALUE self) {
2360
2618
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -2374,17 +2632,17 @@ _wrap_ifs_fuzzy_read_superblock(int argc, VALUE *argv, VALUE self) {
2374
2632
  }
2375
2633
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
2376
2634
  if (!SWIG_IsOK(res1)) {
2377
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_ifs_fuzzy_read_superblock" "', argument " "1"" of type '" "iso9660_t *""'");
2635
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","iso9660_ifs_fuzzy_read_superblock", 1, argv[0] ));
2378
2636
  }
2379
2637
  arg1 = (iso9660_t *)(argp1);
2380
2638
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
2381
2639
  if (!SWIG_IsOK(ecode2)) {
2382
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "iso9660_ifs_fuzzy_read_superblock" "', argument " "2"" of type '" "iso_extension_mask_t""'");
2640
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "iso_extension_mask_t","iso9660_ifs_fuzzy_read_superblock", 2, argv[1] ));
2383
2641
  }
2384
2642
  arg2 = (iso_extension_mask_t)(val2);
2385
2643
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
2386
2644
  if (!SWIG_IsOK(ecode3)) {
2387
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "iso9660_ifs_fuzzy_read_superblock" "', argument " "3"" of type '" "unsigned int""'");
2645
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","iso9660_ifs_fuzzy_read_superblock", 3, argv[2] ));
2388
2646
  }
2389
2647
  arg3 = (unsigned int)(val3);
2390
2648
  result = (bool)iso9660_ifs_fuzzy_read_superblock(arg1,arg2,arg3);
@@ -2395,6 +2653,17 @@ fail:
2395
2653
  }
2396
2654
 
2397
2655
 
2656
+
2657
+ /*
2658
+ Document-method: Rubyiso9660.close
2659
+
2660
+ call-seq:
2661
+ close(p_iso) -> bool
2662
+
2663
+ Close previously opened ISO 9660 image.
2664
+ True is unconditionally returned. If there was an error false would
2665
+ be returned..
2666
+ */
2398
2667
  SWIGINTERN VALUE
2399
2668
  _wrap_close(int argc, VALUE *argv, VALUE self) {
2400
2669
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -2408,7 +2677,7 @@ _wrap_close(int argc, VALUE *argv, VALUE self) {
2408
2677
  }
2409
2678
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
2410
2679
  if (!SWIG_IsOK(res1)) {
2411
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_close" "', argument " "1"" of type '" "iso9660_t *""'");
2680
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","iso9660_close", 1, argv[0] ));
2412
2681
  }
2413
2682
  arg1 = (iso9660_t *)(argp1);
2414
2683
  result = (bool)iso9660_close(arg1);
@@ -2419,8 +2688,41 @@ fail:
2419
2688
  }
2420
2689
 
2421
2690
 
2691
+
2692
+ /*
2693
+ Document-class: Rubyiso9660::Buf_tuple_t
2694
+
2695
+ call-seq:
2696
+
2697
+
2698
+ Close previously opened ISO 9660 image.
2699
+ True is unconditionally returned. If there was an error false would
2700
+ be returned..
2701
+ */
2422
2702
  swig_class cBuf_tuple_t;
2423
2703
 
2704
+
2705
+ /*
2706
+ Document-method: Rubyiso9660::Buf_tuple_t.data
2707
+
2708
+ call-seq:
2709
+ data -> char
2710
+
2711
+ Close previously opened ISO 9660 image.
2712
+ True is unconditionally returned. If there was an error false would
2713
+ be returned..
2714
+ */
2715
+
2716
+ /*
2717
+ Document-method: Rubyiso9660::Buf_tuple_t.data=
2718
+
2719
+ call-seq:
2720
+ data=(x) -> char
2721
+
2722
+ Close previously opened ISO 9660 image.
2723
+ True is unconditionally returned. If there was an error false would
2724
+ be returned..
2725
+ */
2424
2726
  SWIGINTERN VALUE
2425
2727
  _wrap_Buf_tuple_t_data_set(int argc, VALUE *argv, VALUE self) {
2426
2728
  Buf_tuple_t *arg1 = (Buf_tuple_t *) 0 ;
@@ -2436,12 +2738,12 @@ _wrap_Buf_tuple_t_data_set(int argc, VALUE *argv, VALUE self) {
2436
2738
  }
2437
2739
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Buf_tuple_t, 0 | 0 );
2438
2740
  if (!SWIG_IsOK(res1)) {
2439
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "data" "', argument " "1"" of type '" "Buf_tuple_t *""'");
2741
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Buf_tuple_t *","data", 1, self ));
2440
2742
  }
2441
2743
  arg1 = (Buf_tuple_t *)(argp1);
2442
2744
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2443
2745
  if (!SWIG_IsOK(res2)) {
2444
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "data" "', argument " "2"" of type '" "char *""'");
2746
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","data", 2, argv[0] ));
2445
2747
  }
2446
2748
  arg2 = (char *)(buf2);
2447
2749
  if (arg1->data) free((char*)arg1->data);
@@ -2472,7 +2774,7 @@ _wrap_Buf_tuple_t_data_get(int argc, VALUE *argv, VALUE self) {
2472
2774
  }
2473
2775
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Buf_tuple_t, 0 | 0 );
2474
2776
  if (!SWIG_IsOK(res1)) {
2475
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "data" "', argument " "1"" of type '" "Buf_tuple_t *""'");
2777
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Buf_tuple_t *","data", 1, self ));
2476
2778
  }
2477
2779
  arg1 = (Buf_tuple_t *)(argp1);
2478
2780
  result = (char *) ((arg1)->data);
@@ -2483,6 +2785,28 @@ fail:
2483
2785
  }
2484
2786
 
2485
2787
 
2788
+
2789
+ /*
2790
+ Document-method: Rubyiso9660::Buf_tuple_t.i_size
2791
+
2792
+ call-seq:
2793
+ i_size -> size_t
2794
+
2795
+ Close previously opened ISO 9660 image.
2796
+ True is unconditionally returned. If there was an error false would
2797
+ be returned..
2798
+ */
2799
+
2800
+ /*
2801
+ Document-method: Rubyiso9660::Buf_tuple_t.i_size=
2802
+
2803
+ call-seq:
2804
+ i_size=(x) -> size_t
2805
+
2806
+ Close previously opened ISO 9660 image.
2807
+ True is unconditionally returned. If there was an error false would
2808
+ be returned..
2809
+ */
2486
2810
  SWIGINTERN VALUE
2487
2811
  _wrap_Buf_tuple_t_i_size_set(int argc, VALUE *argv, VALUE self) {
2488
2812
  Buf_tuple_t *arg1 = (Buf_tuple_t *) 0 ;
@@ -2497,12 +2821,12 @@ _wrap_Buf_tuple_t_i_size_set(int argc, VALUE *argv, VALUE self) {
2497
2821
  }
2498
2822
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Buf_tuple_t, 0 | 0 );
2499
2823
  if (!SWIG_IsOK(res1)) {
2500
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "i_size" "', argument " "1"" of type '" "Buf_tuple_t *""'");
2824
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Buf_tuple_t *","i_size", 1, self ));
2501
2825
  }
2502
2826
  arg1 = (Buf_tuple_t *)(argp1);
2503
2827
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
2504
2828
  if (!SWIG_IsOK(ecode2)) {
2505
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "i_size" "', argument " "2"" of type '" "size_t""'");
2829
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","i_size", 2, argv[0] ));
2506
2830
  }
2507
2831
  arg2 = (size_t)(val2);
2508
2832
  if (arg1) (arg1)->i_size = arg2;
@@ -2526,7 +2850,7 @@ _wrap_Buf_tuple_t_i_size_get(int argc, VALUE *argv, VALUE self) {
2526
2850
  }
2527
2851
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Buf_tuple_t, 0 | 0 );
2528
2852
  if (!SWIG_IsOK(res1)) {
2529
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "i_size" "', argument " "1"" of type '" "Buf_tuple_t *""'");
2853
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Buf_tuple_t *","i_size", 1, self ));
2530
2854
  }
2531
2855
  arg1 = (Buf_tuple_t *)(argp1);
2532
2856
  result = ((arg1)->i_size);
@@ -2554,6 +2878,15 @@ _wrap_Buf_tuple_t_allocate(VALUE self) {
2554
2878
  }
2555
2879
 
2556
2880
 
2881
+
2882
+ /*
2883
+ Document-method: Rubyiso9660::Buf_tuple_t.new
2884
+
2885
+ call-seq:
2886
+
2887
+
2888
+ Return true if ISO 9660 image has extended attrributes (XA)..
2889
+ */
2557
2890
  SWIGINTERN VALUE
2558
2891
  _wrap_new_Buf_tuple_t(int argc, VALUE *argv, VALUE self) {
2559
2892
  Buf_tuple_t *result = 0 ;
@@ -2574,6 +2907,16 @@ free_Buf_tuple_t(Buf_tuple_t *arg1) {
2574
2907
  free((char *) arg1);
2575
2908
  }
2576
2909
 
2910
+
2911
+ /*
2912
+ Document-method: Rubyiso9660.seek_read
2913
+
2914
+ call-seq:
2915
+ seek_read(p_iso, start, i_size) -> Buf_tuple_t
2916
+
2917
+ Seek to a position and then read n bytes. (buffer, size) are
2918
+ returned..
2919
+ */
2577
2920
  SWIGINTERN VALUE
2578
2921
  _wrap_seek_read(int argc, VALUE *argv, VALUE self) {
2579
2922
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -2593,17 +2936,17 @@ _wrap_seek_read(int argc, VALUE *argv, VALUE self) {
2593
2936
  }
2594
2937
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
2595
2938
  if (!SWIG_IsOK(res1)) {
2596
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "seek_read" "', argument " "1"" of type '" "iso9660_t const *""'");
2939
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t const *","seek_read", 1, argv[0] ));
2597
2940
  }
2598
2941
  arg1 = (iso9660_t *)(argp1);
2599
2942
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
2600
2943
  if (!SWIG_IsOK(ecode2)) {
2601
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "seek_read" "', argument " "2"" of type '" "lsn_t""'");
2944
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "lsn_t","seek_read", 2, argv[1] ));
2602
2945
  }
2603
2946
  arg2 = (lsn_t)(val2);
2604
2947
  ecode3 = SWIG_AsVal_long(argv[2], &val3);
2605
2948
  if (!SWIG_IsOK(ecode3)) {
2606
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "seek_read" "', argument " "3"" of type '" "ssize_t""'");
2949
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "ssize_t","seek_read", 3, argv[2] ));
2607
2950
  }
2608
2951
  arg3 = (ssize_t)(val3);
2609
2952
  result = seek_read((iso9660_t const *)arg1,arg2,arg3);
@@ -2624,6 +2967,16 @@ fail:
2624
2967
  }
2625
2968
 
2626
2969
 
2970
+
2971
+ /*
2972
+ Document-method: Rubyiso9660.fs_read_pvd
2973
+
2974
+ call-seq:
2975
+ fs_read_pvd(p_cdio) -> iso9660_pvd_t
2976
+
2977
+ Read the Primary Volume Descriptor for a CD.
2978
+ None is returned if there was an error..
2979
+ */
2627
2980
  SWIGINTERN VALUE
2628
2981
  _wrap_fs_read_pvd(int argc, VALUE *argv, VALUE self) {
2629
2982
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2637,7 +2990,7 @@ _wrap_fs_read_pvd(int argc, VALUE *argv, VALUE self) {
2637
2990
  }
2638
2991
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2639
2992
  if (!SWIG_IsOK(res1)) {
2640
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_read_pvd" "', argument " "1"" of type '" "CdIo_t const *""'");
2993
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","fs_read_pvd", 1, argv[0] ));
2641
2994
  }
2642
2995
  arg1 = (CdIo_t *)(argp1);
2643
2996
  result = (iso9660_pvd_t *)fs_read_pvd((CdIo_t const *)arg1);
@@ -2648,6 +3001,16 @@ fail:
2648
3001
  }
2649
3002
 
2650
3003
 
3004
+
3005
+ /*
3006
+ Document-method: Rubyiso9660.ifs_read_pvd
3007
+
3008
+ call-seq:
3009
+ ifs_read_pvd(p_iso) -> iso9660_pvd_t
3010
+
3011
+ Read the Primary Volume Descriptor for an ISO 9660 image.
3012
+ None is returned if there was an error..
3013
+ */
2651
3014
  SWIGINTERN VALUE
2652
3015
  _wrap_ifs_read_pvd(int argc, VALUE *argv, VALUE self) {
2653
3016
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -2661,7 +3024,7 @@ _wrap_ifs_read_pvd(int argc, VALUE *argv, VALUE self) {
2661
3024
  }
2662
3025
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
2663
3026
  if (!SWIG_IsOK(res1)) {
2664
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ifs_read_pvd" "', argument " "1"" of type '" "iso9660_t const *""'");
3027
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t const *","ifs_read_pvd", 1, argv[0] ));
2665
3028
  }
2666
3029
  arg1 = (iso9660_t *)(argp1);
2667
3030
  result = (iso9660_pvd_t *)ifs_read_pvd((iso9660_t const *)arg1);
@@ -2672,6 +3035,17 @@ fail:
2672
3035
  }
2673
3036
 
2674
3037
 
3038
+
3039
+ /*
3040
+ Document-method: Rubyiso9660.fs_read_superblock
3041
+
3042
+ call-seq:
3043
+ fs_read_superblock(p_cdio, iso_extension_mask) -> bool
3044
+
3045
+ Read the Super block of an ISO 9660 image. This is the
3046
+ Primary Volume Descriptor (PVD) and perhaps a Supplemental Volume
3047
+ Descriptor if (Joliet) extensions are acceptable..
3048
+ */
2675
3049
  SWIGINTERN VALUE
2676
3050
  _wrap_fs_read_superblock(int argc, VALUE *argv, VALUE self) {
2677
3051
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2688,12 +3062,12 @@ _wrap_fs_read_superblock(int argc, VALUE *argv, VALUE self) {
2688
3062
  }
2689
3063
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2690
3064
  if (!SWIG_IsOK(res1)) {
2691
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_fs_read_superblock" "', argument " "1"" of type '" "CdIo_t *""'");
3065
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","iso9660_fs_read_superblock", 1, argv[0] ));
2692
3066
  }
2693
3067
  arg1 = (CdIo_t *)(argp1);
2694
3068
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
2695
3069
  if (!SWIG_IsOK(ecode2)) {
2696
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "iso9660_fs_read_superblock" "', argument " "2"" of type '" "iso_extension_mask_t""'");
3070
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "iso_extension_mask_t","iso9660_fs_read_superblock", 2, argv[1] ));
2697
3071
  }
2698
3072
  arg2 = (iso_extension_mask_t)(val2);
2699
3073
  result = (bool)iso9660_fs_read_superblock(arg1,arg2);
@@ -2704,6 +3078,17 @@ fail:
2704
3078
  }
2705
3079
 
2706
3080
 
3081
+
3082
+ /*
3083
+ Document-method: Rubyiso9660.ifs_read_superblock
3084
+
3085
+ call-seq:
3086
+ ifs_read_superblock(p_iso, iso_extension_mask) -> bool
3087
+
3088
+ Read the Super block of an ISO 9660 image. This is the
3089
+ Primary Volume Descriptor (PVD) and perhaps a Supplemental Volume
3090
+ Descriptor if (Joliet) extensions are acceptable..
3091
+ */
2707
3092
  SWIGINTERN VALUE
2708
3093
  _wrap_ifs_read_superblock(int argc, VALUE *argv, VALUE self) {
2709
3094
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -2720,12 +3105,12 @@ _wrap_ifs_read_superblock(int argc, VALUE *argv, VALUE self) {
2720
3105
  }
2721
3106
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
2722
3107
  if (!SWIG_IsOK(res1)) {
2723
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_ifs_read_superblock" "', argument " "1"" of type '" "iso9660_t *""'");
3108
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","iso9660_ifs_read_superblock", 1, argv[0] ));
2724
3109
  }
2725
3110
  arg1 = (iso9660_t *)(argp1);
2726
3111
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
2727
3112
  if (!SWIG_IsOK(ecode2)) {
2728
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "iso9660_ifs_read_superblock" "', argument " "2"" of type '" "iso_extension_mask_t""'");
3113
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "iso_extension_mask_t","iso9660_ifs_read_superblock", 2, argv[1] ));
2729
3114
  }
2730
3115
  arg2 = (iso_extension_mask_t)(val2);
2731
3116
  result = (bool)iso9660_ifs_read_superblock(arg1,arg2);
@@ -2736,6 +3121,15 @@ fail:
2736
3121
  }
2737
3122
 
2738
3123
 
3124
+
3125
+ /*
3126
+ Document-method: Rubyiso9660.set_dtime
3127
+
3128
+ call-seq:
3129
+ set_dtime(year, mon, mday, hour, min, sec) -> iso9660_dtime_t
3130
+
3131
+ Set time in format used in ISO 9660 directory index record.
3132
+ */
2739
3133
  SWIGINTERN VALUE
2740
3134
  _wrap_set_dtime(int argc, VALUE *argv, VALUE self) {
2741
3135
  int arg1 ;
@@ -2764,32 +3158,32 @@ _wrap_set_dtime(int argc, VALUE *argv, VALUE self) {
2764
3158
  }
2765
3159
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
2766
3160
  if (!SWIG_IsOK(ecode1)) {
2767
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_dtime" "', argument " "1"" of type '" "int""'");
3161
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","set_dtime", 1, argv[0] ));
2768
3162
  }
2769
3163
  arg1 = (int)(val1);
2770
3164
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
2771
3165
  if (!SWIG_IsOK(ecode2)) {
2772
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set_dtime" "', argument " "2"" of type '" "int""'");
3166
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set_dtime", 2, argv[1] ));
2773
3167
  }
2774
3168
  arg2 = (int)(val2);
2775
3169
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
2776
3170
  if (!SWIG_IsOK(ecode3)) {
2777
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "set_dtime" "', argument " "3"" of type '" "int""'");
3171
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","set_dtime", 3, argv[2] ));
2778
3172
  }
2779
3173
  arg3 = (int)(val3);
2780
3174
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
2781
3175
  if (!SWIG_IsOK(ecode4)) {
2782
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "set_dtime" "', argument " "4"" of type '" "int""'");
3176
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","set_dtime", 4, argv[3] ));
2783
3177
  }
2784
3178
  arg4 = (int)(val4);
2785
3179
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
2786
3180
  if (!SWIG_IsOK(ecode5)) {
2787
- SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "set_dtime" "', argument " "5"" of type '" "int""'");
3181
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","set_dtime", 5, argv[4] ));
2788
3182
  }
2789
3183
  arg5 = (int)(val5);
2790
3184
  ecode6 = SWIG_AsVal_int(argv[5], &val6);
2791
3185
  if (!SWIG_IsOK(ecode6)) {
2792
- SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "set_dtime" "', argument " "6"" of type '" "int""'");
3186
+ SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "int","set_dtime", 6, argv[5] ));
2793
3187
  }
2794
3188
  arg6 = (int)(val6);
2795
3189
  result = (iso9660_dtime_t *)set_dtime(arg1,arg2,arg3,arg4,arg5,arg6);
@@ -2800,6 +3194,15 @@ fail:
2800
3194
  }
2801
3195
 
2802
3196
 
3197
+
3198
+ /*
3199
+ Document-method: Rubyiso9660.set_ltime
3200
+
3201
+ call-seq:
3202
+ set_ltime(year, mon, mday, hour, min, sec) -> iso9660_ltime_t
3203
+
3204
+ Set 'long' time in format used in ISO 9660 primary volume descriptor.
3205
+ */
2803
3206
  SWIGINTERN VALUE
2804
3207
  _wrap_set_ltime(int argc, VALUE *argv, VALUE self) {
2805
3208
  int arg1 ;
@@ -2828,32 +3231,32 @@ _wrap_set_ltime(int argc, VALUE *argv, VALUE self) {
2828
3231
  }
2829
3232
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
2830
3233
  if (!SWIG_IsOK(ecode1)) {
2831
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_ltime" "', argument " "1"" of type '" "int""'");
3234
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","set_ltime", 1, argv[0] ));
2832
3235
  }
2833
3236
  arg1 = (int)(val1);
2834
3237
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
2835
3238
  if (!SWIG_IsOK(ecode2)) {
2836
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set_ltime" "', argument " "2"" of type '" "int""'");
3239
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set_ltime", 2, argv[1] ));
2837
3240
  }
2838
3241
  arg2 = (int)(val2);
2839
3242
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
2840
3243
  if (!SWIG_IsOK(ecode3)) {
2841
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "set_ltime" "', argument " "3"" of type '" "int""'");
3244
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","set_ltime", 3, argv[2] ));
2842
3245
  }
2843
3246
  arg3 = (int)(val3);
2844
3247
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
2845
3248
  if (!SWIG_IsOK(ecode4)) {
2846
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "set_ltime" "', argument " "4"" of type '" "int""'");
3249
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","set_ltime", 4, argv[3] ));
2847
3250
  }
2848
3251
  arg4 = (int)(val4);
2849
3252
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
2850
3253
  if (!SWIG_IsOK(ecode5)) {
2851
- SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "set_ltime" "', argument " "5"" of type '" "int""'");
3254
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","set_ltime", 5, argv[4] ));
2852
3255
  }
2853
3256
  arg5 = (int)(val5);
2854
3257
  ecode6 = SWIG_AsVal_int(argv[5], &val6);
2855
3258
  if (!SWIG_IsOK(ecode6)) {
2856
- SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "set_ltime" "', argument " "6"" of type '" "int""'");
3259
+ SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "int","set_ltime", 6, argv[5] ));
2857
3260
  }
2858
3261
  arg6 = (int)(val6);
2859
3262
  result = (iso9660_ltime_t *)set_ltime(arg1,arg2,arg3,arg4,arg5,arg6);
@@ -2864,6 +3267,20 @@ fail:
2864
3267
  }
2865
3268
 
2866
3269
 
3270
+
3271
+ /*
3272
+ Document-method: Rubyiso9660.get_dtime
3273
+
3274
+ call-seq:
3275
+ get_dtime(p_dtime, use_localtime) -> struct tm
3276
+
3277
+ Get Unix time structure from format use in an ISO 9660 directory index
3278
+ record. Even though tm_wday and tm_yday fields are not explicitly in
3279
+ idr_date, they are calculated from the other fields.
3280
+
3281
+ If tm is to reflect the localtime, set 'use_localtime' true, otherwise
3282
+ tm will reported in GMT..
3283
+ */
2867
3284
  SWIGINTERN VALUE
2868
3285
  _wrap_get_dtime(int argc, VALUE *argv, VALUE self) {
2869
3286
  iso9660_dtime_t *arg1 = (iso9660_dtime_t *) 0 ;
@@ -2880,12 +3297,12 @@ _wrap_get_dtime(int argc, VALUE *argv, VALUE self) {
2880
3297
  }
2881
3298
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_dtime_t, 0 | 0 );
2882
3299
  if (!SWIG_IsOK(res1)) {
2883
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_dtime" "', argument " "1"" of type '" "iso9660_dtime_t const *""'");
3300
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_dtime_t const *","get_dtime", 1, argv[0] ));
2884
3301
  }
2885
3302
  arg1 = (iso9660_dtime_t *)(argp1);
2886
3303
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
2887
3304
  if (!SWIG_IsOK(ecode2)) {
2888
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_dtime" "', argument " "2"" of type '" "bool""'");
3305
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","get_dtime", 2, argv[1] ));
2889
3306
  }
2890
3307
  arg2 = (bool)(val2);
2891
3308
  result = (struct tm *)get_dtime((iso9660_dtime_t const *)arg1,arg2);
@@ -2920,6 +3337,16 @@ fail:
2920
3337
  }
2921
3338
 
2922
3339
 
3340
+
3341
+ /*
3342
+ Document-method: Rubyiso9660.get_ltime
3343
+
3344
+ call-seq:
3345
+ get_ltime(p_ltime) -> struct tm
3346
+
3347
+ Get 'long' time in format used in ISO 9660 primary volume descriptor
3348
+ from a Unix time structure..
3349
+ */
2923
3350
  SWIGINTERN VALUE
2924
3351
  _wrap_get_ltime(int argc, VALUE *argv, VALUE self) {
2925
3352
  iso9660_ltime_t *arg1 = (iso9660_ltime_t *) 0 ;
@@ -2933,7 +3360,7 @@ _wrap_get_ltime(int argc, VALUE *argv, VALUE self) {
2933
3360
  }
2934
3361
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_ltime_t, 0 | 0 );
2935
3362
  if (!SWIG_IsOK(res1)) {
2936
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_ltime" "', argument " "1"" of type '" "iso9660_ltime_t const *""'");
3363
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_ltime_t const *","get_ltime", 1, argv[0] ));
2937
3364
  }
2938
3365
  arg1 = (iso9660_ltime_t *)(argp1);
2939
3366
  result = (struct tm *)get_ltime((iso9660_ltime_t const *)arg1);
@@ -2968,6 +3395,17 @@ fail:
2968
3395
  }
2969
3396
 
2970
3397
 
3398
+
3399
+ /*
3400
+ Document-method: Rubyiso9660.dchar?
3401
+
3402
+ call-seq:
3403
+ dchar?(c) -> bool
3404
+
3405
+ Return true if c is a DCHAR - a character that can appear in an an
3406
+ ISO-9600 level 1 directory name. These are the ASCII capital
3407
+ letters A-Z, the digits 0-9 and an underscore..
3408
+ */
2971
3409
  SWIGINTERN VALUE
2972
3410
  _wrap_dcharq___(int argc, VALUE *argv, VALUE self) {
2973
3411
  int arg1 ;
@@ -2981,7 +3419,7 @@ _wrap_dcharq___(int argc, VALUE *argv, VALUE self) {
2981
3419
  }
2982
3420
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
2983
3421
  if (!SWIG_IsOK(ecode1)) {
2984
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "iso9660_isdchar" "', argument " "1"" of type '" "int""'");
3422
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","iso9660_isdchar", 1, argv[0] ));
2985
3423
  }
2986
3424
  arg1 = (int)(val1);
2987
3425
  result = (bool)iso9660_isdchar(arg1);
@@ -2992,6 +3430,17 @@ fail:
2992
3430
  }
2993
3431
 
2994
3432
 
3433
+
3434
+ /*
3435
+ Document-method: Rubyiso9660.achar?
3436
+
3437
+ call-seq:
3438
+ achar?(c) -> bool
3439
+
3440
+ Return true if c is an ACHAR -
3441
+ These are the DCHAR's plus some ASCII symbols including the space
3442
+ symbol..
3443
+ */
2995
3444
  SWIGINTERN VALUE
2996
3445
  _wrap_acharq___(int argc, VALUE *argv, VALUE self) {
2997
3446
  int arg1 ;
@@ -3005,7 +3454,7 @@ _wrap_acharq___(int argc, VALUE *argv, VALUE self) {
3005
3454
  }
3006
3455
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
3007
3456
  if (!SWIG_IsOK(ecode1)) {
3008
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "iso9660_isachar" "', argument " "1"" of type '" "int""'");
3457
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","iso9660_isachar", 1, argv[0] ));
3009
3458
  }
3010
3459
  arg1 = (int)(val1);
3011
3460
  result = (bool)iso9660_isachar(arg1);
@@ -3016,6 +3465,23 @@ fail:
3016
3465
  }
3017
3466
 
3018
3467
 
3468
+
3469
+ /*
3470
+ Document-method: Rubyiso9660.name_translate
3471
+
3472
+ call-seq:
3473
+ name_translate(psz_oldname) -> char
3474
+
3475
+ Convert an ISO-9660 file name that stored in a directory entry into
3476
+ what's usually listed as the file name in a listing.
3477
+ Lowercase name, and remove trailing ;1's or .;1's and
3478
+ turn the other ;'s into version numbers.
3479
+
3480
+ @param psz_oldname the ISO-9660 filename to be translated.
3481
+ @param psz_newname returned string. The caller allocates this and
3482
+ it should be at least the size of psz_oldname.
3483
+ @return length of the translated string is returned..
3484
+ */
3019
3485
  SWIGINTERN VALUE
3020
3486
  _wrap_name_translate(int argc, VALUE *argv, VALUE self) {
3021
3487
  char *arg1 = (char *) 0 ;
@@ -3030,7 +3496,7 @@ _wrap_name_translate(int argc, VALUE *argv, VALUE self) {
3030
3496
  }
3031
3497
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
3032
3498
  if (!SWIG_IsOK(res1)) {
3033
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "name_translate" "', argument " "1"" of type '" "char const *""'");
3499
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","name_translate", 1, argv[0] ));
3034
3500
  }
3035
3501
  arg1 = (char *)(buf1);
3036
3502
  result = (char *)name_translate((char const *)arg1);
@@ -3044,6 +3510,26 @@ fail:
3044
3510
  }
3045
3511
 
3046
3512
 
3513
+
3514
+ /*
3515
+ Document-method: Rubyiso9660.name_translate_ext
3516
+
3517
+ call-seq:
3518
+ name_translate_ext(psz_oldname, i_joliet_level) -> char
3519
+
3520
+ Convert an ISO-9660 file name that stored in a directory entry into
3521
+ what's usually listed as the file name in a listing. Lowercase
3522
+ name if no Joliet Extension interpretation. Remove trailing ;1's or
3523
+ .;1's and turn the other ;'s into version numbers.
3524
+
3525
+ @param psz_oldname the ISO-9660 filename to be translated.
3526
+ @param psz_newname returned string. The caller allocates this and
3527
+ it should be at least the size of psz_oldname.
3528
+ @param i_joliet_level 0 if not using Joliet Extension. Otherwise the
3529
+ Joliet level.
3530
+ @return length of the translated string is returned. It will be no greater
3531
+ than the length of psz_oldname..
3532
+ */
3047
3533
  SWIGINTERN VALUE
3048
3534
  _wrap_name_translate_ext(int argc, VALUE *argv, VALUE self) {
3049
3535
  char *arg1 = (char *) 0 ;
@@ -3061,12 +3547,12 @@ _wrap_name_translate_ext(int argc, VALUE *argv, VALUE self) {
3061
3547
  }
3062
3548
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
3063
3549
  if (!SWIG_IsOK(res1)) {
3064
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "name_translate_ext" "', argument " "1"" of type '" "char const *""'");
3550
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","name_translate_ext", 1, argv[0] ));
3065
3551
  }
3066
3552
  arg1 = (char *)(buf1);
3067
3553
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[1], &val2);
3068
3554
  if (!SWIG_IsOK(ecode2)) {
3069
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "name_translate_ext" "', argument " "2"" of type '" "unsigned char""'");
3555
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","name_translate_ext", 2, argv[1] ));
3070
3556
  }
3071
3557
  arg2 = (unsigned char)(val2);
3072
3558
  result = (char *)name_translate_ext((char const *)arg1,arg2);
@@ -3080,6 +3566,23 @@ fail:
3080
3566
  }
3081
3567
 
3082
3568
 
3569
+
3570
+ /*
3571
+ Document-method: Rubyiso9660.strncpy_pad
3572
+
3573
+ call-seq:
3574
+ strncpy_pad(src, len, _check) -> char
3575
+
3576
+ Pad string src with spaces to size len and copy this to dst. If
3577
+ en is less than the length of src, dst will be truncated to the
3578
+ first len characters of src.
3579
+
3580
+ src can also be scanned to see if it contains only ACHARs, DCHARs,
3581
+ 7-bit ASCII chars depending on the enumeration _check.
3582
+
3583
+ In addition to getting changed, dst is the return value.
3584
+ Note: this string might not be NULL terminated..
3585
+ */
3083
3586
  SWIGINTERN VALUE
3084
3587
  _wrap_strncpy_pad(int argc, VALUE *argv, VALUE self) {
3085
3588
  char *arg1 ;
@@ -3100,17 +3603,17 @@ _wrap_strncpy_pad(int argc, VALUE *argv, VALUE self) {
3100
3603
  }
3101
3604
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
3102
3605
  if (!SWIG_IsOK(res1)) {
3103
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "strncpy_pad" "', argument " "1"" of type '" "char const []""'");
3606
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const []","strncpy_pad", 1, argv[0] ));
3104
3607
  }
3105
3608
  arg1 = (char *)(buf1);
3106
3609
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
3107
3610
  if (!SWIG_IsOK(ecode2)) {
3108
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "strncpy_pad" "', argument " "2"" of type '" "size_t""'");
3611
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","strncpy_pad", 2, argv[1] ));
3109
3612
  }
3110
3613
  arg2 = (size_t)(val2);
3111
3614
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
3112
3615
  if (!SWIG_IsOK(ecode3)) {
3113
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "strncpy_pad" "', argument " "3"" of type '" "enum strncpy_pad_check""'");
3616
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "enum strncpy_pad_check","strncpy_pad", 3, argv[2] ));
3114
3617
  }
3115
3618
  arg3 = (enum strncpy_pad_check)(val3);
3116
3619
  result = (char *)strncpy_pad((char const (*))arg1,arg2,arg3);
@@ -3124,6 +3627,22 @@ fail:
3124
3627
  }
3125
3628
 
3126
3629
 
3630
+
3631
+ /*
3632
+ Document-method: Rubyiso9660.dirname_valid?
3633
+
3634
+ call-seq:
3635
+ dirname_valid?(psz_path) -> bool
3636
+
3637
+ Check that psz_path is a valid ISO-9660 directory name.
3638
+
3639
+ A valid directory name should not start out with a slash (/),
3640
+ dot (.) or null byte, should be less than 37 characters long,
3641
+ have no more than 8 characters in a directory component
3642
+ which is separated by a /, and consist of only DCHARs.
3643
+
3644
+ True is returned if psz_path is valid..
3645
+ */
3127
3646
  SWIGINTERN VALUE
3128
3647
  _wrap_dirname_validq___(int argc, VALUE *argv, VALUE self) {
3129
3648
  char *arg1 ;
@@ -3138,7 +3657,7 @@ _wrap_dirname_validq___(int argc, VALUE *argv, VALUE self) {
3138
3657
  }
3139
3658
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
3140
3659
  if (!SWIG_IsOK(res1)) {
3141
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_dirname_valid_p" "', argument " "1"" of type '" "char const []""'");
3660
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const []","iso9660_dirname_valid_p", 1, argv[0] ));
3142
3661
  }
3143
3662
  arg1 = (char *)(buf1);
3144
3663
  result = (bool)iso9660_dirname_valid_p((char const (*))arg1);
@@ -3151,6 +3670,18 @@ fail:
3151
3670
  }
3152
3671
 
3153
3672
 
3673
+
3674
+ /*
3675
+ Document-method: Rubyiso9660.pathname_isofy
3676
+
3677
+ call-seq:
3678
+ pathname_isofy(psz_path, i_version=1) -> char
3679
+
3680
+ Take psz_path and a version number and turn that into a ISO-9660
3681
+ pathname. (That's just the pathname followed by ';' and the version
3682
+ number. For example, mydir/file.ext -> MYDIR/FILE.EXT;1 for version
3683
+ 1. The resulting ISO-9660 pathname is returned..
3684
+ */
3154
3685
  SWIGINTERN VALUE
3155
3686
  _wrap_pathname_isofy(int argc, VALUE *argv, VALUE self) {
3156
3687
  char *arg1 ;
@@ -3168,13 +3699,13 @@ _wrap_pathname_isofy(int argc, VALUE *argv, VALUE self) {
3168
3699
  }
3169
3700
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
3170
3701
  if (!SWIG_IsOK(res1)) {
3171
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_pathname_isofy" "', argument " "1"" of type '" "char const []""'");
3702
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const []","iso9660_pathname_isofy", 1, argv[0] ));
3172
3703
  }
3173
3704
  arg1 = (char *)(buf1);
3174
3705
  if (argc > 1) {
3175
3706
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
3176
3707
  if (!SWIG_IsOK(ecode2)) {
3177
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "iso9660_pathname_isofy" "', argument " "2"" of type '" "unsigned int""'");
3708
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","iso9660_pathname_isofy", 2, argv[1] ));
3178
3709
  }
3179
3710
  arg2 = (unsigned int)(val2);
3180
3711
  }
@@ -3189,6 +3720,23 @@ fail:
3189
3720
  }
3190
3721
 
3191
3722
 
3723
+
3724
+ /*
3725
+ Document-method: Rubyiso9660.pathname_valid?
3726
+
3727
+ call-seq:
3728
+ pathname_valid?(psz_path) -> bool
3729
+
3730
+ Check that psz_path is a valid ISO-9660 pathname.
3731
+
3732
+ A valid pathname contains a valid directory name, if one appears and
3733
+ the filename portion should be no more than 8 characters for the
3734
+ file prefix and 3 characters in the extension (or portion after a
3735
+ dot). There should be exactly one dot somewhere in the filename
3736
+ portion and the filename should be composed of only DCHARs.
3737
+
3738
+ True is returned if psz_path is valid..
3739
+ */
3192
3740
  SWIGINTERN VALUE
3193
3741
  _wrap_pathname_validq___(int argc, VALUE *argv, VALUE self) {
3194
3742
  char *arg1 ;
@@ -3203,7 +3751,7 @@ _wrap_pathname_validq___(int argc, VALUE *argv, VALUE self) {
3203
3751
  }
3204
3752
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
3205
3753
  if (!SWIG_IsOK(res1)) {
3206
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_pathname_valid_p" "', argument " "1"" of type '" "char const []""'");
3754
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const []","iso9660_pathname_valid_p", 1, argv[0] ));
3207
3755
  }
3208
3756
  arg1 = (char *)(buf1);
3209
3757
  result = (bool)iso9660_pathname_valid_p((char const (*))arg1);
@@ -3216,6 +3764,15 @@ fail:
3216
3764
  }
3217
3765
 
3218
3766
 
3767
+
3768
+ /*
3769
+ Document-method: Rubyiso9660.fs_stat
3770
+
3771
+ call-seq:
3772
+ fs_stat(p_cdio, psz_path) -> IsoStat_t
3773
+
3774
+ Return file status for psz_path. None is returned on error..
3775
+ */
3219
3776
  SWIGINTERN VALUE
3220
3777
  _wrap_fs_stat(int argc, VALUE *argv, VALUE self) {
3221
3778
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3233,12 +3790,12 @@ _wrap_fs_stat(int argc, VALUE *argv, VALUE self) {
3233
3790
  }
3234
3791
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3235
3792
  if (!SWIG_IsOK(res1)) {
3236
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_fs_stat" "', argument " "1"" of type '" "CdIo_t *""'");
3793
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","iso9660_fs_stat", 1, argv[0] ));
3237
3794
  }
3238
3795
  arg1 = (CdIo_t *)(argp1);
3239
3796
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
3240
3797
  if (!SWIG_IsOK(res2)) {
3241
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "iso9660_fs_stat" "', argument " "2"" of type '" "char const []""'");
3798
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const []","iso9660_fs_stat", 2, argv[1] ));
3242
3799
  }
3243
3800
  arg2 = (char *)(buf2);
3244
3801
  result = (IsoStat_t *)iso9660_fs_stat(arg1,(char const (*))arg2);
@@ -3269,6 +3826,19 @@ fail:
3269
3826
  }
3270
3827
 
3271
3828
 
3829
+
3830
+ /*
3831
+ Document-method: Rubyiso9660.fs_stat_translate
3832
+
3833
+ call-seq:
3834
+ fs_stat_translate(p_cdio, psz_path, b_mode2=false) -> IsoStat_t
3835
+
3836
+ Return file status for path name psz_path. None is returned on error.
3837
+ pathname version numbers in the ISO 9660 name are dropped, i.e. ;1
3838
+ is removed and if level 1 ISO-9660 names are lowercased.
3839
+
3840
+ The b_mode2 parameter is not used..
3841
+ */
3272
3842
  SWIGINTERN VALUE
3273
3843
  _wrap_fs_stat_translate(int argc, VALUE *argv, VALUE self) {
3274
3844
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3289,18 +3859,18 @@ _wrap_fs_stat_translate(int argc, VALUE *argv, VALUE self) {
3289
3859
  }
3290
3860
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3291
3861
  if (!SWIG_IsOK(res1)) {
3292
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_fs_stat_translate" "', argument " "1"" of type '" "CdIo_t *""'");
3862
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","iso9660_fs_stat_translate", 1, argv[0] ));
3293
3863
  }
3294
3864
  arg1 = (CdIo_t *)(argp1);
3295
3865
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
3296
3866
  if (!SWIG_IsOK(res2)) {
3297
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "iso9660_fs_stat_translate" "', argument " "2"" of type '" "char const []""'");
3867
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const []","iso9660_fs_stat_translate", 2, argv[1] ));
3298
3868
  }
3299
3869
  arg2 = (char *)(buf2);
3300
3870
  if (argc > 2) {
3301
3871
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
3302
3872
  if (!SWIG_IsOK(ecode3)) {
3303
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "iso9660_fs_stat_translate" "', argument " "3"" of type '" "bool""'");
3873
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","iso9660_fs_stat_translate", 3, argv[2] ));
3304
3874
  }
3305
3875
  arg3 = (bool)(val3);
3306
3876
  }
@@ -3332,6 +3902,15 @@ fail:
3332
3902
  }
3333
3903
 
3334
3904
 
3905
+
3906
+ /*
3907
+ Document-method: Rubyiso9660.ifs_stat
3908
+
3909
+ call-seq:
3910
+ ifs_stat(p_iso, psz_path) -> IsoStat_t
3911
+
3912
+ Return file status for pathname. None is returned on error..
3913
+ */
3335
3914
  SWIGINTERN VALUE
3336
3915
  _wrap_ifs_stat(int argc, VALUE *argv, VALUE self) {
3337
3916
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -3349,12 +3928,12 @@ _wrap_ifs_stat(int argc, VALUE *argv, VALUE self) {
3349
3928
  }
3350
3929
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
3351
3930
  if (!SWIG_IsOK(res1)) {
3352
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_ifs_stat" "', argument " "1"" of type '" "iso9660_t *""'");
3931
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","iso9660_ifs_stat", 1, argv[0] ));
3353
3932
  }
3354
3933
  arg1 = (iso9660_t *)(argp1);
3355
3934
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
3356
3935
  if (!SWIG_IsOK(res2)) {
3357
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "iso9660_ifs_stat" "', argument " "2"" of type '" "char const []""'");
3936
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const []","iso9660_ifs_stat", 2, argv[1] ));
3358
3937
  }
3359
3938
  arg2 = (char *)(buf2);
3360
3939
  result = (IsoStat_t *)iso9660_ifs_stat(arg1,(char const (*))arg2);
@@ -3385,6 +3964,17 @@ fail:
3385
3964
  }
3386
3965
 
3387
3966
 
3967
+
3968
+ /*
3969
+ Document-method: Rubyiso9660.ifs_stat_translate
3970
+
3971
+ call-seq:
3972
+ ifs_stat_translate(p_iso, psz_path) -> IsoStat_t
3973
+
3974
+ Return file status for path name psz_path. undef is returned on error.
3975
+ pathname version numbers in the ISO 9660 name are dropped, i.e. ;1 is
3976
+ removed and if level 1 ISO-9660 names are lowercased..
3977
+ */
3388
3978
  SWIGINTERN VALUE
3389
3979
  _wrap_ifs_stat_translate(int argc, VALUE *argv, VALUE self) {
3390
3980
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -3402,12 +3992,12 @@ _wrap_ifs_stat_translate(int argc, VALUE *argv, VALUE self) {
3402
3992
  }
3403
3993
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
3404
3994
  if (!SWIG_IsOK(res1)) {
3405
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_ifs_stat_translate" "', argument " "1"" of type '" "iso9660_t *""'");
3995
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","iso9660_ifs_stat_translate", 1, argv[0] ));
3406
3996
  }
3407
3997
  arg1 = (iso9660_t *)(argp1);
3408
3998
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
3409
3999
  if (!SWIG_IsOK(res2)) {
3410
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "iso9660_ifs_stat_translate" "', argument " "2"" of type '" "char const []""'");
4000
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const []","iso9660_ifs_stat_translate", 2, argv[1] ));
3411
4001
  }
3412
4002
  arg2 = (char *)(buf2);
3413
4003
  result = (IsoStat_t *)iso9660_ifs_stat_translate(arg1,(char const (*))arg2);
@@ -3438,6 +4028,16 @@ fail:
3438
4028
  }
3439
4029
 
3440
4030
 
4031
+
4032
+ /*
4033
+ Document-method: Rubyiso9660.fs_readdir
4034
+
4035
+ call-seq:
4036
+ fs_readdir(p_cdio, psz_path) -> IsoStatList_t
4037
+
4038
+ Read psz_path (a directory) and return a list of iso9660_stat_t
4039
+ pointers for the files inside that directory..
4040
+ */
3441
4041
  SWIGINTERN VALUE
3442
4042
  _wrap_fs_readdir(int argc, VALUE *argv, VALUE self) {
3443
4043
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3455,12 +4055,12 @@ _wrap_fs_readdir(int argc, VALUE *argv, VALUE self) {
3455
4055
  }
3456
4056
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3457
4057
  if (!SWIG_IsOK(res1)) {
3458
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_readdir" "', argument " "1"" of type '" "CdIo_t *""'");
4058
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","fs_readdir", 1, argv[0] ));
3459
4059
  }
3460
4060
  arg1 = (CdIo_t *)(argp1);
3461
4061
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
3462
4062
  if (!SWIG_IsOK(res2)) {
3463
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_readdir" "', argument " "2"" of type '" "char const []""'");
4063
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const []","fs_readdir", 2, argv[1] ));
3464
4064
  }
3465
4065
  arg2 = (char *)(buf2);
3466
4066
  result = (IsoStatList_t *)fs_readdir(arg1,(char const (*))arg2);
@@ -3500,6 +4100,16 @@ fail:
3500
4100
  }
3501
4101
 
3502
4102
 
4103
+
4104
+ /*
4105
+ Document-method: Rubyiso9660.ifs_readdir
4106
+
4107
+ call-seq:
4108
+ ifs_readdir(p_iso, psz_path) -> IsoStatList_t
4109
+
4110
+ Read psz_path (a directory) and return a list of iso9660_stat_t
4111
+ pointers for the files inside that directory..
4112
+ */
3503
4113
  SWIGINTERN VALUE
3504
4114
  _wrap_ifs_readdir(int argc, VALUE *argv, VALUE self) {
3505
4115
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -3517,12 +4127,12 @@ _wrap_ifs_readdir(int argc, VALUE *argv, VALUE self) {
3517
4127
  }
3518
4128
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
3519
4129
  if (!SWIG_IsOK(res1)) {
3520
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ifs_readdir" "', argument " "1"" of type '" "iso9660_t *""'");
4130
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","ifs_readdir", 1, argv[0] ));
3521
4131
  }
3522
4132
  arg1 = (iso9660_t *)(argp1);
3523
4133
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
3524
4134
  if (!SWIG_IsOK(res2)) {
3525
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ifs_readdir" "', argument " "2"" of type '" "char const []""'");
4135
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const []","ifs_readdir", 2, argv[1] ));
3526
4136
  }
3527
4137
  arg2 = (char *)(buf2);
3528
4138
  result = (IsoStatList_t *)ifs_readdir(arg1,(char const (*))arg2);
@@ -3562,6 +4172,16 @@ fail:
3562
4172
  }
3563
4173
 
3564
4174
 
4175
+
4176
+ /*
4177
+ Document-method: Rubyiso9660.get_application_id
4178
+
4179
+ call-seq:
4180
+ get_application_id(p_pvd) -> char
4181
+
4182
+ Return the PVD's application ID.
4183
+ None is returned if there is some problem in getting this..
4184
+ */
3565
4185
  SWIGINTERN VALUE
3566
4186
  _wrap_get_application_id(int argc, VALUE *argv, VALUE self) {
3567
4187
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -3575,7 +4195,7 @@ _wrap_get_application_id(int argc, VALUE *argv, VALUE self) {
3575
4195
  }
3576
4196
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
3577
4197
  if (!SWIG_IsOK(res1)) {
3578
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_application_id" "', argument " "1"" of type '" "iso9660_pvd_t *""'");
4198
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t *","iso9660_get_application_id", 1, argv[0] ));
3579
4199
  }
3580
4200
  arg1 = (iso9660_pvd_t *)(argp1);
3581
4201
  result = (char *)iso9660_get_application_id(arg1);
@@ -3586,6 +4206,16 @@ fail:
3586
4206
  }
3587
4207
 
3588
4208
 
4209
+
4210
+ /*
4211
+ Document-method: Rubyiso9660.ifs_get_application_id
4212
+
4213
+ call-seq:
4214
+ ifs_get_application_id(p_iso) -> string_or_nil_t
4215
+
4216
+ Get the application ID. Return None if there
4217
+ is some problem in getting this..
4218
+ */
3589
4219
  SWIGINTERN VALUE
3590
4220
  _wrap_ifs_get_application_id(int argc, VALUE *argv, VALUE self) {
3591
4221
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -3599,7 +4229,7 @@ _wrap_ifs_get_application_id(int argc, VALUE *argv, VALUE self) {
3599
4229
  }
3600
4230
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
3601
4231
  if (!SWIG_IsOK(res1)) {
3602
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ifs_get_application_id" "', argument " "1"" of type '" "iso9660_t *""'");
4232
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","ifs_get_application_id", 1, argv[0] ));
3603
4233
  }
3604
4234
  arg1 = (iso9660_t *)(argp1);
3605
4235
  result = (string_or_nil_t)ifs_get_application_id(arg1);
@@ -3614,6 +4244,15 @@ fail:
3614
4244
  }
3615
4245
 
3616
4246
 
4247
+
4248
+ /*
4249
+ Document-method: Rubyiso9660.get_joliet_level
4250
+
4251
+ call-seq:
4252
+ get_joliet_level(p_iso) -> unsigned char
4253
+
4254
+ Return the Joliet level recognized for p_iso..
4255
+ */
3617
4256
  SWIGINTERN VALUE
3618
4257
  _wrap_get_joliet_level(int argc, VALUE *argv, VALUE self) {
3619
4258
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -3627,7 +4266,7 @@ _wrap_get_joliet_level(int argc, VALUE *argv, VALUE self) {
3627
4266
  }
3628
4267
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
3629
4268
  if (!SWIG_IsOK(res1)) {
3630
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_ifs_get_joliet_level" "', argument " "1"" of type '" "iso9660_t *""'");
4269
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","iso9660_ifs_get_joliet_level", 1, argv[0] ));
3631
4270
  }
3632
4271
  arg1 = (iso9660_t *)(argp1);
3633
4272
  result = (unsigned char)iso9660_ifs_get_joliet_level(arg1);
@@ -3638,6 +4277,15 @@ fail:
3638
4277
  }
3639
4278
 
3640
4279
 
4280
+
4281
+ /*
4282
+ Document-method: Rubyiso9660.get_dir_len
4283
+
4284
+ call-seq:
4285
+ get_dir_len(p_idr) -> unsigned char
4286
+
4287
+ Return the Joliet level recognized for p_iso..
4288
+ */
3641
4289
  SWIGINTERN VALUE
3642
4290
  _wrap_get_dir_len(int argc, VALUE *argv, VALUE self) {
3643
4291
  iso9660_dir_t *arg1 = (iso9660_dir_t *) 0 ;
@@ -3651,7 +4299,7 @@ _wrap_get_dir_len(int argc, VALUE *argv, VALUE self) {
3651
4299
  }
3652
4300
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_dir_t, 0 | 0 );
3653
4301
  if (!SWIG_IsOK(res1)) {
3654
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_dir_len" "', argument " "1"" of type '" "iso9660_dir_t const *""'");
4302
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_dir_t const *","iso9660_get_dir_len", 1, argv[0] ));
3655
4303
  }
3656
4304
  arg1 = (iso9660_dir_t *)(argp1);
3657
4305
  result = (unsigned char)iso9660_get_dir_len((iso9660_dir_t const *)arg1);
@@ -3662,6 +4310,15 @@ fail:
3662
4310
  }
3663
4311
 
3664
4312
 
4313
+
4314
+ /*
4315
+ Document-method: Rubyiso9660.iso9660_dir_to_name
4316
+
4317
+ call-seq:
4318
+ iso9660_dir_to_name(p_iso9660_dir) -> char
4319
+
4320
+ Return the directory name stored in the iso9660_dir_t..
4321
+ */
3665
4322
  SWIGINTERN VALUE
3666
4323
  _wrap_iso9660_dir_to_name(int argc, VALUE *argv, VALUE self) {
3667
4324
  iso9660_dir_t *arg1 = (iso9660_dir_t *) 0 ;
@@ -3675,7 +4332,7 @@ _wrap_iso9660_dir_to_name(int argc, VALUE *argv, VALUE self) {
3675
4332
  }
3676
4333
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_dir_t, 0 | 0 );
3677
4334
  if (!SWIG_IsOK(res1)) {
3678
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_dir_to_name" "', argument " "1"" of type '" "iso9660_dir_t const *""'");
4335
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_dir_t const *","iso9660_dir_to_name", 1, argv[0] ));
3679
4336
  }
3680
4337
  arg1 = (iso9660_dir_t *)(argp1);
3681
4338
  result = (char *)iso9660_dir_to_name((iso9660_dir_t const *)arg1);
@@ -3687,6 +4344,16 @@ fail:
3687
4344
  }
3688
4345
 
3689
4346
 
4347
+
4348
+ /*
4349
+ Document-method: Rubyiso9660.get_preparer_id
4350
+
4351
+ call-seq:
4352
+ get_preparer_id(p_pvd) -> char
4353
+
4354
+ Return a string containing the preparer id with trailing
4355
+ blanks removed..
4356
+ */
3690
4357
  SWIGINTERN VALUE
3691
4358
  _wrap_get_preparer_id(int argc, VALUE *argv, VALUE self) {
3692
4359
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -3700,7 +4367,7 @@ _wrap_get_preparer_id(int argc, VALUE *argv, VALUE self) {
3700
4367
  }
3701
4368
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
3702
4369
  if (!SWIG_IsOK(res1)) {
3703
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_preparer_id" "', argument " "1"" of type '" "iso9660_pvd_t const *""'");
4370
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t const *","iso9660_get_preparer_id", 1, argv[0] ));
3704
4371
  }
3705
4372
  arg1 = (iso9660_pvd_t *)(argp1);
3706
4373
  result = (char *)iso9660_get_preparer_id((iso9660_pvd_t const *)arg1);
@@ -3711,6 +4378,16 @@ fail:
3711
4378
  }
3712
4379
 
3713
4380
 
4381
+
4382
+ /*
4383
+ Document-method: Rubyiso9660.ifs_get_preparer_id
4384
+
4385
+ call-seq:
4386
+ ifs_get_preparer_id(p_iso) -> string_or_nil_t
4387
+
4388
+ Get the preparer ID. Return None if there is some problem in
4389
+ getting this..
4390
+ */
3714
4391
  SWIGINTERN VALUE
3715
4392
  _wrap_ifs_get_preparer_id(int argc, VALUE *argv, VALUE self) {
3716
4393
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -3724,7 +4401,7 @@ _wrap_ifs_get_preparer_id(int argc, VALUE *argv, VALUE self) {
3724
4401
  }
3725
4402
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
3726
4403
  if (!SWIG_IsOK(res1)) {
3727
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ifs_get_preparer_id" "', argument " "1"" of type '" "iso9660_t *""'");
4404
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","ifs_get_preparer_id", 1, argv[0] ));
3728
4405
  }
3729
4406
  arg1 = (iso9660_t *)(argp1);
3730
4407
  result = (string_or_nil_t)ifs_get_preparer_id(arg1);
@@ -3739,6 +4416,16 @@ fail:
3739
4416
  }
3740
4417
 
3741
4418
 
4419
+
4420
+ /*
4421
+ Document-method: Rubyiso9660.get_publisher_id
4422
+
4423
+ call-seq:
4424
+ get_publisher_id(p_pvd) -> char
4425
+
4426
+ Return a string containing the PVD's publisher id with trailing
4427
+ blanks removed..
4428
+ */
3742
4429
  SWIGINTERN VALUE
3743
4430
  _wrap_get_publisher_id(int argc, VALUE *argv, VALUE self) {
3744
4431
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -3752,7 +4439,7 @@ _wrap_get_publisher_id(int argc, VALUE *argv, VALUE self) {
3752
4439
  }
3753
4440
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
3754
4441
  if (!SWIG_IsOK(res1)) {
3755
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_publisher_id" "', argument " "1"" of type '" "iso9660_pvd_t const *""'");
4442
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t const *","iso9660_get_publisher_id", 1, argv[0] ));
3756
4443
  }
3757
4444
  arg1 = (iso9660_pvd_t *)(argp1);
3758
4445
  result = (char *)iso9660_get_publisher_id((iso9660_pvd_t const *)arg1);
@@ -3763,6 +4450,16 @@ fail:
3763
4450
  }
3764
4451
 
3765
4452
 
4453
+
4454
+ /*
4455
+ Document-method: Rubyiso9660.ifs_get_publisher_id
4456
+
4457
+ call-seq:
4458
+ ifs_get_publisher_id(p_iso) -> string_or_nil_t
4459
+
4460
+ Get the publisher ID. Return None if there
4461
+ is some problem in getting this..
4462
+ */
3766
4463
  SWIGINTERN VALUE
3767
4464
  _wrap_ifs_get_publisher_id(int argc, VALUE *argv, VALUE self) {
3768
4465
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -3776,7 +4473,7 @@ _wrap_ifs_get_publisher_id(int argc, VALUE *argv, VALUE self) {
3776
4473
  }
3777
4474
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
3778
4475
  if (!SWIG_IsOK(res1)) {
3779
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ifs_get_publisher_id" "', argument " "1"" of type '" "iso9660_t *""'");
4476
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","ifs_get_publisher_id", 1, argv[0] ));
3780
4477
  }
3781
4478
  arg1 = (iso9660_t *)(argp1);
3782
4479
  result = (string_or_nil_t)ifs_get_publisher_id(arg1);
@@ -3791,6 +4488,16 @@ fail:
3791
4488
  }
3792
4489
 
3793
4490
 
4491
+
4492
+ /*
4493
+ Document-method: Rubyiso9660.get_pvd_type
4494
+
4495
+ call-seq:
4496
+ get_pvd_type(p_pvd) -> unsigned char
4497
+
4498
+ Get the publisher ID. Return None if there
4499
+ is some problem in getting this..
4500
+ */
3794
4501
  SWIGINTERN VALUE
3795
4502
  _wrap_get_pvd_type(int argc, VALUE *argv, VALUE self) {
3796
4503
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -3804,7 +4511,7 @@ _wrap_get_pvd_type(int argc, VALUE *argv, VALUE self) {
3804
4511
  }
3805
4512
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
3806
4513
  if (!SWIG_IsOK(res1)) {
3807
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_pvd_type" "', argument " "1"" of type '" "iso9660_pvd_t const *""'");
4514
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t const *","iso9660_get_pvd_type", 1, argv[0] ));
3808
4515
  }
3809
4516
  arg1 = (iso9660_pvd_t *)(argp1);
3810
4517
  result = (unsigned char)iso9660_get_pvd_type((iso9660_pvd_t const *)arg1);
@@ -3815,6 +4522,16 @@ fail:
3815
4522
  }
3816
4523
 
3817
4524
 
4525
+
4526
+ /*
4527
+ Document-method: Rubyiso9660.get_pvd_id
4528
+
4529
+ call-seq:
4530
+ get_pvd_id(p_pvd) -> char
4531
+
4532
+ Get the publisher ID. Return None if there
4533
+ is some problem in getting this..
4534
+ */
3818
4535
  SWIGINTERN VALUE
3819
4536
  _wrap_get_pvd_id(int argc, VALUE *argv, VALUE self) {
3820
4537
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -3828,7 +4545,7 @@ _wrap_get_pvd_id(int argc, VALUE *argv, VALUE self) {
3828
4545
  }
3829
4546
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
3830
4547
  if (!SWIG_IsOK(res1)) {
3831
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_pvd_id" "', argument " "1"" of type '" "iso9660_pvd_t const *""'");
4548
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t const *","iso9660_get_pvd_id", 1, argv[0] ));
3832
4549
  }
3833
4550
  arg1 = (iso9660_pvd_t *)(argp1);
3834
4551
  result = (char *)iso9660_get_pvd_id((iso9660_pvd_t const *)arg1);
@@ -3839,6 +4556,16 @@ fail:
3839
4556
  }
3840
4557
 
3841
4558
 
4559
+
4560
+ /*
4561
+ Document-method: Rubyiso9660.get_pvd_space_size
4562
+
4563
+ call-seq:
4564
+ get_pvd_space_size(p_pvd) -> int
4565
+
4566
+ Get the publisher ID. Return None if there
4567
+ is some problem in getting this..
4568
+ */
3842
4569
  SWIGINTERN VALUE
3843
4570
  _wrap_get_pvd_space_size(int argc, VALUE *argv, VALUE self) {
3844
4571
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -3852,7 +4579,7 @@ _wrap_get_pvd_space_size(int argc, VALUE *argv, VALUE self) {
3852
4579
  }
3853
4580
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
3854
4581
  if (!SWIG_IsOK(res1)) {
3855
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_pvd_space_size" "', argument " "1"" of type '" "iso9660_pvd_t const *""'");
4582
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t const *","iso9660_get_pvd_space_size", 1, argv[0] ));
3856
4583
  }
3857
4584
  arg1 = (iso9660_pvd_t *)(argp1);
3858
4585
  result = (int)iso9660_get_pvd_space_size((iso9660_pvd_t const *)arg1);
@@ -3863,6 +4590,16 @@ fail:
3863
4590
  }
3864
4591
 
3865
4592
 
4593
+
4594
+ /*
4595
+ Document-method: Rubyiso9660.get_pvd_block_size
4596
+
4597
+ call-seq:
4598
+ get_pvd_block_size(p_pvd) -> int
4599
+
4600
+ Get the publisher ID. Return None if there
4601
+ is some problem in getting this..
4602
+ */
3866
4603
  SWIGINTERN VALUE
3867
4604
  _wrap_get_pvd_block_size(int argc, VALUE *argv, VALUE self) {
3868
4605
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -3876,7 +4613,7 @@ _wrap_get_pvd_block_size(int argc, VALUE *argv, VALUE self) {
3876
4613
  }
3877
4614
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
3878
4615
  if (!SWIG_IsOK(res1)) {
3879
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_pvd_block_size" "', argument " "1"" of type '" "iso9660_pvd_t const *""'");
4616
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t const *","iso9660_get_pvd_block_size", 1, argv[0] ));
3880
4617
  }
3881
4618
  arg1 = (iso9660_pvd_t *)(argp1);
3882
4619
  result = (int)iso9660_get_pvd_block_size((iso9660_pvd_t const *)arg1);
@@ -3887,6 +4624,16 @@ fail:
3887
4624
  }
3888
4625
 
3889
4626
 
4627
+
4628
+ /*
4629
+ Document-method: Rubyiso9660.get_pvd_version
4630
+
4631
+ call-seq:
4632
+ get_pvd_version(pvd) -> int
4633
+
4634
+ Return the primary volume id version number (of pvd).
4635
+ If there is an error 0 is returned..
4636
+ */
3890
4637
  SWIGINTERN VALUE
3891
4638
  _wrap_get_pvd_version(int argc, VALUE *argv, VALUE self) {
3892
4639
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -3900,7 +4647,7 @@ _wrap_get_pvd_version(int argc, VALUE *argv, VALUE self) {
3900
4647
  }
3901
4648
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
3902
4649
  if (!SWIG_IsOK(res1)) {
3903
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_pvd_version" "', argument " "1"" of type '" "iso9660_pvd_t const *""'");
4650
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t const *","iso9660_get_pvd_version", 1, argv[0] ));
3904
4651
  }
3905
4652
  arg1 = (iso9660_pvd_t *)(argp1);
3906
4653
  result = (int)iso9660_get_pvd_version((iso9660_pvd_t const *)arg1);
@@ -3911,6 +4658,16 @@ fail:
3911
4658
  }
3912
4659
 
3913
4660
 
4661
+
4662
+ /*
4663
+ Document-method: Rubyiso9660.get_system_id
4664
+
4665
+ call-seq:
4666
+ get_system_id(p_pvd) -> char
4667
+
4668
+ Return a string containing the PVD's system id with trailing
4669
+ blanks removed..
4670
+ */
3914
4671
  SWIGINTERN VALUE
3915
4672
  _wrap_get_system_id(int argc, VALUE *argv, VALUE self) {
3916
4673
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -3924,7 +4681,7 @@ _wrap_get_system_id(int argc, VALUE *argv, VALUE self) {
3924
4681
  }
3925
4682
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
3926
4683
  if (!SWIG_IsOK(res1)) {
3927
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_system_id" "', argument " "1"" of type '" "iso9660_pvd_t const *""'");
4684
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t const *","iso9660_get_system_id", 1, argv[0] ));
3928
4685
  }
3929
4686
  arg1 = (iso9660_pvd_t *)(argp1);
3930
4687
  result = (char *)iso9660_get_system_id((iso9660_pvd_t const *)arg1);
@@ -3935,6 +4692,16 @@ fail:
3935
4692
  }
3936
4693
 
3937
4694
 
4695
+
4696
+ /*
4697
+ Document-method: Rubyiso9660.ifs_get_system_id
4698
+
4699
+ call-seq:
4700
+ ifs_get_system_id(p_iso) -> char
4701
+
4702
+ Get the system ID. None is returned if there
4703
+ is some problem in getting this..
4704
+ */
3938
4705
  SWIGINTERN VALUE
3939
4706
  _wrap_ifs_get_system_id(int argc, VALUE *argv, VALUE self) {
3940
4707
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -3948,7 +4715,7 @@ _wrap_ifs_get_system_id(int argc, VALUE *argv, VALUE self) {
3948
4715
  }
3949
4716
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
3950
4717
  if (!SWIG_IsOK(res1)) {
3951
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ifs_get_system_id" "', argument " "1"" of type '" "iso9660_t *""'");
4718
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","ifs_get_system_id", 1, argv[0] ));
3952
4719
  }
3953
4720
  arg1 = (iso9660_t *)(argp1);
3954
4721
  result = (char *)ifs_get_system_id(arg1);
@@ -3960,6 +4727,17 @@ fail:
3960
4727
  }
3961
4728
 
3962
4729
 
4730
+
4731
+ /*
4732
+ Document-method: Rubyiso9660.get_root_lsn
4733
+
4734
+ call-seq:
4735
+ get_root_lsn(p_pvd) -> lsn_t
4736
+
4737
+ Return the LSN of the root directory for pvd. If there is an error
4738
+ INVALID_LSN is returned.
4739
+ .
4740
+ */
3963
4741
  SWIGINTERN VALUE
3964
4742
  _wrap_get_root_lsn(int argc, VALUE *argv, VALUE self) {
3965
4743
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -3973,7 +4751,7 @@ _wrap_get_root_lsn(int argc, VALUE *argv, VALUE self) {
3973
4751
  }
3974
4752
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
3975
4753
  if (!SWIG_IsOK(res1)) {
3976
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_root_lsn" "', argument " "1"" of type '" "iso9660_pvd_t const *""'");
4754
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t const *","iso9660_get_root_lsn", 1, argv[0] ));
3977
4755
  }
3978
4756
  arg1 = (iso9660_pvd_t *)(argp1);
3979
4757
  result = (lsn_t)iso9660_get_root_lsn((iso9660_pvd_t const *)arg1);
@@ -3984,6 +4762,15 @@ fail:
3984
4762
  }
3985
4763
 
3986
4764
 
4765
+
4766
+ /*
4767
+ Document-method: Rubyiso9660.get_volume_id
4768
+
4769
+ call-seq:
4770
+ get_volume_id(p_pvd) -> char
4771
+
4772
+ Return the PVD's volume ID..
4773
+ */
3987
4774
  SWIGINTERN VALUE
3988
4775
  _wrap_get_volume_id(int argc, VALUE *argv, VALUE self) {
3989
4776
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -3997,7 +4784,7 @@ _wrap_get_volume_id(int argc, VALUE *argv, VALUE self) {
3997
4784
  }
3998
4785
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
3999
4786
  if (!SWIG_IsOK(res1)) {
4000
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_volume_id" "', argument " "1"" of type '" "iso9660_pvd_t const *""'");
4787
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t const *","iso9660_get_volume_id", 1, argv[0] ));
4001
4788
  }
4002
4789
  arg1 = (iso9660_pvd_t *)(argp1);
4003
4790
  result = (char *)iso9660_get_volume_id((iso9660_pvd_t const *)arg1);
@@ -4008,6 +4795,16 @@ fail:
4008
4795
  }
4009
4796
 
4010
4797
 
4798
+
4799
+ /*
4800
+ Document-method: Rubyiso9660.ifs_get_volume_id
4801
+
4802
+ call-seq:
4803
+ ifs_get_volume_id(p_iso) -> char
4804
+
4805
+ Get the system ID. None is returned if there
4806
+ is some problem in getting this..
4807
+ */
4011
4808
  SWIGINTERN VALUE
4012
4809
  _wrap_ifs_get_volume_id(int argc, VALUE *argv, VALUE self) {
4013
4810
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -4021,7 +4818,7 @@ _wrap_ifs_get_volume_id(int argc, VALUE *argv, VALUE self) {
4021
4818
  }
4022
4819
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
4023
4820
  if (!SWIG_IsOK(res1)) {
4024
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ifs_get_volume_id" "', argument " "1"" of type '" "iso9660_t *""'");
4821
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","ifs_get_volume_id", 1, argv[0] ));
4025
4822
  }
4026
4823
  arg1 = (iso9660_t *)(argp1);
4027
4824
  result = (char *)ifs_get_volume_id(arg1);
@@ -4033,6 +4830,17 @@ fail:
4033
4830
  }
4034
4831
 
4035
4832
 
4833
+
4834
+ /*
4835
+ Document-method: Rubyiso9660.get_volumeset_id
4836
+
4837
+ call-seq:
4838
+ get_volumeset_id(p_pvd) -> char
4839
+
4840
+ Return the PVD's volumeset ID.
4841
+ None is returned if there is some problem in getting this.
4842
+ .
4843
+ */
4036
4844
  SWIGINTERN VALUE
4037
4845
  _wrap_get_volumeset_id(int argc, VALUE *argv, VALUE self) {
4038
4846
  iso9660_pvd_t *arg1 = (iso9660_pvd_t *) 0 ;
@@ -4046,7 +4854,7 @@ _wrap_get_volumeset_id(int argc, VALUE *argv, VALUE self) {
4046
4854
  }
4047
4855
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_pvd_t, 0 | 0 );
4048
4856
  if (!SWIG_IsOK(res1)) {
4049
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_get_volumeset_id" "', argument " "1"" of type '" "iso9660_pvd_t const *""'");
4857
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_pvd_t const *","iso9660_get_volumeset_id", 1, argv[0] ));
4050
4858
  }
4051
4859
  arg1 = (iso9660_pvd_t *)(argp1);
4052
4860
  result = (char *)iso9660_get_volumeset_id((iso9660_pvd_t const *)arg1);
@@ -4057,6 +4865,16 @@ fail:
4057
4865
  }
4058
4866
 
4059
4867
 
4868
+
4869
+ /*
4870
+ Document-method: Rubyiso9660.ifs_get_volumeset_id
4871
+
4872
+ call-seq:
4873
+ ifs_get_volumeset_id(p_iso) -> string_or_nil_t
4874
+
4875
+ Get the volumeset ID. None is returned if there
4876
+ is some problem in getting this..
4877
+ */
4060
4878
  SWIGINTERN VALUE
4061
4879
  _wrap_ifs_get_volumeset_id(int argc, VALUE *argv, VALUE self) {
4062
4880
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -4070,7 +4888,7 @@ _wrap_ifs_get_volumeset_id(int argc, VALUE *argv, VALUE self) {
4070
4888
  }
4071
4889
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
4072
4890
  if (!SWIG_IsOK(res1)) {
4073
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ifs_get_volumeset_id" "', argument " "1"" of type '" "iso9660_t *""'");
4891
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t *","ifs_get_volumeset_id", 1, argv[0] ));
4074
4892
  }
4075
4893
  arg1 = (iso9660_t *)(argp1);
4076
4894
  result = (string_or_nil_t)ifs_get_volumeset_id(arg1);
@@ -4085,6 +4903,15 @@ fail:
4085
4903
  }
4086
4904
 
4087
4905
 
4906
+
4907
+ /*
4908
+ Document-method: Rubyiso9660.pathtable_init
4909
+
4910
+ call-seq:
4911
+ pathtable_init(pt)
4912
+
4913
+ Zero's out pathable. Do this first..
4914
+ */
4088
4915
  SWIGINTERN VALUE
4089
4916
  _wrap_pathtable_init(int argc, VALUE *argv, VALUE self) {
4090
4917
  void *arg1 = (void *) 0 ;
@@ -4095,7 +4922,7 @@ _wrap_pathtable_init(int argc, VALUE *argv, VALUE self) {
4095
4922
  }
4096
4923
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
4097
4924
  if (!SWIG_IsOK(res1)) {
4098
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_pathtable_init" "', argument " "1"" of type '" "void *""'");
4925
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","iso9660_pathtable_init", 1, argv[0] ));
4099
4926
  }
4100
4927
  iso9660_pathtable_init(arg1);
4101
4928
  return Qnil;
@@ -4104,6 +4931,15 @@ fail:
4104
4931
  }
4105
4932
 
4106
4933
 
4934
+
4935
+ /*
4936
+ Document-method: Rubyiso9660.pathtable_get_size
4937
+
4938
+ call-seq:
4939
+ pathtable_get_size(pt) -> unsigned int
4940
+
4941
+ Zero's out pathable. Do this first..
4942
+ */
4107
4943
  SWIGINTERN VALUE
4108
4944
  _wrap_pathtable_get_size(int argc, VALUE *argv, VALUE self) {
4109
4945
  void *arg1 = (void *) 0 ;
@@ -4116,7 +4952,7 @@ _wrap_pathtable_get_size(int argc, VALUE *argv, VALUE self) {
4116
4952
  }
4117
4953
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
4118
4954
  if (!SWIG_IsOK(res1)) {
4119
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_pathtable_get_size" "', argument " "1"" of type '" "void const *""'");
4955
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void const *","iso9660_pathtable_get_size", 1, argv[0] ));
4120
4956
  }
4121
4957
  result = (unsigned int)iso9660_pathtable_get_size((void const *)arg1);
4122
4958
  vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
@@ -4126,6 +4962,15 @@ fail:
4126
4962
  }
4127
4963
 
4128
4964
 
4965
+
4966
+ /*
4967
+ Document-method: Rubyiso9660.pathtable_l_add_entry
4968
+
4969
+ call-seq:
4970
+ pathtable_l_add_entry(pt, name, extent, parent) -> unsigned int
4971
+
4972
+ Zero's out pathable. Do this first..
4973
+ */
4129
4974
  SWIGINTERN VALUE
4130
4975
  _wrap_pathtable_l_add_entry(int argc, VALUE *argv, VALUE self) {
4131
4976
  void *arg1 = (void *) 0 ;
@@ -4148,21 +4993,21 @@ _wrap_pathtable_l_add_entry(int argc, VALUE *argv, VALUE self) {
4148
4993
  }
4149
4994
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
4150
4995
  if (!SWIG_IsOK(res1)) {
4151
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_pathtable_l_add_entry" "', argument " "1"" of type '" "void *""'");
4996
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","iso9660_pathtable_l_add_entry", 1, argv[0] ));
4152
4997
  }
4153
4998
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
4154
4999
  if (!SWIG_IsOK(res2)) {
4155
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "iso9660_pathtable_l_add_entry" "', argument " "2"" of type '" "char const []""'");
5000
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const []","iso9660_pathtable_l_add_entry", 2, argv[1] ));
4156
5001
  }
4157
5002
  arg2 = (char *)(buf2);
4158
5003
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
4159
5004
  if (!SWIG_IsOK(ecode3)) {
4160
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "iso9660_pathtable_l_add_entry" "', argument " "3"" of type '" "unsigned int""'");
5005
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","iso9660_pathtable_l_add_entry", 3, argv[2] ));
4161
5006
  }
4162
5007
  arg3 = (unsigned int)(val3);
4163
5008
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
4164
5009
  if (!SWIG_IsOK(ecode4)) {
4165
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "iso9660_pathtable_l_add_entry" "', argument " "4"" of type '" "unsigned int""'");
5010
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","iso9660_pathtable_l_add_entry", 4, argv[3] ));
4166
5011
  }
4167
5012
  arg4 = (unsigned int)(val4);
4168
5013
  result = (unsigned int)iso9660_pathtable_l_add_entry(arg1,(char const (*))arg2,arg3,arg4);
@@ -4175,6 +5020,15 @@ fail:
4175
5020
  }
4176
5021
 
4177
5022
 
5023
+
5024
+ /*
5025
+ Document-method: Rubyiso9660.pathtable_m_add_entry
5026
+
5027
+ call-seq:
5028
+ pathtable_m_add_entry(pt, name, extent, parent) -> unsigned int
5029
+
5030
+ Zero's out pathable. Do this first..
5031
+ */
4178
5032
  SWIGINTERN VALUE
4179
5033
  _wrap_pathtable_m_add_entry(int argc, VALUE *argv, VALUE self) {
4180
5034
  void *arg1 = (void *) 0 ;
@@ -4197,21 +5051,21 @@ _wrap_pathtable_m_add_entry(int argc, VALUE *argv, VALUE self) {
4197
5051
  }
4198
5052
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
4199
5053
  if (!SWIG_IsOK(res1)) {
4200
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_pathtable_m_add_entry" "', argument " "1"" of type '" "void *""'");
5054
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","iso9660_pathtable_m_add_entry", 1, argv[0] ));
4201
5055
  }
4202
5056
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
4203
5057
  if (!SWIG_IsOK(res2)) {
4204
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "iso9660_pathtable_m_add_entry" "', argument " "2"" of type '" "char const []""'");
5058
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const []","iso9660_pathtable_m_add_entry", 2, argv[1] ));
4205
5059
  }
4206
5060
  arg2 = (char *)(buf2);
4207
5061
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
4208
5062
  if (!SWIG_IsOK(ecode3)) {
4209
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "iso9660_pathtable_m_add_entry" "', argument " "3"" of type '" "unsigned int""'");
5063
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","iso9660_pathtable_m_add_entry", 3, argv[2] ));
4210
5064
  }
4211
5065
  arg3 = (unsigned int)(val3);
4212
5066
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
4213
5067
  if (!SWIG_IsOK(ecode4)) {
4214
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "iso9660_pathtable_m_add_entry" "', argument " "4"" of type '" "unsigned int""'");
5068
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","iso9660_pathtable_m_add_entry", 4, argv[3] ));
4215
5069
  }
4216
5070
  arg4 = (unsigned int)(val4);
4217
5071
  result = (unsigned int)iso9660_pathtable_m_add_entry(arg1,(char const (*))arg2,arg3,arg4);
@@ -4224,6 +5078,15 @@ fail:
4224
5078
  }
4225
5079
 
4226
5080
 
5081
+
5082
+ /*
5083
+ Document-method: Rubyiso9660.set_evd
5084
+
5085
+ call-seq:
5086
+ set_evd(pd)
5087
+
5088
+ Zero's out pathable. Do this first..
5089
+ */
4227
5090
  SWIGINTERN VALUE
4228
5091
  _wrap_set_evd(int argc, VALUE *argv, VALUE self) {
4229
5092
  void *arg1 = (void *) 0 ;
@@ -4234,7 +5097,7 @@ _wrap_set_evd(int argc, VALUE *argv, VALUE self) {
4234
5097
  }
4235
5098
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
4236
5099
  if (!SWIG_IsOK(res1)) {
4237
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_set_evd" "', argument " "1"" of type '" "void *""'");
5100
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","iso9660_set_evd", 1, argv[0] ));
4238
5101
  }
4239
5102
  iso9660_set_evd(arg1);
4240
5103
  return Qnil;
@@ -4243,6 +5106,15 @@ fail:
4243
5106
  }
4244
5107
 
4245
5108
 
5109
+
5110
+ /*
5111
+ Document-method: Rubyiso9660.xa?
5112
+
5113
+ call-seq:
5114
+ xa?(p_iso) -> bool
5115
+
5116
+ Return true if ISO 9660 image has extended attrributes (XA)..
5117
+ */
4246
5118
  SWIGINTERN VALUE
4247
5119
  _wrap_xaq___(int argc, VALUE *argv, VALUE self) {
4248
5120
  iso9660_t *arg1 = (iso9660_t *) 0 ;
@@ -4256,7 +5128,7 @@ _wrap_xaq___(int argc, VALUE *argv, VALUE self) {
4256
5128
  }
4257
5129
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iso9660_t, 0 | 0 );
4258
5130
  if (!SWIG_IsOK(res1)) {
4259
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iso9660_ifs_is_xa" "', argument " "1"" of type '" "iso9660_t const *""'");
5131
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "iso9660_t const *","iso9660_ifs_is_xa", 1, argv[0] ));
4260
5132
  }
4261
5133
  arg1 = (iso9660_t *)(argp1);
4262
5134
  result = (bool)iso9660_ifs_is_xa((iso9660_t const *)arg1);
@@ -4275,15 +5147,15 @@ static swig_type_info _swigt__p_CdIo_t = {"_p_CdIo_t", "CdIo_t *", 0, 0, (void*)
4275
5147
  static swig_type_info _swigt__p_CdioList_t = {"_p_CdioList_t", "CdioList_t *|IsoStatList_t *", 0, 0, (void*)0, 0};
4276
5148
  static swig_type_info _swigt__p_cdio_read_mode_t = {"_p_cdio_read_mode_t", "enum cdio_read_mode_t *|cdio_read_mode_t *", 0, 0, (void*)0, 0};
4277
5149
  static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
4278
- static swig_type_info _swigt__p_int = {"_p_int", "int *|lba_t *", 0, 0, (void*)0, 0};
5150
+ static swig_type_info _swigt__p_int = {"_p_int", "int *|lba_t *|lsn_t *|int16_t *", 0, 0, (void*)0, 0};
4279
5151
  static swig_type_info _swigt__p_iso9660_dir_t = {"_p_iso9660_dir_t", "iso9660_dir_t *", 0, 0, (void*)0, 0};
4280
5152
  static swig_type_info _swigt__p_iso9660_dtime_t = {"_p_iso9660_dtime_t", "iso9660_dtime_t *", 0, 0, (void*)0, 0};
4281
5153
  static swig_type_info _swigt__p_iso9660_ltime_t = {"_p_iso9660_ltime_t", "iso9660_ltime_t *", 0, 0, (void*)0, 0};
4282
5154
  static swig_type_info _swigt__p_iso9660_pvd_t = {"_p_iso9660_pvd_t", "iso9660_pvd_t *", 0, 0, (void*)0, 0};
4283
5155
  static swig_type_info _swigt__p_iso9660_stat_t = {"_p_iso9660_stat_t", "iso9660_stat_t *|IsoStat_t *", 0, 0, (void*)0, 0};
4284
5156
  static swig_type_info _swigt__p_iso9660_t = {"_p_iso9660_t", "iso9660_t *", 0, 0, (void*)0, 0};
4285
- static swig_type_info _swigt__p_long = {"_p_long", "long *|ssize_t *", 0, 0, (void*)0, 0};
4286
- static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|iso_extension_mask_t *", 0, 0, (void*)0, 0};
5157
+ static swig_type_info _swigt__p_long = {"_p_long", "my_ssize_t *|ssize_t *|long *|driver_return_code_t *", 0, 0, (void*)0, 0};
5158
+ static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "track_t *|unsigned int *|cdio_drive_write_cap_t *|cdio_drive_misc_cap_t *|cdio_drive_read_cap_t *|iso_extension_mask_t *|driver_id_t *", 0, 0, (void*)0, 0};
4287
5159
 
4288
5160
  static swig_type_info *swig_type_initial[] = {
4289
5161
  &_swigt__p_Buf_tuple_t,
@@ -4565,7 +5437,9 @@ SWIG_PropagateClientData(void) {
4565
5437
  }
4566
5438
  #endif
4567
5439
 
5440
+ /*
4568
5441
 
5442
+ */
4569
5443
  #ifdef __cplusplus
4570
5444
  extern "C"
4571
5445
  #endif