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
 
@@ -1546,7 +1735,11 @@ static swig_module_info swig_module = {swig_types, 10, 0, 0, 0, 0};
1546
1735
 
1547
1736
  static VALUE mRubycdio;
1548
1737
 
1549
- #define SWIGVERSION 0x010331
1738
+ #define SWIG_RUBY_THREAD_BEGIN_BLOCK
1739
+ #define SWIG_RUBY_THREAD_END_BLOCK
1740
+
1741
+
1742
+ #define SWIGVERSION 0x010333
1550
1743
  #define SWIG_VERSION SWIGVERSION
1551
1744
 
1552
1745
 
@@ -1646,14 +1839,12 @@ cdio_eject_media_drive (const char *psz_drive)
1646
1839
 
1647
1840
 
1648
1841
  #include <limits.h>
1649
- #ifndef LLONG_MIN
1650
- # define LLONG_MIN LONG_LONG_MIN
1651
- #endif
1652
- #ifndef LLONG_MAX
1653
- # define LLONG_MAX LONG_LONG_MAX
1654
- #endif
1655
- #ifndef ULLONG_MAX
1656
- # define ULLONG_MAX ULONG_LONG_MAX
1842
+ #if !defined(SWIG_NO_LLONG_MAX)
1843
+ # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1844
+ # define LLONG_MAX __LONG_LONG_MAX__
1845
+ # define LLONG_MIN (-LLONG_MAX - 1LL)
1846
+ # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1847
+ # endif
1657
1848
  #endif
1658
1849
 
1659
1850
 
@@ -1674,7 +1865,7 @@ SWIG_ruby_failed(void)
1674
1865
  }
1675
1866
 
1676
1867
 
1677
- /*@SWIG:%ruby_aux_method@*/
1868
+ /*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
1678
1869
  SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
1679
1870
  {
1680
1871
  VALUE obj = args[0];
@@ -1719,7 +1910,7 @@ SWIG_AsVal_int (VALUE obj, int *val)
1719
1910
  }
1720
1911
 
1721
1912
 
1722
- /*@SWIG:%ruby_aux_method@*/
1913
+ /*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
1723
1914
  SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
1724
1915
  {
1725
1916
  VALUE obj = args[0];
@@ -1781,11 +1972,11 @@ SWIGINTERN int
1781
1972
  SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
1782
1973
  {
1783
1974
  if (TYPE(obj) == T_STRING) {
1784
-
1785
-
1786
-
1975
+ #if defined(StringValuePtr)
1976
+ char *cstr = StringValuePtr(obj);
1977
+ #else
1787
1978
  char *cstr = STR2CSTR(obj);
1788
-
1979
+ #endif
1789
1980
  size_t size = RSTRING_LEN(obj) + 1;
1790
1981
  if (cptr) {
1791
1982
  if (alloc) {
@@ -2260,26 +2451,26 @@ _wrap_cdio_read_sectors(int argc, VALUE *argv, VALUE self) {
2260
2451
  }
2261
2452
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2262
2453
  if (!SWIG_IsOK(res1)) {
2263
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_read_sectors" "', argument " "1"" of type '" "CdIo_t const *""'");
2454
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_read_sectors", 1, argv[0] ));
2264
2455
  }
2265
2456
  arg1 = (CdIo_t *)(argp1);
2266
2457
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
2267
2458
  if (!SWIG_IsOK(res2)) {
2268
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdio_read_sectors" "', argument " "2"" of type '" "void *""'");
2459
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","cdio_read_sectors", 2, argv[1] ));
2269
2460
  }
2270
2461
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
2271
2462
  if (!SWIG_IsOK(ecode3)) {
2272
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdio_read_sectors" "', argument " "3"" of type '" "lsn_t""'");
2463
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "lsn_t","cdio_read_sectors", 3, argv[2] ));
2273
2464
  }
2274
2465
  arg3 = (lsn_t)(val3);
2275
2466
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
2276
2467
  if (!SWIG_IsOK(ecode4)) {
2277
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cdio_read_sectors" "', argument " "4"" of type '" "cdio_read_mode_t""'");
2468
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "cdio_read_mode_t","cdio_read_sectors", 4, argv[3] ));
2278
2469
  }
2279
2470
  arg4 = (cdio_read_mode_t)(val4);
2280
2471
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[4], &val5);
2281
2472
  if (!SWIG_IsOK(ecode5)) {
2282
- SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cdio_read_sectors" "', argument " "5"" of type '" "unsigned int""'");
2473
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned int","cdio_read_sectors", 5, argv[4] ));
2283
2474
  }
2284
2475
  arg5 = (unsigned int)(val5);
2285
2476
  result = (driver_return_code_t)cdio_read_sectors((CdIo_t const *)arg1,arg2,arg3,arg4,arg5);
@@ -2304,7 +2495,7 @@ _wrap_cdio_eject_media_drive(int argc, VALUE *argv, VALUE self) {
2304
2495
  }
2305
2496
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
2306
2497
  if (!SWIG_IsOK(res1)) {
2307
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_eject_media_drive" "', argument " "1"" of type '" "char const *""'");
2498
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdio_eject_media_drive", 1, argv[0] ));
2308
2499
  }
2309
2500
  arg1 = (char *)(buf1);
2310
2501
  result = (driver_return_code_t)cdio_eject_media_drive((char const *)arg1);
@@ -2317,6 +2508,17 @@ fail:
2317
2508
  }
2318
2509
 
2319
2510
 
2511
+
2512
+ /*
2513
+ Document-method: Rubycdio.audio_pause
2514
+
2515
+ call-seq:
2516
+ audio_pause(p_cdio) -> driver_return_code_t
2517
+
2518
+ audio_pause(cdio)->status
2519
+
2520
+ Pause playing CD through analog output..
2521
+ */
2320
2522
  SWIGINTERN VALUE
2321
2523
  _wrap_audio_pause(int argc, VALUE *argv, VALUE self) {
2322
2524
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2330,7 +2532,7 @@ _wrap_audio_pause(int argc, VALUE *argv, VALUE self) {
2330
2532
  }
2331
2533
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2332
2534
  if (!SWIG_IsOK(res1)) {
2333
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_audio_pause" "', argument " "1"" of type '" "CdIo_t *""'");
2535
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","cdio_audio_pause", 1, argv[0] ));
2334
2536
  }
2335
2537
  arg1 = (CdIo_t *)(argp1);
2336
2538
  result = (driver_return_code_t)cdio_audio_pause(arg1);
@@ -2341,6 +2543,17 @@ fail:
2341
2543
  }
2342
2544
 
2343
2545
 
2546
+
2547
+ /*
2548
+ Document-method: Rubycdio.audio_play_lsn
2549
+
2550
+ call-seq:
2551
+ audio_play_lsn(p_cdio, start_lsn, end_lsn) -> driver_return_code_t
2552
+
2553
+ auto_play_lsn(cdio, start_lsn, end_lsn)->status
2554
+
2555
+ Playing CD through analog output at the given lsn to the ending lsn.
2556
+ */
2344
2557
  SWIGINTERN VALUE
2345
2558
  _wrap_audio_play_lsn(int argc, VALUE *argv, VALUE self) {
2346
2559
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2360,17 +2573,17 @@ _wrap_audio_play_lsn(int argc, VALUE *argv, VALUE self) {
2360
2573
  }
2361
2574
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2362
2575
  if (!SWIG_IsOK(res1)) {
2363
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "audio_play_lsn" "', argument " "1"" of type '" "CdIo_t *""'");
2576
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","audio_play_lsn", 1, argv[0] ));
2364
2577
  }
2365
2578
  arg1 = (CdIo_t *)(argp1);
2366
2579
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
2367
2580
  if (!SWIG_IsOK(ecode2)) {
2368
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "audio_play_lsn" "', argument " "2"" of type '" "lsn_t""'");
2581
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "lsn_t","audio_play_lsn", 2, argv[1] ));
2369
2582
  }
2370
2583
  arg2 = (lsn_t)(val2);
2371
2584
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
2372
2585
  if (!SWIG_IsOK(ecode3)) {
2373
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "audio_play_lsn" "', argument " "3"" of type '" "lsn_t""'");
2586
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "lsn_t","audio_play_lsn", 3, argv[2] ));
2374
2587
  }
2375
2588
  arg3 = (lsn_t)(val3);
2376
2589
  result = (driver_return_code_t)audio_play_lsn(arg1,arg2,arg3);
@@ -2381,6 +2594,16 @@ fail:
2381
2594
  }
2382
2595
 
2383
2596
 
2597
+
2598
+ /*
2599
+ Document-method: Rubycdio.audio_resume
2600
+
2601
+ call-seq:
2602
+ audio_resume(p_cdio) -> driver_return_code_t
2603
+
2604
+ audio_resume(cdio)->status
2605
+ Resume playing an audio CD..
2606
+ */
2384
2607
  SWIGINTERN VALUE
2385
2608
  _wrap_audio_resume(int argc, VALUE *argv, VALUE self) {
2386
2609
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2394,7 +2617,7 @@ _wrap_audio_resume(int argc, VALUE *argv, VALUE self) {
2394
2617
  }
2395
2618
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2396
2619
  if (!SWIG_IsOK(res1)) {
2397
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_audio_resume" "', argument " "1"" of type '" "CdIo_t *""'");
2620
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","cdio_audio_resume", 1, argv[0] ));
2398
2621
  }
2399
2622
  arg1 = (CdIo_t *)(argp1);
2400
2623
  result = (driver_return_code_t)cdio_audio_resume(arg1);
@@ -2405,6 +2628,16 @@ fail:
2405
2628
  }
2406
2629
 
2407
2630
 
2631
+
2632
+ /*
2633
+ Document-method: Rubycdio.audio_stop
2634
+
2635
+ call-seq:
2636
+ audio_stop(p_cdio) -> driver_return_code_t
2637
+
2638
+ audio_stop(cdio)->status
2639
+ Stop playing an audio CD..
2640
+ */
2408
2641
  SWIGINTERN VALUE
2409
2642
  _wrap_audio_stop(int argc, VALUE *argv, VALUE self) {
2410
2643
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2418,7 +2651,7 @@ _wrap_audio_stop(int argc, VALUE *argv, VALUE self) {
2418
2651
  }
2419
2652
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2420
2653
  if (!SWIG_IsOK(res1)) {
2421
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_audio_stop" "', argument " "1"" of type '" "CdIo_t *""'");
2654
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","cdio_audio_stop", 1, argv[0] ));
2422
2655
  }
2423
2656
  arg1 = (CdIo_t *)(argp1);
2424
2657
  result = (driver_return_code_t)cdio_audio_stop(arg1);
@@ -2429,8 +2662,38 @@ fail:
2429
2662
  }
2430
2663
 
2431
2664
 
2665
+
2666
+ /*
2667
+ Document-class: Rubycdio::Buf_triple_t
2668
+
2669
+ call-seq:
2670
+
2671
+
2672
+ audio_stop(cdio)->status
2673
+ Stop playing an audio CD..
2674
+ */
2432
2675
  swig_class cBuf_triple_t;
2433
2676
 
2677
+
2678
+ /*
2679
+ Document-method: Rubycdio::Buf_triple_t.data
2680
+
2681
+ call-seq:
2682
+ data -> char
2683
+
2684
+ audio_stop(cdio)->status
2685
+ Stop playing an audio CD..
2686
+ */
2687
+
2688
+ /*
2689
+ Document-method: Rubycdio::Buf_triple_t.data=
2690
+
2691
+ call-seq:
2692
+ data=(x) -> char
2693
+
2694
+ audio_stop(cdio)->status
2695
+ Stop playing an audio CD..
2696
+ */
2434
2697
  SWIGINTERN VALUE
2435
2698
  _wrap_Buf_triple_t_data_set(int argc, VALUE *argv, VALUE self) {
2436
2699
  Buf_triple_t *arg1 = (Buf_triple_t *) 0 ;
@@ -2446,12 +2709,12 @@ _wrap_Buf_triple_t_data_set(int argc, VALUE *argv, VALUE self) {
2446
2709
  }
2447
2710
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Buf_triple_t, 0 | 0 );
2448
2711
  if (!SWIG_IsOK(res1)) {
2449
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "data" "', argument " "1"" of type '" "Buf_triple_t *""'");
2712
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Buf_triple_t *","data", 1, self ));
2450
2713
  }
2451
2714
  arg1 = (Buf_triple_t *)(argp1);
2452
2715
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2453
2716
  if (!SWIG_IsOK(res2)) {
2454
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "data" "', argument " "2"" of type '" "char *""'");
2717
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","data", 2, argv[0] ));
2455
2718
  }
2456
2719
  arg2 = (char *)(buf2);
2457
2720
  if (arg1->data) free((char*)arg1->data);
@@ -2482,7 +2745,7 @@ _wrap_Buf_triple_t_data_get(int argc, VALUE *argv, VALUE self) {
2482
2745
  }
2483
2746
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Buf_triple_t, 0 | 0 );
2484
2747
  if (!SWIG_IsOK(res1)) {
2485
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "data" "', argument " "1"" of type '" "Buf_triple_t *""'");
2748
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Buf_triple_t *","data", 1, self ));
2486
2749
  }
2487
2750
  arg1 = (Buf_triple_t *)(argp1);
2488
2751
  result = (char *) ((arg1)->data);
@@ -2493,6 +2756,24 @@ fail:
2493
2756
  }
2494
2757
 
2495
2758
 
2759
+
2760
+ /*
2761
+ Document-method: Rubycdio::Buf_triple_t.size
2762
+
2763
+ call-seq:
2764
+ size -> size_t
2765
+
2766
+ Size or Length of the Buf_triple_t.
2767
+ */
2768
+
2769
+ /*
2770
+ Document-method: Rubycdio::Buf_triple_t.size=
2771
+
2772
+ call-seq:
2773
+ size=(x) -> size_t
2774
+
2775
+ Size or Length of the Buf_triple_t.
2776
+ */
2496
2777
  SWIGINTERN VALUE
2497
2778
  _wrap_Buf_triple_t_size_set(int argc, VALUE *argv, VALUE self) {
2498
2779
  Buf_triple_t *arg1 = (Buf_triple_t *) 0 ;
@@ -2507,12 +2788,12 @@ _wrap_Buf_triple_t_size_set(int argc, VALUE *argv, VALUE self) {
2507
2788
  }
2508
2789
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Buf_triple_t, 0 | 0 );
2509
2790
  if (!SWIG_IsOK(res1)) {
2510
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "size" "', argument " "1"" of type '" "Buf_triple_t *""'");
2791
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Buf_triple_t *","size", 1, self ));
2511
2792
  }
2512
2793
  arg1 = (Buf_triple_t *)(argp1);
2513
2794
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
2514
2795
  if (!SWIG_IsOK(ecode2)) {
2515
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "size" "', argument " "2"" of type '" "size_t""'");
2796
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","size", 2, argv[0] ));
2516
2797
  }
2517
2798
  arg2 = (size_t)(val2);
2518
2799
  if (arg1) (arg1)->size = arg2;
@@ -2536,7 +2817,7 @@ _wrap_Buf_triple_t_size_get(int argc, VALUE *argv, VALUE self) {
2536
2817
  }
2537
2818
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Buf_triple_t, 0 | 0 );
2538
2819
  if (!SWIG_IsOK(res1)) {
2539
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "size" "', argument " "1"" of type '" "Buf_triple_t *""'");
2820
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Buf_triple_t *","size", 1, self ));
2540
2821
  }
2541
2822
  arg1 = (Buf_triple_t *)(argp1);
2542
2823
  result = ((arg1)->size);
@@ -2547,6 +2828,26 @@ fail:
2547
2828
  }
2548
2829
 
2549
2830
 
2831
+
2832
+ /*
2833
+ Document-method: Rubycdio::Buf_triple_t.drc
2834
+
2835
+ call-seq:
2836
+ drc -> driver_return_code_t
2837
+
2838
+ audio_stop(cdio)->status
2839
+ Stop playing an audio CD..
2840
+ */
2841
+
2842
+ /*
2843
+ Document-method: Rubycdio::Buf_triple_t.drc=
2844
+
2845
+ call-seq:
2846
+ drc=(x) -> driver_return_code_t
2847
+
2848
+ audio_stop(cdio)->status
2849
+ Stop playing an audio CD..
2850
+ */
2550
2851
  SWIGINTERN VALUE
2551
2852
  _wrap_Buf_triple_t_drc_set(int argc, VALUE *argv, VALUE self) {
2552
2853
  Buf_triple_t *arg1 = (Buf_triple_t *) 0 ;
@@ -2561,12 +2862,12 @@ _wrap_Buf_triple_t_drc_set(int argc, VALUE *argv, VALUE self) {
2561
2862
  }
2562
2863
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Buf_triple_t, 0 | 0 );
2563
2864
  if (!SWIG_IsOK(res1)) {
2564
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "drc" "', argument " "1"" of type '" "Buf_triple_t *""'");
2865
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Buf_triple_t *","drc", 1, self ));
2565
2866
  }
2566
2867
  arg1 = (Buf_triple_t *)(argp1);
2567
2868
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
2568
2869
  if (!SWIG_IsOK(ecode2)) {
2569
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "drc" "', argument " "2"" of type '" "driver_return_code_t""'");
2870
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "driver_return_code_t","drc", 2, argv[0] ));
2570
2871
  }
2571
2872
  arg2 = (driver_return_code_t)(val2);
2572
2873
  if (arg1) (arg1)->drc = arg2;
@@ -2590,7 +2891,7 @@ _wrap_Buf_triple_t_drc_get(int argc, VALUE *argv, VALUE self) {
2590
2891
  }
2591
2892
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Buf_triple_t, 0 | 0 );
2592
2893
  if (!SWIG_IsOK(res1)) {
2593
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "drc" "', argument " "1"" of type '" "Buf_triple_t *""'");
2894
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Buf_triple_t *","drc", 1, self ));
2594
2895
  }
2595
2896
  arg1 = (Buf_triple_t *)(argp1);
2596
2897
  result = (driver_return_code_t) ((arg1)->drc);
@@ -2618,6 +2919,18 @@ _wrap_Buf_triple_t_allocate(VALUE self) {
2618
2919
  }
2619
2920
 
2620
2921
 
2922
+
2923
+ /*
2924
+ Document-method: Rubycdio::Buf_triple_t.new
2925
+
2926
+ call-seq:
2927
+
2928
+
2929
+ get_num_tracks(p_cdio)->int
2930
+
2931
+ Return the number of tracks on the CD.
2932
+ On error rubycdio::INVALID_TRACK is returned..
2933
+ */
2621
2934
  SWIGINTERN VALUE
2622
2935
  _wrap_new_Buf_triple_t(int argc, VALUE *argv, VALUE self) {
2623
2936
  Buf_triple_t *result = 0 ;
@@ -2638,6 +2951,16 @@ free_Buf_triple_t(Buf_triple_t *arg1) {
2638
2951
  free((char *) arg1);
2639
2952
  }
2640
2953
 
2954
+
2955
+ /*
2956
+ Document-method: Rubycdio.lseek
2957
+
2958
+ call-seq:
2959
+ lseek(p_cdio, offset, whence=SEEK_SET) -> off_t
2960
+
2961
+ audio_stop(cdio)->status
2962
+ Stop playing an audio CD..
2963
+ */
2641
2964
  SWIGINTERN VALUE
2642
2965
  _wrap_lseek(int argc, VALUE *argv, VALUE self) {
2643
2966
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2657,16 +2980,16 @@ _wrap_lseek(int argc, VALUE *argv, VALUE self) {
2657
2980
  }
2658
2981
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2659
2982
  if (!SWIG_IsOK(res1)) {
2660
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_lseek" "', argument " "1"" of type '" "CdIo_t const *""'");
2983
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_lseek", 1, argv[0] ));
2661
2984
  }
2662
2985
  arg1 = (CdIo_t *)(argp1);
2663
2986
  {
2664
2987
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_off_t, 0 );
2665
2988
  if (!SWIG_IsOK(res2)) {
2666
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdio_lseek" "', argument " "2"" of type '" "off_t""'");
2989
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "off_t","cdio_lseek", 2, argv[1] ));
2667
2990
  }
2668
2991
  if (!argp2) {
2669
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cdio_lseek" "', argument " "2"" of type '" "off_t""'");
2992
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "off_t","cdio_lseek", 2, argv[1]));
2670
2993
  } else {
2671
2994
  arg2 = *((off_t *)(argp2));
2672
2995
  }
@@ -2674,7 +2997,7 @@ _wrap_lseek(int argc, VALUE *argv, VALUE self) {
2674
2997
  if (argc > 2) {
2675
2998
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
2676
2999
  if (!SWIG_IsOK(ecode3)) {
2677
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdio_lseek" "', argument " "3"" of type '" "int""'");
3000
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdio_lseek", 3, argv[2] ));
2678
3001
  }
2679
3002
  arg3 = (int)(val3);
2680
3003
  }
@@ -2686,6 +3009,16 @@ fail:
2686
3009
  }
2687
3010
 
2688
3011
 
3012
+
3013
+ /*
3014
+ Document-method: Rubycdio.read_cd
3015
+
3016
+ call-seq:
3017
+ read_cd(p_cdio, i_size) -> Buf_triple_t
3018
+
3019
+ audio_stop(cdio)->status
3020
+ Stop playing an audio CD..
3021
+ */
2689
3022
  SWIGINTERN VALUE
2690
3023
  _wrap_read_cd(int argc, VALUE *argv, VALUE self) {
2691
3024
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2702,12 +3035,12 @@ _wrap_read_cd(int argc, VALUE *argv, VALUE self) {
2702
3035
  }
2703
3036
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2704
3037
  if (!SWIG_IsOK(res1)) {
2705
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read_cd" "', argument " "1"" of type '" "CdIo_t const *""'");
3038
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","read_cd", 1, argv[0] ));
2706
3039
  }
2707
3040
  arg1 = (CdIo_t *)(argp1);
2708
3041
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
2709
3042
  if (!SWIG_IsOK(ecode2)) {
2710
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "read_cd" "', argument " "2"" of type '" "size_t""'");
3043
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","read_cd", 2, argv[1] ));
2711
3044
  }
2712
3045
  arg2 = (size_t)(val2);
2713
3046
  result = read_cd((CdIo_t const *)arg1,arg2);
@@ -2730,6 +3063,16 @@ fail:
2730
3063
  }
2731
3064
 
2732
3065
 
3066
+
3067
+ /*
3068
+ Document-method: Rubycdio.read_sectors
3069
+
3070
+ call-seq:
3071
+ read_sectors(p_cdio, i_lsn, read_mode, i_size) -> Buf_triple_t
3072
+
3073
+ audio_stop(cdio)->status
3074
+ Stop playing an audio CD..
3075
+ */
2733
3076
  SWIGINTERN VALUE
2734
3077
  _wrap_read_sectors(int argc, VALUE *argv, VALUE self) {
2735
3078
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2752,22 +3095,22 @@ _wrap_read_sectors(int argc, VALUE *argv, VALUE self) {
2752
3095
  }
2753
3096
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2754
3097
  if (!SWIG_IsOK(res1)) {
2755
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read_sectors" "', argument " "1"" of type '" "CdIo_t const *""'");
3098
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","read_sectors", 1, argv[0] ));
2756
3099
  }
2757
3100
  arg1 = (CdIo_t *)(argp1);
2758
3101
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
2759
3102
  if (!SWIG_IsOK(ecode2)) {
2760
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "read_sectors" "', argument " "2"" of type '" "lsn_t""'");
3103
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "lsn_t","read_sectors", 2, argv[1] ));
2761
3104
  }
2762
3105
  arg2 = (lsn_t)(val2);
2763
3106
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
2764
3107
  if (!SWIG_IsOK(ecode3)) {
2765
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "read_sectors" "', argument " "3"" of type '" "cdio_read_mode_t""'");
3108
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "cdio_read_mode_t","read_sectors", 3, argv[2] ));
2766
3109
  }
2767
3110
  arg3 = (cdio_read_mode_t)(val3);
2768
3111
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
2769
3112
  if (!SWIG_IsOK(ecode4)) {
2770
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "read_sectors" "', argument " "4"" of type '" "size_t""'");
3113
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","read_sectors", 4, argv[3] ));
2771
3114
  }
2772
3115
  arg4 = (size_t)(val4);
2773
3116
  result = read_sectors((CdIo_t const *)arg1,arg2,arg3,arg4);
@@ -2790,6 +3133,16 @@ fail:
2790
3133
  }
2791
3134
 
2792
3135
 
3136
+
3137
+ /*
3138
+ Document-method: Rubycdio.read_data_bytes
3139
+
3140
+ call-seq:
3141
+ read_data_bytes(p_cdio, i_lsn, i_blocksize, i_size) -> Buf_triple_t
3142
+
3143
+ audio_stop(cdio)->status
3144
+ Stop playing an audio CD..
3145
+ */
2793
3146
  SWIGINTERN VALUE
2794
3147
  _wrap_read_data_bytes(int argc, VALUE *argv, VALUE self) {
2795
3148
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2812,22 +3165,22 @@ _wrap_read_data_bytes(int argc, VALUE *argv, VALUE self) {
2812
3165
  }
2813
3166
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2814
3167
  if (!SWIG_IsOK(res1)) {
2815
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read_data_bytes" "', argument " "1"" of type '" "CdIo_t const *""'");
3168
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","read_data_bytes", 1, argv[0] ));
2816
3169
  }
2817
3170
  arg1 = (CdIo_t *)(argp1);
2818
3171
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
2819
3172
  if (!SWIG_IsOK(ecode2)) {
2820
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "read_data_bytes" "', argument " "2"" of type '" "lsn_t""'");
3173
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "lsn_t","read_data_bytes", 2, argv[1] ));
2821
3174
  }
2822
3175
  arg2 = (lsn_t)(val2);
2823
3176
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
2824
3177
  if (!SWIG_IsOK(ecode3)) {
2825
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "read_data_bytes" "', argument " "3"" of type '" "int16_t""'");
3178
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int16_t","read_data_bytes", 3, argv[2] ));
2826
3179
  }
2827
3180
  arg3 = (int16_t)(val3);
2828
3181
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
2829
3182
  if (!SWIG_IsOK(ecode4)) {
2830
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "read_data_bytes" "', argument " "4"" of type '" "size_t""'");
3183
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","read_data_bytes", 4, argv[3] ));
2831
3184
  }
2832
3185
  arg4 = (size_t)(val4);
2833
3186
  result = read_data_bytes((CdIo_t const *)arg1,arg2,arg3,arg4);
@@ -2850,6 +3203,19 @@ fail:
2850
3203
  }
2851
3204
 
2852
3205
 
3206
+
3207
+ /*
3208
+ Document-method: Rubycdio.get_first_track_num
3209
+
3210
+ call-seq:
3211
+ get_first_track_num(p_cdio) -> track_t
3212
+
3213
+ get_first_track_num(p_cdio) -> int
3214
+ Get the number of the first track.
3215
+
3216
+ return the track number or pycdio.INVALID_TRACK if there was
3217
+ a problem..
3218
+ */
2853
3219
  SWIGINTERN VALUE
2854
3220
  _wrap_get_first_track_num(int argc, VALUE *argv, VALUE self) {
2855
3221
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2863,7 +3229,7 @@ _wrap_get_first_track_num(int argc, VALUE *argv, VALUE self) {
2863
3229
  }
2864
3230
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2865
3231
  if (!SWIG_IsOK(res1)) {
2866
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_first_track_num" "', argument " "1"" of type '" "CdIo_t const *""'");
3232
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_first_track_num", 1, argv[0] ));
2867
3233
  }
2868
3234
  arg1 = (CdIo_t *)(argp1);
2869
3235
  result = (track_t)cdio_get_first_track_num((CdIo_t const *)arg1);
@@ -2874,6 +3240,17 @@ fail:
2874
3240
  }
2875
3241
 
2876
3242
 
3243
+
3244
+ /*
3245
+ Document-method: Rubycdio.get_last_track_num
3246
+
3247
+ call-seq:
3248
+ get_last_track_num(p_cdio) -> track_t
3249
+
3250
+ get_last_track_num
3251
+ Return the last track number.
3252
+ pycdio.INVALID_TRACK is if there was a problem..
3253
+ */
2877
3254
  SWIGINTERN VALUE
2878
3255
  _wrap_get_last_track_num(int argc, VALUE *argv, VALUE self) {
2879
3256
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2887,7 +3264,7 @@ _wrap_get_last_track_num(int argc, VALUE *argv, VALUE self) {
2887
3264
  }
2888
3265
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2889
3266
  if (!SWIG_IsOK(res1)) {
2890
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_last_track_num" "', argument " "1"" of type '" "CdIo_t const *""'");
3267
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_last_track_num", 1, argv[0] ));
2891
3268
  }
2892
3269
  arg1 = (CdIo_t *)(argp1);
2893
3270
  result = (track_t)cdio_get_last_track_num((CdIo_t const *)arg1);
@@ -2898,6 +3275,22 @@ fail:
2898
3275
  }
2899
3276
 
2900
3277
 
3278
+
3279
+ /*
3280
+ Document-method: Rubycdio.get_track
3281
+
3282
+ call-seq:
3283
+ get_track(p_cdio, lsn) -> track_t
3284
+
3285
+ cdio_get_track(lsn)->int
3286
+
3287
+ Find the track which contains lsn.
3288
+ pycdio.INVALID_TRACK is returned if the lsn outside of the CD or
3289
+ if there was some error.
3290
+
3291
+ If the lsn is before the pregap of the first track, 0 is returned.
3292
+ Otherwise we return the track that spans the lsn..
3293
+ */
2901
3294
  SWIGINTERN VALUE
2902
3295
  _wrap_get_track(int argc, VALUE *argv, VALUE self) {
2903
3296
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2914,12 +3307,12 @@ _wrap_get_track(int argc, VALUE *argv, VALUE self) {
2914
3307
  }
2915
3308
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2916
3309
  if (!SWIG_IsOK(res1)) {
2917
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_track" "', argument " "1"" of type '" "CdIo_t const *""'");
3310
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_track", 1, argv[0] ));
2918
3311
  }
2919
3312
  arg1 = (CdIo_t *)(argp1);
2920
3313
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
2921
3314
  if (!SWIG_IsOK(ecode2)) {
2922
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_get_track" "', argument " "2"" of type '" "lsn_t""'");
3315
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "lsn_t","cdio_get_track", 2, argv[1] ));
2923
3316
  }
2924
3317
  arg2 = (lsn_t)(val2);
2925
3318
  result = (track_t)cdio_get_track((CdIo_t const *)arg1,arg2);
@@ -2930,6 +3323,18 @@ fail:
2930
3323
  }
2931
3324
 
2932
3325
 
3326
+
3327
+ /*
3328
+ Document-method: Rubycdio.get_track_channels
3329
+
3330
+ call-seq:
3331
+ get_track_channels(p_cdio, i_track) -> int
3332
+
3333
+ get_track_channels(cdio, track)->int
3334
+
3335
+ Return number of channels in track: 2 or 4; -2 if implemented or -1
3336
+ for error. Not meaningful if track is not an audio track..
3337
+ */
2933
3338
  SWIGINTERN VALUE
2934
3339
  _wrap_get_track_channels(int argc, VALUE *argv, VALUE self) {
2935
3340
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2946,12 +3351,12 @@ _wrap_get_track_channels(int argc, VALUE *argv, VALUE self) {
2946
3351
  }
2947
3352
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2948
3353
  if (!SWIG_IsOK(res1)) {
2949
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_track_channels" "', argument " "1"" of type '" "CdIo_t const *""'");
3354
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_track_channels", 1, argv[0] ));
2950
3355
  }
2951
3356
  arg1 = (CdIo_t *)(argp1);
2952
3357
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
2953
3358
  if (!SWIG_IsOK(ecode2)) {
2954
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_get_track_channels" "', argument " "2"" of type '" "track_t""'");
3359
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "track_t","cdio_get_track_channels", 2, argv[1] ));
2955
3360
  }
2956
3361
  arg2 = (track_t)(val2);
2957
3362
  result = (int)cdio_get_track_channels((CdIo_t const *)arg1,arg2);
@@ -2962,6 +3367,19 @@ fail:
2962
3367
  }
2963
3368
 
2964
3369
 
3370
+
3371
+ /*
3372
+ Document-method: Rubycdio.track_copy_permit?
3373
+
3374
+ call-seq:
3375
+ track_copy_permit?(p_cdio, i_track) -> bool
3376
+
3377
+ copy_permit?(cdio, track)->bool
3378
+
3379
+ Return copy protection status on a track. Is this meaningful
3380
+ not an audio track?
3381
+ .
3382
+ */
2965
3383
  SWIGINTERN VALUE
2966
3384
  _wrap_track_copy_permitq___(int argc, VALUE *argv, VALUE self) {
2967
3385
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -2978,12 +3396,12 @@ _wrap_track_copy_permitq___(int argc, VALUE *argv, VALUE self) {
2978
3396
  }
2979
3397
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
2980
3398
  if (!SWIG_IsOK(res1)) {
2981
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_track_copy_permit" "', argument " "1"" of type '" "CdIo_t const *""'");
3399
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_track_copy_permit", 1, argv[0] ));
2982
3400
  }
2983
3401
  arg1 = (CdIo_t *)(argp1);
2984
3402
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
2985
3403
  if (!SWIG_IsOK(ecode2)) {
2986
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_get_track_copy_permit" "', argument " "2"" of type '" "track_t""'");
3404
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "track_t","cdio_get_track_copy_permit", 2, argv[1] ));
2987
3405
  }
2988
3406
  arg2 = (track_t)(val2);
2989
3407
  result = (bool)cdio_get_track_copy_permit((CdIo_t const *)arg1,arg2);
@@ -2994,6 +3412,17 @@ fail:
2994
3412
  }
2995
3413
 
2996
3414
 
3415
+
3416
+ /*
3417
+ Document-method: Rubycdio.get_track_format
3418
+
3419
+ call-seq:
3420
+ get_track_format(p_cdio, i_track) -> char
3421
+
3422
+ get_track_format(cdio, track)->format
3423
+
3424
+ Get the format (audio, mode2, mode1) of track. .
3425
+ */
2997
3426
  SWIGINTERN VALUE
2998
3427
  _wrap_get_track_format(int argc, VALUE *argv, VALUE self) {
2999
3428
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3010,12 +3439,12 @@ _wrap_get_track_format(int argc, VALUE *argv, VALUE self) {
3010
3439
  }
3011
3440
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3012
3441
  if (!SWIG_IsOK(res1)) {
3013
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_track_format" "', argument " "1"" of type '" "CdIo_t const *""'");
3442
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","get_track_format", 1, argv[0] ));
3014
3443
  }
3015
3444
  arg1 = (CdIo_t *)(argp1);
3016
3445
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
3017
3446
  if (!SWIG_IsOK(ecode2)) {
3018
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_track_format" "', argument " "2"" of type '" "track_t""'");
3447
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "track_t","get_track_format", 2, argv[1] ));
3019
3448
  }
3020
3449
  arg2 = (track_t)(val2);
3021
3450
  result = (char *)get_track_format((CdIo_t const *)arg1,arg2);
@@ -3026,6 +3455,22 @@ fail:
3026
3455
  }
3027
3456
 
3028
3457
 
3458
+
3459
+ /*
3460
+ Document-method: Rubycdio.track_green?
3461
+
3462
+ call-seq:
3463
+ track_green?(p_cdio, i_track) -> bool
3464
+
3465
+ track_green?(cdio, track) -> bool
3466
+
3467
+ Return True if we have XA data (green, mode2 form1) or
3468
+ XA data (green, mode2 form2). That is track begins:
3469
+ sync - header - subheader
3470
+ 12 4 - 8
3471
+
3472
+ FIXME: there's gotta be a better design for this and get_track_format?.
3473
+ */
3029
3474
  SWIGINTERN VALUE
3030
3475
  _wrap_track_greenq___(int argc, VALUE *argv, VALUE self) {
3031
3476
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3042,12 +3487,12 @@ _wrap_track_greenq___(int argc, VALUE *argv, VALUE self) {
3042
3487
  }
3043
3488
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3044
3489
  if (!SWIG_IsOK(res1)) {
3045
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_track_green" "', argument " "1"" of type '" "CdIo_t const *""'");
3490
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_track_green", 1, argv[0] ));
3046
3491
  }
3047
3492
  arg1 = (CdIo_t *)(argp1);
3048
3493
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
3049
3494
  if (!SWIG_IsOK(ecode2)) {
3050
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_get_track_green" "', argument " "2"" of type '" "track_t""'");
3495
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "track_t","cdio_get_track_green", 2, argv[1] ));
3051
3496
  }
3052
3497
  arg2 = (track_t)(val2);
3053
3498
  result = (bool)cdio_get_track_green((CdIo_t const *)arg1,arg2);
@@ -3058,6 +3503,18 @@ fail:
3058
3503
  }
3059
3504
 
3060
3505
 
3506
+
3507
+ /*
3508
+ Document-method: Rubycdio.get_track_last_lsn
3509
+
3510
+ call-seq:
3511
+ get_track_last_lsn(p_cdio, i_track) -> lsn_t
3512
+
3513
+ cdio_get_track_last_lsn(cdio, track)->lsn
3514
+
3515
+ Return the ending LSN for track number
3516
+ track in cdio. CDIO_INVALID_LSN is returned on error..
3517
+ */
3061
3518
  SWIGINTERN VALUE
3062
3519
  _wrap_get_track_last_lsn(int argc, VALUE *argv, VALUE self) {
3063
3520
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3074,12 +3531,12 @@ _wrap_get_track_last_lsn(int argc, VALUE *argv, VALUE self) {
3074
3531
  }
3075
3532
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3076
3533
  if (!SWIG_IsOK(res1)) {
3077
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_track_last_lsn" "', argument " "1"" of type '" "CdIo_t const *""'");
3534
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_track_last_lsn", 1, argv[0] ));
3078
3535
  }
3079
3536
  arg1 = (CdIo_t *)(argp1);
3080
3537
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
3081
3538
  if (!SWIG_IsOK(ecode2)) {
3082
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_get_track_last_lsn" "', argument " "2"" of type '" "track_t""'");
3539
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "track_t","cdio_get_track_last_lsn", 2, argv[1] ));
3083
3540
  }
3084
3541
  arg2 = (track_t)(val2);
3085
3542
  result = (lsn_t)cdio_get_track_last_lsn((CdIo_t const *)arg1,arg2);
@@ -3090,6 +3547,25 @@ fail:
3090
3547
  }
3091
3548
 
3092
3549
 
3550
+
3551
+ /*
3552
+ Document-method: Rubycdio.get_track_lba
3553
+
3554
+ call-seq:
3555
+ get_track_lba(p_cdio, i_track) -> lba_t
3556
+
3557
+ cdio_get_track_lba
3558
+ Get the starting LBA for track number
3559
+ i_track in p_cdio. Track numbers usually start at something
3560
+ greater than 0, usually 1.
3561
+
3562
+ The 'leadout' track is specified either by
3563
+ using i_track CDIO_CDROM_LEADOUT_TRACK or the total tracks+1.
3564
+
3565
+ @param p_cdio object to get information from
3566
+ @param i_track the track number we want the LSN for
3567
+ @return the starting LBA or CDIO_INVALID_LBA on error..
3568
+ */
3093
3569
  SWIGINTERN VALUE
3094
3570
  _wrap_get_track_lba(int argc, VALUE *argv, VALUE self) {
3095
3571
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3106,12 +3582,12 @@ _wrap_get_track_lba(int argc, VALUE *argv, VALUE self) {
3106
3582
  }
3107
3583
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3108
3584
  if (!SWIG_IsOK(res1)) {
3109
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_track_lba" "', argument " "1"" of type '" "CdIo_t const *""'");
3585
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_track_lba", 1, argv[0] ));
3110
3586
  }
3111
3587
  arg1 = (CdIo_t *)(argp1);
3112
3588
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
3113
3589
  if (!SWIG_IsOK(ecode2)) {
3114
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_get_track_lba" "', argument " "2"" of type '" "track_t""'");
3590
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "track_t","cdio_get_track_lba", 2, argv[1] ));
3115
3591
  }
3116
3592
  arg2 = (track_t)(val2);
3117
3593
  result = (lba_t)cdio_get_track_lba((CdIo_t const *)arg1,arg2);
@@ -3122,6 +3598,23 @@ fail:
3122
3598
  }
3123
3599
 
3124
3600
 
3601
+
3602
+ /*
3603
+ Document-method: Rubycdio.get_track_lsn
3604
+
3605
+ call-seq:
3606
+ get_track_lsn(p_cdio, i_track) -> lsn_t
3607
+
3608
+ cdio_get_track_lsn (cdio, track)->int
3609
+
3610
+ Return the starting LSN for track number.
3611
+ Track numbers usually start at something greater than 0, usually 1.
3612
+
3613
+ The 'leadout' track is specified either by
3614
+ using i_track pycdio.CDROM_LEADOUT_TRACK or the total tracks+1.
3615
+
3616
+ pycdio.INVALID_LSN is returned on error..
3617
+ */
3125
3618
  SWIGINTERN VALUE
3126
3619
  _wrap_get_track_lsn(int argc, VALUE *argv, VALUE self) {
3127
3620
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3138,12 +3631,12 @@ _wrap_get_track_lsn(int argc, VALUE *argv, VALUE self) {
3138
3631
  }
3139
3632
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3140
3633
  if (!SWIG_IsOK(res1)) {
3141
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_track_lsn" "', argument " "1"" of type '" "CdIo_t const *""'");
3634
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_track_lsn", 1, argv[0] ));
3142
3635
  }
3143
3636
  arg1 = (CdIo_t *)(argp1);
3144
3637
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
3145
3638
  if (!SWIG_IsOK(ecode2)) {
3146
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_get_track_lsn" "', argument " "2"" of type '" "track_t""'");
3639
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "track_t","cdio_get_track_lsn", 2, argv[1] ));
3147
3640
  }
3148
3641
  arg2 = (track_t)(val2);
3149
3642
  result = (lsn_t)cdio_get_track_lsn((CdIo_t const *)arg1,arg2);
@@ -3154,6 +3647,24 @@ fail:
3154
3647
  }
3155
3648
 
3156
3649
 
3650
+
3651
+ /*
3652
+ Document-method: Rubycdio.get_track_msf
3653
+
3654
+ call-seq:
3655
+ get_track_msf(p_cdio, i_track) -> char
3656
+
3657
+ get_track_msf(cdio,track)->string
3658
+
3659
+ Return the starting MSF (minutes/secs/frames) for track number
3660
+ track. Track numbers usually start at something
3661
+ greater than 0, usually 1.
3662
+
3663
+ The 'leadout' track is specified either by
3664
+ using i_track CDIO_CDROM_LEADOUT_TRACK or the total tracks+1.
3665
+
3666
+ @return string mm:ss:ff if all good, or string 'error' on error..
3667
+ */
3157
3668
  SWIGINTERN VALUE
3158
3669
  _wrap_get_track_msf(int argc, VALUE *argv, VALUE self) {
3159
3670
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3170,12 +3681,12 @@ _wrap_get_track_msf(int argc, VALUE *argv, VALUE self) {
3170
3681
  }
3171
3682
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3172
3683
  if (!SWIG_IsOK(res1)) {
3173
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_track_msf" "', argument " "1"" of type '" "CdIo_t const *""'");
3684
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","get_track_msf", 1, argv[0] ));
3174
3685
  }
3175
3686
  arg1 = (CdIo_t *)(argp1);
3176
3687
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
3177
3688
  if (!SWIG_IsOK(ecode2)) {
3178
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_track_msf" "', argument " "2"" of type '" "track_t""'");
3689
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "track_t","get_track_msf", 2, argv[1] ));
3179
3690
  }
3180
3691
  arg2 = (track_t)(val2);
3181
3692
  result = (char *)get_track_msf((CdIo_t const *)arg1,arg2);
@@ -3186,6 +3697,18 @@ fail:
3186
3697
  }
3187
3698
 
3188
3699
 
3700
+
3701
+ /*
3702
+ Document-method: Rubycdio.get_track_preemphasis
3703
+
3704
+ call-seq:
3705
+ get_track_preemphasis(p_cdio, i_track) -> track_flag_t
3706
+
3707
+ cdio_get_track_preemphasis(cdio, track)
3708
+
3709
+ Get linear preemphasis status on an audio track.
3710
+ This is not meaningful if not an audio track?.
3711
+ */
3189
3712
  SWIGINTERN VALUE
3190
3713
  _wrap_get_track_preemphasis(int argc, VALUE *argv, VALUE self) {
3191
3714
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3202,12 +3725,12 @@ _wrap_get_track_preemphasis(int argc, VALUE *argv, VALUE self) {
3202
3725
  }
3203
3726
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3204
3727
  if (!SWIG_IsOK(res1)) {
3205
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_track_preemphasis" "', argument " "1"" of type '" "CdIo_t const *""'");
3728
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_track_preemphasis", 1, argv[0] ));
3206
3729
  }
3207
3730
  arg1 = (CdIo_t *)(argp1);
3208
3731
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
3209
3732
  if (!SWIG_IsOK(ecode2)) {
3210
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_get_track_preemphasis" "', argument " "2"" of type '" "track_t""'");
3733
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "track_t","cdio_get_track_preemphasis", 2, argv[1] ));
3211
3734
  }
3212
3735
  arg2 = (track_t)(val2);
3213
3736
  result = (track_flag_t)cdio_get_track_preemphasis((CdIo_t const *)arg1,arg2);
@@ -3218,6 +3741,22 @@ fail:
3218
3741
  }
3219
3742
 
3220
3743
 
3744
+
3745
+ /*
3746
+ Document-method: Rubycdio.get_track_sec_count
3747
+
3748
+ call-seq:
3749
+ get_track_sec_count(p_cdio, i_track) -> unsigned int
3750
+
3751
+ get_track_sec_count(cdio, track)->int
3752
+
3753
+ Get the number of sectors between this track an the next. This
3754
+ includes any pregap sectors before the start of the next track.
3755
+ Track numbers usually start at something
3756
+ greater than 0, usually 1.
3757
+
3758
+ 0 is returned if there is an error..
3759
+ */
3221
3760
  SWIGINTERN VALUE
3222
3761
  _wrap_get_track_sec_count(int argc, VALUE *argv, VALUE self) {
3223
3762
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3234,12 +3773,12 @@ _wrap_get_track_sec_count(int argc, VALUE *argv, VALUE self) {
3234
3773
  }
3235
3774
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3236
3775
  if (!SWIG_IsOK(res1)) {
3237
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_track_sec_count" "', argument " "1"" of type '" "CdIo_t const *""'");
3776
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_track_sec_count", 1, argv[0] ));
3238
3777
  }
3239
3778
  arg1 = (CdIo_t *)(argp1);
3240
3779
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
3241
3780
  if (!SWIG_IsOK(ecode2)) {
3242
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_get_track_sec_count" "', argument " "2"" of type '" "track_t""'");
3781
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "track_t","cdio_get_track_sec_count", 2, argv[1] ));
3243
3782
  }
3244
3783
  arg2 = (track_t)(val2);
3245
3784
  result = (unsigned int)cdio_get_track_sec_count((CdIo_t const *)arg1,arg2);
@@ -3250,6 +3789,22 @@ fail:
3250
3789
  }
3251
3790
 
3252
3791
 
3792
+
3793
+ /*
3794
+ Document-method: Rubycdio.close_tray
3795
+
3796
+ call-seq:
3797
+ close_tray(psz_drive, p_driver_id=DRIVER_UNKNOWN) -> driver_return_code_t
3798
+
3799
+ get_track_sec_count(cdio, track)->int
3800
+
3801
+ Get the number of sectors between this track an the next. This
3802
+ includes any pregap sectors before the start of the next track.
3803
+ Track numbers usually start at something
3804
+ greater than 0, usually 1.
3805
+
3806
+ 0 is returned if there is an error..
3807
+ */
3253
3808
  SWIGINTERN VALUE
3254
3809
  _wrap_close_tray(int argc, VALUE *argv, VALUE self) {
3255
3810
  char *arg1 = (char *) 0 ;
@@ -3271,13 +3826,13 @@ _wrap_close_tray(int argc, VALUE *argv, VALUE self) {
3271
3826
  }
3272
3827
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
3273
3828
  if (!SWIG_IsOK(res1)) {
3274
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "close_tray" "', argument " "1"" of type '" "char const *""'");
3829
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","close_tray", 1, argv[0] ));
3275
3830
  }
3276
3831
  arg1 = (char *)(buf1);
3277
3832
  if (argc > 1) {
3278
3833
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
3279
3834
  if (!SWIG_IsOK(ecode2)) {
3280
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "close_tray" "', argument " "2"" of type '" "driver_id_t""'");
3835
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "driver_id_t","close_tray", 2, argv[1] ));
3281
3836
  }
3282
3837
  arg2 = (driver_id_t)(val2);
3283
3838
  }
@@ -3297,6 +3852,18 @@ fail:
3297
3852
  }
3298
3853
 
3299
3854
 
3855
+
3856
+ /*
3857
+ Document-method: Rubycdio.close
3858
+
3859
+ call-seq:
3860
+ close(p_cdio)
3861
+
3862
+ destroy(p_cdio)
3863
+ Free resources associated with p_cdio. Call this when done using
3864
+ using CD reading/control operations for the current device.
3865
+ .
3866
+ */
3300
3867
  SWIGINTERN VALUE
3301
3868
  _wrap_close(int argc, VALUE *argv, VALUE self) {
3302
3869
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3308,7 +3875,7 @@ _wrap_close(int argc, VALUE *argv, VALUE self) {
3308
3875
  }
3309
3876
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3310
3877
  if (!SWIG_IsOK(res1)) {
3311
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_destroy" "', argument " "1"" of type '" "CdIo_t *""'");
3878
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","cdio_destroy", 1, argv[0] ));
3312
3879
  }
3313
3880
  arg1 = (CdIo_t *)(argp1);
3314
3881
  cdio_destroy(arg1);
@@ -3318,6 +3885,18 @@ fail:
3318
3885
  }
3319
3886
 
3320
3887
 
3888
+
3889
+ /*
3890
+ Document-method: Rubycdio.driver_errmsg
3891
+
3892
+ call-seq:
3893
+ driver_errmsg(drc) -> char
3894
+
3895
+ destroy(p_cdio)
3896
+ Free resources associated with p_cdio. Call this when done using
3897
+ using CD reading/control operations for the current device.
3898
+ .
3899
+ */
3321
3900
  SWIGINTERN VALUE
3322
3901
  _wrap_driver_errmsg(int argc, VALUE *argv, VALUE self) {
3323
3902
  driver_return_code_t arg1 ;
@@ -3331,7 +3910,7 @@ _wrap_driver_errmsg(int argc, VALUE *argv, VALUE self) {
3331
3910
  }
3332
3911
  ecode1 = SWIG_AsVal_long(argv[0], &val1);
3333
3912
  if (!SWIG_IsOK(ecode1)) {
3334
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "driver_errmsg" "', argument " "1"" of type '" "driver_return_code_t""'");
3913
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "driver_return_code_t","driver_errmsg", 1, argv[0] ));
3335
3914
  }
3336
3915
  arg1 = (driver_return_code_t)(val1);
3337
3916
  result = (char *)driver_errmsg(arg1);
@@ -3342,6 +3921,18 @@ fail:
3342
3921
  }
3343
3922
 
3344
3923
 
3924
+
3925
+ /*
3926
+ Document-method: Rubycdio.eject_media
3927
+
3928
+ call-seq:
3929
+ eject_media(p_cdio) -> driver_return_code_t
3930
+
3931
+ eject_media(cdio)->return_code
3932
+
3933
+ Eject media in CD drive if there is a routine to do so.
3934
+ .
3935
+ */
3345
3936
  SWIGINTERN VALUE
3346
3937
  _wrap_eject_media(int argc, VALUE *argv, VALUE self) {
3347
3938
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3355,7 +3946,7 @@ _wrap_eject_media(int argc, VALUE *argv, VALUE self) {
3355
3946
  }
3356
3947
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3357
3948
  if (!SWIG_IsOK(res1)) {
3358
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eject_media" "', argument " "1"" of type '" "CdIo_t *""'");
3949
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","eject_media", 1, argv[0] ));
3359
3950
  }
3360
3951
  arg1 = (CdIo_t *)(argp1);
3361
3952
  result = (driver_return_code_t)eject_media(arg1);
@@ -3366,6 +3957,19 @@ fail:
3366
3957
  }
3367
3958
 
3368
3959
 
3960
+
3961
+ /*
3962
+ Document-method: Rubycdio.eject_media_drive
3963
+
3964
+ call-seq:
3965
+ eject_media_drive(psz_drive=nil) -> driver_return_code_t
3966
+
3967
+ eject_media_drive(drive=nil)->return_code
3968
+ Eject media in CD drive if there is a routine to do so.
3969
+
3970
+ psz_drive: the name of the device to be acted upon.
3971
+ The operation status is returned..
3972
+ */
3369
3973
  SWIGINTERN VALUE
3370
3974
  _wrap_eject_media_drive(int argc, VALUE *argv, VALUE self) {
3371
3975
  char *arg1 = (char *) NULL ;
@@ -3381,7 +3985,7 @@ _wrap_eject_media_drive(int argc, VALUE *argv, VALUE self) {
3381
3985
  if (argc > 0) {
3382
3986
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
3383
3987
  if (!SWIG_IsOK(res1)) {
3384
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_eject_media_drive" "', argument " "1"" of type '" "char const *""'");
3988
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdio_eject_media_drive", 1, argv[0] ));
3385
3989
  }
3386
3990
  arg1 = (char *)(buf1);
3387
3991
  }
@@ -3395,6 +3999,17 @@ fail:
3395
3999
  }
3396
4000
 
3397
4001
 
4002
+
4003
+ /*
4004
+ Document-method: Rubycdio.get_arg
4005
+
4006
+ call-seq:
4007
+ get_arg(p_cdio, key) -> char
4008
+
4009
+ get_arg(p_cdio, key)->string
4010
+
4011
+ Get the value associatied with key..
4012
+ */
3398
4013
  SWIGINTERN VALUE
3399
4014
  _wrap_get_arg(int argc, VALUE *argv, VALUE self) {
3400
4015
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3412,12 +4027,12 @@ _wrap_get_arg(int argc, VALUE *argv, VALUE self) {
3412
4027
  }
3413
4028
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3414
4029
  if (!SWIG_IsOK(res1)) {
3415
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_arg" "', argument " "1"" of type '" "CdIo_t const *""'");
4030
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_arg", 1, argv[0] ));
3416
4031
  }
3417
4032
  arg1 = (CdIo_t *)(argp1);
3418
4033
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
3419
4034
  if (!SWIG_IsOK(res2)) {
3420
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdio_get_arg" "', argument " "2"" of type '" "char const []""'");
4035
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const []","cdio_get_arg", 2, argv[1] ));
3421
4036
  }
3422
4037
  arg2 = (char *)(buf2);
3423
4038
  result = (char *)cdio_get_arg((CdIo_t const *)arg1,(char const (*))arg2);
@@ -3430,6 +4045,23 @@ fail:
3430
4045
  }
3431
4046
 
3432
4047
 
4048
+
4049
+ /*
4050
+ Document-method: Rubycdio.get_device
4051
+
4052
+ call-seq:
4053
+ get_device(p_cdio=nil) -> char
4054
+
4055
+ get_device(cdio)->str
4056
+
4057
+ Get the CD device associated with cdio.
4058
+ If cdio is NULL (we haven't initialized a specific device driver),
4059
+ then find a suitable one and return the default device for that.
4060
+
4061
+ In some situations of drivers or OS's we can't find a CD device if
4062
+ there is no media in it and it is possible for this routine to return
4063
+ nil even though there may be a hardware CD-ROM..
4064
+ */
3433
4065
  SWIGINTERN VALUE
3434
4066
  _wrap_get_device(int argc, VALUE *argv, VALUE self) {
3435
4067
  CdIo_t *arg1 = (CdIo_t *) NULL ;
@@ -3444,7 +4076,7 @@ _wrap_get_device(int argc, VALUE *argv, VALUE self) {
3444
4076
  if (argc > 0) {
3445
4077
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3446
4078
  if (!SWIG_IsOK(res1)) {
3447
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_default_device" "', argument " "1"" of type '" "CdIo_t const *""'");
4079
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_default_device", 1, argv[0] ));
3448
4080
  }
3449
4081
  arg1 = (CdIo_t *)(argp1);
3450
4082
  }
@@ -3457,6 +4089,20 @@ fail:
3457
4089
  }
3458
4090
 
3459
4091
 
4092
+
4093
+ /*
4094
+ Document-method: Rubycdio.get_default_device_driver
4095
+
4096
+ call-seq:
4097
+ get_default_device_driver(p_driver_id) -> char
4098
+
4099
+ get_default_device_driver(driver_id=nil)->[device, driver]
4100
+ Return a string containing the default CD device if none is specified.
4101
+ if p_driver_id is DRIVER_UNKNOWN or DRIVER_DEVICE then find a suitable
4102
+ one set the default device for that.
4103
+
4104
+ nil is returned as the device if we couldn't get a default device..
4105
+ */
3460
4106
  SWIGINTERN VALUE
3461
4107
  _wrap_get_default_device_driver(int argc, VALUE *argv, VALUE self) {
3462
4108
  driver_id_t arg1 ;
@@ -3474,7 +4120,7 @@ _wrap_get_default_device_driver(int argc, VALUE *argv, VALUE self) {
3474
4120
  }
3475
4121
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
3476
4122
  if (!SWIG_IsOK(ecode1)) {
3477
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_default_device_driver" "', argument " "1"" of type '" "driver_id_t""'");
4123
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "driver_id_t","get_default_device_driver", 1, argv[0] ));
3478
4124
  }
3479
4125
  arg1 = (driver_id_t)(val1);
3480
4126
  result = (char *)get_default_device_driver(arg1,arg2);
@@ -3492,6 +4138,20 @@ fail:
3492
4138
  }
3493
4139
 
3494
4140
 
4141
+
4142
+ /*
4143
+ Document-method: Rubycdio.get_devices
4144
+
4145
+ call-seq:
4146
+ get_devices(driver_id) -> DeviceList_t
4147
+
4148
+ get_default_device_driver(driver_id=nil)->[device, driver]
4149
+ Return a string containing the default CD device if none is specified.
4150
+ if p_driver_id is DRIVER_UNKNOWN or DRIVER_DEVICE then find a suitable
4151
+ one set the default device for that.
4152
+
4153
+ nil is returned as the device if we couldn't get a default device..
4154
+ */
3495
4155
  SWIGINTERN VALUE
3496
4156
  _wrap_get_devices(int argc, VALUE *argv, VALUE self) {
3497
4157
  driver_id_t arg1 ;
@@ -3505,7 +4165,7 @@ _wrap_get_devices(int argc, VALUE *argv, VALUE self) {
3505
4165
  }
3506
4166
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
3507
4167
  if (!SWIG_IsOK(ecode1)) {
3508
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdio_get_devices" "', argument " "1"" of type '" "driver_id_t""'");
4168
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "driver_id_t","cdio_get_devices", 1, argv[0] ));
3509
4169
  }
3510
4170
  arg1 = (driver_id_t)(val1);
3511
4171
  result = (DeviceList_t)cdio_get_devices(arg1);
@@ -3530,6 +4190,20 @@ fail:
3530
4190
  }
3531
4191
 
3532
4192
 
4193
+
4194
+ /*
4195
+ Document-method: Rubycdio.get_devices_ret
4196
+
4197
+ call-seq:
4198
+ get_devices_ret(driver_id) -> DeviceList_t
4199
+
4200
+ get_default_device_driver(driver_id=nil)->[device, driver]
4201
+ Return a string containing the default CD device if none is specified.
4202
+ if p_driver_id is DRIVER_UNKNOWN or DRIVER_DEVICE then find a suitable
4203
+ one set the default device for that.
4204
+
4205
+ nil is returned as the device if we couldn't get a default device..
4206
+ */
3533
4207
  SWIGINTERN VALUE
3534
4208
  _wrap_get_devices_ret(int argc, VALUE *argv, VALUE self) {
3535
4209
  driver_id_t arg1 ;
@@ -3547,7 +4221,7 @@ _wrap_get_devices_ret(int argc, VALUE *argv, VALUE self) {
3547
4221
  }
3548
4222
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
3549
4223
  if (!SWIG_IsOK(ecode1)) {
3550
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_devices_ret" "', argument " "1"" of type '" "driver_id_t""'");
4224
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "driver_id_t","get_devices_ret", 1, argv[0] ));
3551
4225
  }
3552
4226
  arg1 = (driver_id_t)(val1);
3553
4227
  result = (DeviceList_t)get_devices_ret(arg1,arg2);
@@ -3578,6 +4252,29 @@ fail:
3578
4252
  }
3579
4253
 
3580
4254
 
4255
+
4256
+ /*
4257
+ Document-method: Rubycdio.get_devices_with_cap
4258
+
4259
+ call-seq:
4260
+ get_devices_with_cap(capabilities, b_any) -> DeviceList_t
4261
+
4262
+ get_devices_with_cap(capabilities, any)->[device1, device2...]
4263
+ Get an array of device names in search_devices that have at least
4264
+ the capabilities listed by the capabities parameter.
4265
+
4266
+ If any is False then every capability listed in the
4267
+ extended portion of capabilities (i.e. not the basic filesystem)
4268
+ must be satisified. If any is True, then if any of the
4269
+ capabilities matches, we call that a success.
4270
+
4271
+ To find a CD-drive of any type, use the mask CDIO_FS_MATCH_ALL.
4272
+
4273
+ The array of device names is returned or NULL if we couldn't get a
4274
+ default device. It is also possible to return a non NULL but after
4275
+ dereferencing the the value is NULL. This also means nothing was
4276
+ found..
4277
+ */
3581
4278
  SWIGINTERN VALUE
3582
4279
  _wrap_get_devices_with_cap(int argc, VALUE *argv, VALUE self) {
3583
4280
  unsigned int arg1 ;
@@ -3594,12 +4291,12 @@ _wrap_get_devices_with_cap(int argc, VALUE *argv, VALUE self) {
3594
4291
  }
3595
4292
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
3596
4293
  if (!SWIG_IsOK(ecode1)) {
3597
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_devices_with_cap" "', argument " "1"" of type '" "unsigned int""'");
4294
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","get_devices_with_cap", 1, argv[0] ));
3598
4295
  }
3599
4296
  arg1 = (unsigned int)(val1);
3600
4297
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
3601
4298
  if (!SWIG_IsOK(ecode2)) {
3602
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_devices_with_cap" "', argument " "2"" of type '" "bool""'");
4299
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","get_devices_with_cap", 2, argv[1] ));
3603
4300
  }
3604
4301
  arg2 = (bool)(val2);
3605
4302
  result = (DeviceList_t)get_devices_with_cap(arg1,arg2);
@@ -3624,6 +4321,18 @@ fail:
3624
4321
  }
3625
4322
 
3626
4323
 
4324
+
4325
+ /*
4326
+ Document-method: Rubycdio.get_devices_with_cap_ret
4327
+
4328
+ call-seq:
4329
+ get_devices_with_cap_ret(capabilities, b_any) -> DeviceList_t
4330
+
4331
+ Like cdio_get_devices_with_cap but we return the driver we found
4332
+ as well. This is because often one wants to search for kind of drive
4333
+ and then *open* it afterwards. Giving the driver back facilitates this,
4334
+ and speeds things up for libcdio as well..
4335
+ */
3627
4336
  SWIGINTERN VALUE
3628
4337
  _wrap_get_devices_with_cap_ret(int argc, VALUE *argv, VALUE self) {
3629
4338
  unsigned int arg1 ;
@@ -3644,12 +4353,12 @@ _wrap_get_devices_with_cap_ret(int argc, VALUE *argv, VALUE self) {
3644
4353
  }
3645
4354
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
3646
4355
  if (!SWIG_IsOK(ecode1)) {
3647
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_devices_with_cap_ret" "', argument " "1"" of type '" "unsigned int""'");
4356
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","get_devices_with_cap_ret", 1, argv[0] ));
3648
4357
  }
3649
4358
  arg1 = (unsigned int)(val1);
3650
4359
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
3651
4360
  if (!SWIG_IsOK(ecode2)) {
3652
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_devices_with_cap_ret" "', argument " "2"" of type '" "bool""'");
4361
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","get_devices_with_cap_ret", 2, argv[1] ));
3653
4362
  }
3654
4363
  arg2 = (bool)(val2);
3655
4364
  result = (DeviceList_t)get_devices_with_cap_ret(arg1,arg2,arg3);
@@ -3680,6 +4389,22 @@ fail:
3680
4389
  }
3681
4390
 
3682
4391
 
4392
+
4393
+ /*
4394
+ Document-method: Rubycdio.get_drive_cap
4395
+
4396
+ call-seq:
4397
+ get_drive_cap(p_cdio)
4398
+ get_drive_cap(device=nil)
4399
+
4400
+ get_drive_cap()->(read_cap, write_cap, misc_cap)
4401
+
4402
+ Get drive capabilities of device.
4403
+
4404
+ In some situations of drivers or OS's we can't find a CD device if
4405
+ there is no media in it. In this situation capabilities will show up as
4406
+ empty even though there is a hardware CD-ROM..
4407
+ */
3683
4408
  SWIGINTERN VALUE
3684
4409
  _wrap_get_drive_cap__SWIG_0(int argc, VALUE *argv, VALUE self) {
3685
4410
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3704,10 +4429,11 @@ _wrap_get_drive_cap__SWIG_0(int argc, VALUE *argv, VALUE self) {
3704
4429
  }
3705
4430
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3706
4431
  if (!SWIG_IsOK(res1)) {
3707
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_drive_cap" "', argument " "1"" of type '" "CdIo_t const *""'");
4432
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_drive_cap", 1, argv[0] ));
3708
4433
  }
3709
4434
  arg1 = (CdIo_t *)(argp1);
3710
4435
  cdio_get_drive_cap((CdIo_t const *)arg1,arg2,arg3,arg4);
4436
+ vresult = rb_ary_new();
3711
4437
  if (SWIG_IsTmpObj(res2)) {
3712
4438
  vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg2)));
3713
4439
  } else {
@@ -3758,11 +4484,12 @@ _wrap_get_drive_cap__SWIG_1(int argc, VALUE *argv, VALUE self) {
3758
4484
  if (argc > 0) {
3759
4485
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
3760
4486
  if (!SWIG_IsOK(res1)) {
3761
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_drive_cap_dev" "', argument " "1"" of type '" "char const *""'");
4487
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdio_get_drive_cap_dev", 1, argv[0] ));
3762
4488
  }
3763
4489
  arg1 = (char *)(buf1);
3764
4490
  }
3765
4491
  cdio_get_drive_cap_dev((char const *)arg1,arg2,arg3,arg4);
4492
+ vresult = rb_ary_new();
3766
4493
  if (SWIG_IsTmpObj(res2)) {
3767
4494
  vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg2)));
3768
4495
  } else {
@@ -3796,7 +4523,7 @@ SWIGINTERN VALUE _wrap_get_drive_cap(int nargs, VALUE *args, VALUE self) {
3796
4523
 
3797
4524
  argc = nargs;
3798
4525
  if (argc > 1) SWIG_fail;
3799
- for (ii = 0; (ii < argc); ii++) {
4526
+ for (ii = 0; (ii < argc); ++ii) {
3800
4527
  argv[ii] = args[ii];
3801
4528
  }
3802
4529
  if ((argc >= 0) && (argc <= 1)) {
@@ -3821,11 +4548,26 @@ SWIGINTERN VALUE _wrap_get_drive_cap(int nargs, VALUE *args, VALUE self) {
3821
4548
  }
3822
4549
 
3823
4550
  fail:
3824
- rb_raise(rb_eArgError, "No matching function for overloaded 'get_drive_cap'");
4551
+ Ruby_Format_OverloadedError( argc, 1, "get_drive_cap",
4552
+ " void get_drive_cap(CdIo_t const *p_cdio, unsigned int *p_read_cap, unsigned int *p_write_cap, unsigned int *p_misc_cap)\n"
4553
+ " void get_drive_cap(char const *device, unsigned int *p_read_cap, unsigned int *p_write_cap, unsigned int *p_misc_cap)\n");
4554
+
3825
4555
  return Qnil;
3826
4556
  }
3827
4557
 
3828
4558
 
4559
+
4560
+ /*
4561
+ Document-method: Rubycdio.get_driver_name
4562
+
4563
+ call-seq:
4564
+ get_driver_name(p_cdio) -> char
4565
+
4566
+ get_driver_name(cdio)-> string
4567
+
4568
+ return a string containing the name of the driver in use.
4569
+ .
4570
+ */
3829
4571
  SWIGINTERN VALUE
3830
4572
  _wrap_get_driver_name(int argc, VALUE *argv, VALUE self) {
3831
4573
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3839,7 +4581,7 @@ _wrap_get_driver_name(int argc, VALUE *argv, VALUE self) {
3839
4581
  }
3840
4582
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3841
4583
  if (!SWIG_IsOK(res1)) {
3842
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_driver_name" "', argument " "1"" of type '" "CdIo_t const *""'");
4584
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_driver_name", 1, argv[0] ));
3843
4585
  }
3844
4586
  arg1 = (CdIo_t *)(argp1);
3845
4587
  result = (char *)cdio_get_driver_name((CdIo_t const *)arg1);
@@ -3850,6 +4592,19 @@ fail:
3850
4592
  }
3851
4593
 
3852
4594
 
4595
+
4596
+ /*
4597
+ Document-method: Rubycdio.get_driver_id
4598
+
4599
+ call-seq:
4600
+ get_driver_id(p_cdio) -> driver_id_t
4601
+
4602
+ get_driver_id(cdio)-> int
4603
+
4604
+ Return the driver id of the driver in use.
4605
+ if cdio has not been initialized or is nil,
4606
+ return pycdio.DRIVER_UNKNOWN..
4607
+ */
3853
4608
  SWIGINTERN VALUE
3854
4609
  _wrap_get_driver_id(int argc, VALUE *argv, VALUE self) {
3855
4610
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3863,7 +4618,7 @@ _wrap_get_driver_id(int argc, VALUE *argv, VALUE self) {
3863
4618
  }
3864
4619
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3865
4620
  if (!SWIG_IsOK(res1)) {
3866
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_driver_id" "', argument " "1"" of type '" "CdIo_t const *""'");
4621
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_driver_id", 1, argv[0] ));
3867
4622
  }
3868
4623
  arg1 = (CdIo_t *)(argp1);
3869
4624
  result = (driver_id_t)cdio_get_driver_id((CdIo_t const *)arg1);
@@ -3874,6 +4629,19 @@ fail:
3874
4629
  }
3875
4630
 
3876
4631
 
4632
+
4633
+ /*
4634
+ Document-method: Rubycdio.get_last_session
4635
+
4636
+ call-seq:
4637
+ get_last_session(p_cdio) -> driver_return_code_t
4638
+
4639
+ get_driver_id(cdio)-> int
4640
+
4641
+ Return the driver id of the driver in use.
4642
+ if cdio has not been initialized or is nil,
4643
+ return pycdio.DRIVER_UNKNOWN..
4644
+ */
3877
4645
  SWIGINTERN VALUE
3878
4646
  _wrap_get_last_session(int argc, VALUE *argv, VALUE self) {
3879
4647
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3891,7 +4659,7 @@ _wrap_get_last_session(int argc, VALUE *argv, VALUE self) {
3891
4659
  }
3892
4660
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3893
4661
  if (!SWIG_IsOK(res1)) {
3894
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_last_session" "', argument " "1"" of type '" "CdIo_t *""'");
4662
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","cdio_get_last_session", 1, argv[0] ));
3895
4663
  }
3896
4664
  arg1 = (CdIo_t *)(argp1);
3897
4665
  result = (driver_return_code_t)cdio_get_last_session(arg1,arg2);
@@ -3908,6 +4676,18 @@ fail:
3908
4676
  }
3909
4677
 
3910
4678
 
4679
+
4680
+ /*
4681
+ Document-method: Rubycdio.have_driver
4682
+
4683
+ call-seq:
4684
+ have_driver(driver_id) -> int
4685
+
4686
+ have_driver(driver_id) -> int
4687
+
4688
+ Return 1 if we have driver driver_id, 0 if not and -1
4689
+ if driver id is out of range..
4690
+ */
3911
4691
  SWIGINTERN VALUE
3912
4692
  _wrap_have_driver(int argc, VALUE *argv, VALUE self) {
3913
4693
  unsigned int arg1 ;
@@ -3921,7 +4701,7 @@ _wrap_have_driver(int argc, VALUE *argv, VALUE self) {
3921
4701
  }
3922
4702
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
3923
4703
  if (!SWIG_IsOK(ecode1)) {
3924
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "have_driver" "', argument " "1"" of type '" "unsigned int""'");
4704
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","have_driver", 1, argv[0] ));
3925
4705
  }
3926
4706
  arg1 = (unsigned int)(val1);
3927
4707
  result = (int)have_driver(arg1);
@@ -3932,6 +4712,16 @@ fail:
3932
4712
  }
3933
4713
 
3934
4714
 
4715
+
4716
+ /*
4717
+ Document-method: Rubycdio.ATAPI?
4718
+
4719
+ call-seq:
4720
+ ATAPI?(p_cdio) -> bool
4721
+
4722
+ ATAPI?(CdIo_t *p_cdio)->bool
4723
+ return True if CD-ROM understand ATAPI commands..
4724
+ */
3935
4725
  SWIGINTERN VALUE
3936
4726
  _wrap_ATAPIq___(int argc, VALUE *argv, VALUE self) {
3937
4727
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -3945,7 +4735,7 @@ _wrap_ATAPIq___(int argc, VALUE *argv, VALUE self) {
3945
4735
  }
3946
4736
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
3947
4737
  if (!SWIG_IsOK(res1)) {
3948
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "have_ATAPI" "', argument " "1"" of type '" "CdIo_t *""'");
4738
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","have_ATAPI", 1, argv[0] ));
3949
4739
  }
3950
4740
  arg1 = (CdIo_t *)(argp1);
3951
4741
  result = (bool)have_ATAPI(arg1);
@@ -3956,6 +4746,21 @@ fail:
3956
4746
  }
3957
4747
 
3958
4748
 
4749
+
4750
+ /*
4751
+ Document-method: Rubycdio.is_binfile
4752
+
4753
+ call-seq:
4754
+ is_binfile(bin_name) -> buf_t
4755
+
4756
+ is_binfile(binfile_name)->cue_name
4757
+
4758
+ Determine if binfile_name is the BIN file part of a CDRWIN CD disk
4759
+ image.
4760
+
4761
+ Return the corresponding CUE file if bin_name is a BIN file or
4762
+ nil if not a BIN file..
4763
+ */
3959
4764
  SWIGINTERN VALUE
3960
4765
  _wrap_is_binfile(int argc, VALUE *argv, VALUE self) {
3961
4766
  char *arg1 = (char *) 0 ;
@@ -3970,7 +4775,7 @@ _wrap_is_binfile(int argc, VALUE *argv, VALUE self) {
3970
4775
  }
3971
4776
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
3972
4777
  if (!SWIG_IsOK(res1)) {
3973
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_is_binfile" "', argument " "1"" of type '" "char const *""'");
4778
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdio_is_binfile", 1, argv[0] ));
3974
4779
  }
3975
4780
  arg1 = (char *)(buf1);
3976
4781
  result = (buf_t)cdio_is_binfile((char const *)arg1);
@@ -3983,6 +4788,21 @@ fail:
3983
4788
  }
3984
4789
 
3985
4790
 
4791
+
4792
+ /*
4793
+ Document-method: Rubycdio.is_cuefile
4794
+
4795
+ call-seq:
4796
+ is_cuefile(cue_name) -> buf_t
4797
+
4798
+ is_cuefile(cuefile_name)->bin_name
4799
+
4800
+ Determine if cuefile_name is the CUE file part of a CDRWIN CD disk
4801
+ image.
4802
+
4803
+ Return the corresponding BIN file if bin_name is a CUE file or
4804
+ nil if not a CUE file..
4805
+ */
3986
4806
  SWIGINTERN VALUE
3987
4807
  _wrap_is_cuefile(int argc, VALUE *argv, VALUE self) {
3988
4808
  char *arg1 = (char *) 0 ;
@@ -3997,7 +4817,7 @@ _wrap_is_cuefile(int argc, VALUE *argv, VALUE self) {
3997
4817
  }
3998
4818
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
3999
4819
  if (!SWIG_IsOK(res1)) {
4000
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_is_cuefile" "', argument " "1"" of type '" "char const *""'");
4820
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdio_is_cuefile", 1, argv[0] ));
4001
4821
  }
4002
4822
  arg1 = (char *)(buf1);
4003
4823
  result = (buf_t)cdio_is_cuefile((char const *)arg1);
@@ -4010,6 +4830,21 @@ fail:
4010
4830
  }
4011
4831
 
4012
4832
 
4833
+
4834
+ /*
4835
+ Document-method: Rubycdio.cdio_is_device
4836
+
4837
+ call-seq:
4838
+ cdio_is_device(psz_source, driver_id=DRIVER_UNKNOWN) -> bool
4839
+
4840
+ is_cuefile(cuefile_name)->bin_name
4841
+
4842
+ Determine if cuefile_name is the CUE file part of a CDRWIN CD disk
4843
+ image.
4844
+
4845
+ Return the corresponding BIN file if bin_name is a CUE file or
4846
+ nil if not a CUE file..
4847
+ */
4013
4848
  SWIGINTERN VALUE
4014
4849
  _wrap_cdio_is_device(int argc, VALUE *argv, VALUE self) {
4015
4850
  char *arg1 = (char *) 0 ;
@@ -4027,13 +4862,13 @@ _wrap_cdio_is_device(int argc, VALUE *argv, VALUE self) {
4027
4862
  }
4028
4863
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
4029
4864
  if (!SWIG_IsOK(res1)) {
4030
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_is_device" "', argument " "1"" of type '" "char const *""'");
4865
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdio_is_device", 1, argv[0] ));
4031
4866
  }
4032
4867
  arg1 = (char *)(buf1);
4033
4868
  if (argc > 1) {
4034
4869
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
4035
4870
  if (!SWIG_IsOK(ecode2)) {
4036
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_is_device" "', argument " "2"" of type '" "driver_id_t""'");
4871
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "driver_id_t","cdio_is_device", 2, argv[1] ));
4037
4872
  }
4038
4873
  arg2 = (driver_id_t)(val2);
4039
4874
  }
@@ -4047,6 +4882,21 @@ fail:
4047
4882
  }
4048
4883
 
4049
4884
 
4885
+
4886
+ /*
4887
+ Document-method: Rubycdio.device?
4888
+
4889
+ call-seq:
4890
+ device?(psz_source, driver_id) -> bool
4891
+
4892
+ is_cuefile(cuefile_name)->bin_name
4893
+
4894
+ Determine if cuefile_name is the CUE file part of a CDRWIN CD disk
4895
+ image.
4896
+
4897
+ Return the corresponding BIN file if bin_name is a CUE file or
4898
+ nil if not a CUE file..
4899
+ */
4050
4900
  SWIGINTERN VALUE
4051
4901
  _wrap_deviceq___(int argc, VALUE *argv, VALUE self) {
4052
4902
  char *arg1 = (char *) 0 ;
@@ -4064,12 +4914,12 @@ _wrap_deviceq___(int argc, VALUE *argv, VALUE self) {
4064
4914
  }
4065
4915
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
4066
4916
  if (!SWIG_IsOK(res1)) {
4067
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_device" "', argument " "1"" of type '" "char const *""'");
4917
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","is_device", 1, argv[0] ));
4068
4918
  }
4069
4919
  arg1 = (char *)(buf1);
4070
4920
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
4071
4921
  if (!SWIG_IsOK(ecode2)) {
4072
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "is_device" "', argument " "2"" of type '" "driver_id_t""'");
4922
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "driver_id_t","is_device", 2, argv[1] ));
4073
4923
  }
4074
4924
  arg2 = (driver_id_t)(val2);
4075
4925
  result = (bool)is_device((char const *)arg1,arg2);
@@ -4082,6 +4932,17 @@ fail:
4082
4932
  }
4083
4933
 
4084
4934
 
4935
+
4936
+ /*
4937
+ Document-method: Rubycdio.nrg?
4938
+
4939
+ call-seq:
4940
+ nrg?(nrg_name) -> bool
4941
+
4942
+ nrg?(cue_name)->bool
4943
+
4944
+ Determine if nrg_name is a Nero CD disc image.
4945
+ */
4085
4946
  SWIGINTERN VALUE
4086
4947
  _wrap_nrgq___(int argc, VALUE *argv, VALUE self) {
4087
4948
  char *arg1 = (char *) 0 ;
@@ -4096,7 +4957,7 @@ _wrap_nrgq___(int argc, VALUE *argv, VALUE self) {
4096
4957
  }
4097
4958
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
4098
4959
  if (!SWIG_IsOK(res1)) {
4099
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_is_nrg" "', argument " "1"" of type '" "char const *""'");
4960
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdio_is_nrg", 1, argv[0] ));
4100
4961
  }
4101
4962
  arg1 = (char *)(buf1);
4102
4963
  result = (bool)cdio_is_nrg((char const *)arg1);
@@ -4109,6 +4970,17 @@ fail:
4109
4970
  }
4110
4971
 
4111
4972
 
4973
+
4974
+ /*
4975
+ Document-method: Rubycdio.tocfile?
4976
+
4977
+ call-seq:
4978
+ tocfile?(tocfile_name) -> bool
4979
+
4980
+ tocfile?(tocfile_name)->bool
4981
+
4982
+ Determine if tocfile_name is a cdrdao CD disc image.
4983
+ */
4112
4984
  SWIGINTERN VALUE
4113
4985
  _wrap_tocfileq___(int argc, VALUE *argv, VALUE self) {
4114
4986
  char *arg1 = (char *) 0 ;
@@ -4123,7 +4995,7 @@ _wrap_tocfileq___(int argc, VALUE *argv, VALUE self) {
4123
4995
  }
4124
4996
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
4125
4997
  if (!SWIG_IsOK(res1)) {
4126
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_is_tocfile" "', argument " "1"" of type '" "char const *""'");
4998
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdio_is_tocfile", 1, argv[0] ));
4127
4999
  }
4128
5000
  arg1 = (char *)(buf1);
4129
5001
  result = (bool)cdio_is_tocfile((char const *)arg1);
@@ -4136,6 +5008,19 @@ fail:
4136
5008
  }
4137
5009
 
4138
5010
 
5011
+
5012
+ /*
5013
+ Document-method: Rubycdio.get_media_changed
5014
+
5015
+ call-seq:
5016
+ get_media_changed(p_cdio) -> int
5017
+
5018
+ get_media_changed(cdio) -> int
5019
+
5020
+ Find out if media has changed since the last call.
5021
+ Return 1 if media has changed since last call, 0 if not. Error
5022
+ return codes are the same as driver_return_code_t.
5023
+ */
4139
5024
  SWIGINTERN VALUE
4140
5025
  _wrap_get_media_changed(int argc, VALUE *argv, VALUE self) {
4141
5026
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -4149,7 +5034,7 @@ _wrap_get_media_changed(int argc, VALUE *argv, VALUE self) {
4149
5034
  }
4150
5035
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
4151
5036
  if (!SWIG_IsOK(res1)) {
4152
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_media_changed" "', argument " "1"" of type '" "CdIo_t *""'");
5037
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","cdio_get_media_changed", 1, argv[0] ));
4153
5038
  }
4154
5039
  arg1 = (CdIo_t *)(argp1);
4155
5040
  result = (int)cdio_get_media_changed(arg1);
@@ -4160,8 +5045,47 @@ fail:
4160
5045
  }
4161
5046
 
4162
5047
 
5048
+
5049
+ /*
5050
+ Document-class: Rubycdio::HWInfo_t
5051
+
5052
+ call-seq:
5053
+
5054
+
5055
+ get_media_changed(cdio) -> int
5056
+
5057
+ Find out if media has changed since the last call.
5058
+ Return 1 if media has changed since last call, 0 if not. Error
5059
+ return codes are the same as driver_return_code_t.
5060
+ */
4163
5061
  swig_class cHWInfo_t;
4164
5062
 
5063
+
5064
+ /*
5065
+ Document-method: Rubycdio::HWInfo_t.hw
5066
+
5067
+ call-seq:
5068
+ hw -> cdio_hwinfo_t
5069
+
5070
+ get_media_changed(cdio) -> int
5071
+
5072
+ Find out if media has changed since the last call.
5073
+ Return 1 if media has changed since last call, 0 if not. Error
5074
+ return codes are the same as driver_return_code_t.
5075
+ */
5076
+
5077
+ /*
5078
+ Document-method: Rubycdio::HWInfo_t.hw=
5079
+
5080
+ call-seq:
5081
+ hw=(x) -> cdio_hwinfo_t
5082
+
5083
+ get_media_changed(cdio) -> int
5084
+
5085
+ Find out if media has changed since the last call.
5086
+ Return 1 if media has changed since last call, 0 if not. Error
5087
+ return codes are the same as driver_return_code_t.
5088
+ */
4165
5089
  SWIGINTERN VALUE
4166
5090
  _wrap_HWInfo_t_hw_set(int argc, VALUE *argv, VALUE self) {
4167
5091
  HWInfo_t *arg1 = (HWInfo_t *) 0 ;
@@ -4176,16 +5100,16 @@ _wrap_HWInfo_t_hw_set(int argc, VALUE *argv, VALUE self) {
4176
5100
  }
4177
5101
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_HWInfo_t, 0 | 0 );
4178
5102
  if (!SWIG_IsOK(res1)) {
4179
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hw" "', argument " "1"" of type '" "HWInfo_t *""'");
5103
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "HWInfo_t *","hw", 1, self ));
4180
5104
  }
4181
5105
  arg1 = (HWInfo_t *)(argp1);
4182
5106
  {
4183
5107
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_cdio_hwinfo_t, 0 );
4184
5108
  if (!SWIG_IsOK(res2)) {
4185
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hw" "', argument " "2"" of type '" "cdio_hwinfo_t""'");
5109
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "cdio_hwinfo_t","hw", 2, argv[0] ));
4186
5110
  }
4187
5111
  if (!argp2) {
4188
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "hw" "', argument " "2"" of type '" "cdio_hwinfo_t""'");
5112
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "cdio_hwinfo_t","hw", 2, argv[0]));
4189
5113
  } else {
4190
5114
  arg2 = *((cdio_hwinfo_t *)(argp2));
4191
5115
  }
@@ -4211,7 +5135,7 @@ _wrap_HWInfo_t_hw_get(int argc, VALUE *argv, VALUE self) {
4211
5135
  }
4212
5136
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_HWInfo_t, 0 | 0 );
4213
5137
  if (!SWIG_IsOK(res1)) {
4214
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hw" "', argument " "1"" of type '" "HWInfo_t *""'");
5138
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "HWInfo_t *","hw", 1, self ));
4215
5139
  }
4216
5140
  arg1 = (HWInfo_t *)(argp1);
4217
5141
  result = ((arg1)->hw);
@@ -4222,6 +5146,32 @@ fail:
4222
5146
  }
4223
5147
 
4224
5148
 
5149
+
5150
+ /*
5151
+ Document-method: Rubycdio::HWInfo_t.result
5152
+
5153
+ call-seq:
5154
+ result -> bool
5155
+
5156
+ get_media_changed(cdio) -> int
5157
+
5158
+ Find out if media has changed since the last call.
5159
+ Return 1 if media has changed since last call, 0 if not. Error
5160
+ return codes are the same as driver_return_code_t.
5161
+ */
5162
+
5163
+ /*
5164
+ Document-method: Rubycdio::HWInfo_t.result=
5165
+
5166
+ call-seq:
5167
+ result=(x) -> bool
5168
+
5169
+ get_media_changed(cdio) -> int
5170
+
5171
+ Find out if media has changed since the last call.
5172
+ Return 1 if media has changed since last call, 0 if not. Error
5173
+ return codes are the same as driver_return_code_t.
5174
+ */
4225
5175
  SWIGINTERN VALUE
4226
5176
  _wrap_HWInfo_t_result_set(int argc, VALUE *argv, VALUE self) {
4227
5177
  HWInfo_t *arg1 = (HWInfo_t *) 0 ;
@@ -4236,12 +5186,12 @@ _wrap_HWInfo_t_result_set(int argc, VALUE *argv, VALUE self) {
4236
5186
  }
4237
5187
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_HWInfo_t, 0 | 0 );
4238
5188
  if (!SWIG_IsOK(res1)) {
4239
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "result" "', argument " "1"" of type '" "HWInfo_t *""'");
5189
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "HWInfo_t *","result", 1, self ));
4240
5190
  }
4241
5191
  arg1 = (HWInfo_t *)(argp1);
4242
5192
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
4243
5193
  if (!SWIG_IsOK(ecode2)) {
4244
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "result" "', argument " "2"" of type '" "bool""'");
5194
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","result", 2, argv[0] ));
4245
5195
  }
4246
5196
  arg2 = (bool)(val2);
4247
5197
  if (arg1) (arg1)->result = arg2;
@@ -4265,7 +5215,7 @@ _wrap_HWInfo_t_result_get(int argc, VALUE *argv, VALUE self) {
4265
5215
  }
4266
5216
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_HWInfo_t, 0 | 0 );
4267
5217
  if (!SWIG_IsOK(res1)) {
4268
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "result" "', argument " "1"" of type '" "HWInfo_t *""'");
5218
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "HWInfo_t *","result", 1, self ));
4269
5219
  }
4270
5220
  arg1 = (HWInfo_t *)(argp1);
4271
5221
  result = (bool) ((arg1)->result);
@@ -4293,6 +5243,18 @@ _wrap_HWInfo_t_allocate(VALUE self) {
4293
5243
  }
4294
5244
 
4295
5245
 
5246
+
5247
+ /*
5248
+ Document-method: Rubycdio::HWInfo_t.new
5249
+
5250
+ call-seq:
5251
+
5252
+
5253
+ get_num_tracks(p_cdio)->int
5254
+
5255
+ Return the number of tracks on the CD.
5256
+ On error rubycdio::INVALID_TRACK is returned..
5257
+ */
4296
5258
  SWIGINTERN VALUE
4297
5259
  _wrap_new_HWInfo_t(int argc, VALUE *argv, VALUE self) {
4298
5260
  HWInfo_t *result = 0 ;
@@ -4313,6 +5275,19 @@ free_HWInfo_t(HWInfo_t *arg1) {
4313
5275
  free((char *) arg1);
4314
5276
  }
4315
5277
 
5278
+
5279
+ /*
5280
+ Document-method: Rubycdio.get_hwinfo
5281
+
5282
+ call-seq:
5283
+ get_hwinfo(p_cdio) -> HWInfo_t
5284
+
5285
+ get_media_changed(cdio) -> int
5286
+
5287
+ Find out if media has changed since the last call.
5288
+ Return 1 if media has changed since last call, 0 if not. Error
5289
+ return codes are the same as driver_return_code_t.
5290
+ */
4316
5291
  SWIGINTERN VALUE
4317
5292
  _wrap_get_hwinfo(int argc, VALUE *argv, VALUE self) {
4318
5293
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -4326,7 +5301,7 @@ _wrap_get_hwinfo(int argc, VALUE *argv, VALUE self) {
4326
5301
  }
4327
5302
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
4328
5303
  if (!SWIG_IsOK(res1)) {
4329
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_hwinfo" "', argument " "1"" of type '" "CdIo_t const *""'");
5304
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","get_hwinfo", 1, argv[0] ));
4330
5305
  }
4331
5306
  arg1 = (CdIo_t *)(argp1);
4332
5307
  result = get_hwinfo((CdIo_t const *)arg1);
@@ -4352,6 +5327,17 @@ fail:
4352
5327
  }
4353
5328
 
4354
5329
 
5330
+
5331
+ /*
5332
+ Document-method: Rubycdio.set_blocksize
5333
+
5334
+ call-seq:
5335
+ set_blocksize(p_cdio, i_blocksize) -> driver_return_code_t
5336
+
5337
+ set_blocksize(cdio, blocksize)->return_status
5338
+
5339
+ Set the blocksize for subsequent reads..
5340
+ */
4355
5341
  SWIGINTERN VALUE
4356
5342
  _wrap_set_blocksize(int argc, VALUE *argv, VALUE self) {
4357
5343
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -4368,12 +5354,12 @@ _wrap_set_blocksize(int argc, VALUE *argv, VALUE self) {
4368
5354
  }
4369
5355
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
4370
5356
  if (!SWIG_IsOK(res1)) {
4371
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_set_blocksize" "', argument " "1"" of type '" "CdIo_t const *""'");
5357
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_set_blocksize", 1, argv[0] ));
4372
5358
  }
4373
5359
  arg1 = (CdIo_t *)(argp1);
4374
5360
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
4375
5361
  if (!SWIG_IsOK(ecode2)) {
4376
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_set_blocksize" "', argument " "2"" of type '" "int""'");
5362
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdio_set_blocksize", 2, argv[1] ));
4377
5363
  }
4378
5364
  arg2 = (int)(val2);
4379
5365
  result = (driver_return_code_t)cdio_set_blocksize((CdIo_t const *)arg1,arg2);
@@ -4384,6 +5370,16 @@ fail:
4384
5370
  }
4385
5371
 
4386
5372
 
5373
+
5374
+ /*
5375
+ Document-method: Rubycdio.set_speed
5376
+
5377
+ call-seq:
5378
+ set_speed(p_cdio, i_speed) -> driver_return_code_t
5379
+
5380
+ cdio_set_speed(cdio, speed)->return_status
5381
+ Set the drive speed..
5382
+ */
4387
5383
  SWIGINTERN VALUE
4388
5384
  _wrap_set_speed(int argc, VALUE *argv, VALUE self) {
4389
5385
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -4400,12 +5396,12 @@ _wrap_set_speed(int argc, VALUE *argv, VALUE self) {
4400
5396
  }
4401
5397
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
4402
5398
  if (!SWIG_IsOK(res1)) {
4403
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_set_speed" "', argument " "1"" of type '" "CdIo_t const *""'");
5399
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_set_speed", 1, argv[0] ));
4404
5400
  }
4405
5401
  arg1 = (CdIo_t *)(argp1);
4406
5402
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
4407
5403
  if (!SWIG_IsOK(ecode2)) {
4408
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdio_set_speed" "', argument " "2"" of type '" "int""'");
5404
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdio_set_speed", 2, argv[1] ));
4409
5405
  }
4410
5406
  arg2 = (int)(val2);
4411
5407
  result = (driver_return_code_t)cdio_set_speed((CdIo_t const *)arg1,arg2);
@@ -4416,6 +5412,25 @@ fail:
4416
5412
  }
4417
5413
 
4418
5414
 
5415
+
5416
+ /*
5417
+ Document-method: Rubycdio.open_cd
5418
+
5419
+ call-seq:
5420
+ open_cd(psz_source, driver_id=DRIVER_UNKNOWN, psz_access_mode=nil) -> CdIo_t
5421
+
5422
+ open_cd(source=NULL, driver_id=nil, access_mode=nil)
5423
+
5424
+ Sets up to read from place specified by source, driver_id and
5425
+ access mode. This should be called before using any other routine
5426
+ except those that act on a CD-ROM drive by name.
5427
+
5428
+ If nil is given as the source, we'll use the default driver device.
5429
+ If nil is given as the driver_id, we'll find a suitable device driver.
5430
+
5431
+ Return the a pointer than can be used in subsequent operations or
5432
+ nil on error or no device..
5433
+ */
4419
5434
  SWIGINTERN VALUE
4420
5435
  _wrap_open_cd(int argc, VALUE *argv, VALUE self) {
4421
5436
  char *arg1 = (char *) 0 ;
@@ -4437,20 +5452,20 @@ _wrap_open_cd(int argc, VALUE *argv, VALUE self) {
4437
5452
  }
4438
5453
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
4439
5454
  if (!SWIG_IsOK(res1)) {
4440
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "open_cd" "', argument " "1"" of type '" "char const *""'");
5455
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","open_cd", 1, argv[0] ));
4441
5456
  }
4442
5457
  arg1 = (char *)(buf1);
4443
5458
  if (argc > 1) {
4444
5459
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
4445
5460
  if (!SWIG_IsOK(ecode2)) {
4446
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "open_cd" "', argument " "2"" of type '" "driver_id_t""'");
5461
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "driver_id_t","open_cd", 2, argv[1] ));
4447
5462
  }
4448
5463
  arg2 = (driver_id_t)(val2);
4449
5464
  }
4450
5465
  if (argc > 2) {
4451
5466
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
4452
5467
  if (!SWIG_IsOK(res3)) {
4453
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "open_cd" "', argument " "3"" of type '" "char const *""'");
5468
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","open_cd", 3, argv[2] ));
4454
5469
  }
4455
5470
  arg3 = (char *)(buf3);
4456
5471
  }
@@ -4466,6 +5481,18 @@ fail:
4466
5481
  }
4467
5482
 
4468
5483
 
5484
+
5485
+ /*
5486
+ Document-method: Rubycdio.get_disc_last_lsn
5487
+
5488
+ call-seq:
5489
+ get_disc_last_lsn(p_cdio) -> lsn_t
5490
+
5491
+ get_disc_last_lsn(cdio)->lsn
5492
+ Get the LSN of the end of the CD.
5493
+
5494
+ perlcdio.INVALID_LSN is returned on error..
5495
+ */
4469
5496
  SWIGINTERN VALUE
4470
5497
  _wrap_get_disc_last_lsn(int argc, VALUE *argv, VALUE self) {
4471
5498
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -4479,7 +5506,7 @@ _wrap_get_disc_last_lsn(int argc, VALUE *argv, VALUE self) {
4479
5506
  }
4480
5507
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
4481
5508
  if (!SWIG_IsOK(res1)) {
4482
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_disc_last_lsn" "', argument " "1"" of type '" "CdIo_t const *""'");
5509
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_disc_last_lsn", 1, argv[0] ));
4483
5510
  }
4484
5511
  arg1 = (CdIo_t *)(argp1);
4485
5512
  result = (lsn_t)cdio_get_disc_last_lsn((CdIo_t const *)arg1);
@@ -4490,6 +5517,19 @@ fail:
4490
5517
  }
4491
5518
 
4492
5519
 
5520
+
5521
+ /*
5522
+ Document-method: Rubycdio.get_disc_mode
5523
+
5524
+ call-seq:
5525
+ get_disc_mode(p_cdio) -> char
5526
+
5527
+ get_disc_mode(p_cdio) -> str
5528
+
5529
+ Get disc mode - the kind of CD (CD-DA, CD-ROM mode 1, CD-MIXED, etc.
5530
+ that we've got. The notion of 'CD' is extended a little to include
5531
+ DVD's..
5532
+ */
4493
5533
  SWIGINTERN VALUE
4494
5534
  _wrap_get_disc_mode(int argc, VALUE *argv, VALUE self) {
4495
5535
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -4503,7 +5543,7 @@ _wrap_get_disc_mode(int argc, VALUE *argv, VALUE self) {
4503
5543
  }
4504
5544
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
4505
5545
  if (!SWIG_IsOK(res1)) {
4506
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_disc_mode" "', argument " "1"" of type '" "CdIo_t *""'");
5546
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t *","get_disc_mode", 1, argv[0] ));
4507
5547
  }
4508
5548
  arg1 = (CdIo_t *)(argp1);
4509
5549
  result = (char *)get_disc_mode(arg1);
@@ -4514,6 +5554,19 @@ fail:
4514
5554
  }
4515
5555
 
4516
5556
 
5557
+
5558
+ /*
5559
+ Document-method: Rubycdio.get_joliet_level
5560
+
5561
+ call-seq:
5562
+ get_joliet_level(p_cdio) -> int
5563
+
5564
+ get_joliet_level(cdio)->int
5565
+
5566
+ Return the Joliet level recognized for cdio.
5567
+ This only makes sense for something that has an ISO-9660
5568
+ filesystem..
5569
+ */
4517
5570
  SWIGINTERN VALUE
4518
5571
  _wrap_get_joliet_level(int argc, VALUE *argv, VALUE self) {
4519
5572
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -4527,7 +5580,7 @@ _wrap_get_joliet_level(int argc, VALUE *argv, VALUE self) {
4527
5580
  }
4528
5581
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
4529
5582
  if (!SWIG_IsOK(res1)) {
4530
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_joliet_level" "', argument " "1"" of type '" "CdIo_t const *""'");
5583
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_joliet_level", 1, argv[0] ));
4531
5584
  }
4532
5585
  arg1 = (CdIo_t *)(argp1);
4533
5586
  result = (int)cdio_get_joliet_level((CdIo_t const *)arg1);
@@ -4538,6 +5591,19 @@ fail:
4538
5591
  }
4539
5592
 
4540
5593
 
5594
+
5595
+ /*
5596
+ Document-method: Rubycdio.get_mcn
5597
+
5598
+ call-seq:
5599
+ get_mcn(p_cdio) -> char
5600
+
5601
+ get_joliet_level(cdio)->int
5602
+
5603
+ Return the Joliet level recognized for cdio.
5604
+ This only makes sense for something that has an ISO-9660
5605
+ filesystem..
5606
+ */
4541
5607
  SWIGINTERN VALUE
4542
5608
  _wrap_get_mcn(int argc, VALUE *argv, VALUE self) {
4543
5609
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -4551,7 +5617,7 @@ _wrap_get_mcn(int argc, VALUE *argv, VALUE self) {
4551
5617
  }
4552
5618
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
4553
5619
  if (!SWIG_IsOK(res1)) {
4554
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_mcn" "', argument " "1"" of type '" "CdIo_t const *""'");
5620
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_mcn", 1, argv[0] ));
4555
5621
  }
4556
5622
  arg1 = (CdIo_t *)(argp1);
4557
5623
  result = (char *)cdio_get_mcn((CdIo_t const *)arg1);
@@ -4563,6 +5629,18 @@ fail:
4563
5629
  }
4564
5630
 
4565
5631
 
5632
+
5633
+ /*
5634
+ Document-method: Rubycdio.get_num_tracks
5635
+
5636
+ call-seq:
5637
+ get_num_tracks(p_cdio) -> track_t
5638
+
5639
+ get_num_tracks(p_cdio)->int
5640
+
5641
+ Return the number of tracks on the CD.
5642
+ On error rubycdio::INVALID_TRACK is returned..
5643
+ */
4566
5644
  SWIGINTERN VALUE
4567
5645
  _wrap_get_num_tracks(int argc, VALUE *argv, VALUE self) {
4568
5646
  CdIo_t *arg1 = (CdIo_t *) 0 ;
@@ -4576,7 +5654,7 @@ _wrap_get_num_tracks(int argc, VALUE *argv, VALUE self) {
4576
5654
  }
4577
5655
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdIo_t, 0 | 0 );
4578
5656
  if (!SWIG_IsOK(res1)) {
4579
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdio_get_num_tracks" "', argument " "1"" of type '" "CdIo_t const *""'");
5657
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdIo_t const *","cdio_get_num_tracks", 1, argv[0] ));
4580
5658
  }
4581
5659
  arg1 = (CdIo_t *)(argp1);
4582
5660
  result = (track_t)cdio_get_num_tracks((CdIo_t const *)arg1);
@@ -4596,10 +5674,10 @@ static swig_type_info _swigt__p_HWInfo_t = {"_p_HWInfo_t", "HWInfo_t *", 0, 0, (
4596
5674
  static swig_type_info _swigt__p_cdio_hwinfo_t = {"_p_cdio_hwinfo_t", "cdio_hwinfo_t *", 0, 0, (void*)0, 0};
4597
5675
  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};
4598
5676
  static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
4599
- static swig_type_info _swigt__p_int = {"_p_int", "int *|lsn_t *", 0, 0, (void*)0, 0};
4600
- static swig_type_info _swigt__p_long = {"_p_long", "long *|ssize_t *", 0, 0, (void*)0, 0};
5677
+ static swig_type_info _swigt__p_int = {"_p_int", "int *|lba_t *|track_flag_t *|lsn_t *|int16_t *", 0, 0, (void*)0, 0};
5678
+ static swig_type_info _swigt__p_long = {"_p_long", "my_ssize_t *|ssize_t *|long *|driver_return_code_t *", 0, 0, (void*)0, 0};
4601
5679
  static swig_type_info _swigt__p_off_t = {"_p_off_t", "off_t *", 0, 0, (void*)0, 0};
4602
- static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0};
5680
+ 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 *|driver_id_t *", 0, 0, (void*)0, 0};
4603
5681
 
4604
5682
  static swig_type_info *swig_type_initial[] = {
4605
5683
  &_swigt__p_Buf_triple_t,
@@ -4869,7 +5947,9 @@ SWIG_PropagateClientData(void) {
4869
5947
  }
4870
5948
  #endif
4871
5949
 
5950
+ /*
4872
5951
 
5952
+ */
4873
5953
  #ifdef __cplusplus
4874
5954
  extern "C"
4875
5955
  #endif