jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Support building with recent versions of the Ruby 1.9 development branch.

Browse source 
Fixes bug #1560092.


git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@9333 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Olly Betts 2006-09-23 21:39:09 +00:00
commit 2f6a268e55
11 changed files with 137 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

4
CHANGES.current
View file

@ -1,6 +1,10 @@
Version 1.3.30 (in progress) Version 1.3.30 (in progress)
============================ ============================
09/23/2006: olly
[Ruby] Support building with recent versions of the Ruby 1.9
development branch. Fixes bug #1560092.
09/23/2006: olly 09/23/2006: olly
Templates can now be instantiated using negative numbers and Templates can now be instantiated using negative numbers and
constant expressions, e.g.: constant expressions, e.g.:

4
Lib/ruby/argcargv.i
View file

@ -25,10 +25,10 @@
%typemap(in) (int ARGC, char **ARGV) { %typemap(in) (int ARGC, char **ARGV) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
int i; int i;
int size = RARRAY($input)->len; int size = RARRAY_LEN($input);
$1 = ($1_ltype) size; $1 = ($1_ltype) size;
$2 = (char **) malloc((size+1)*sizeof(char *)); $2 = (char **) malloc((size+1)*sizeof(char *));
VALUE *ptr = RARRAY($input)->ptr; VALUE *ptr = RARRAY_PTR($input);
for (i=0; i < size; i++, ptr++) { for (i=0; i < size; i++, ptr++) {
$2[i]= STR2CSTR(*ptr); $2[i]= STR2CSTR(*ptr);
} }

2
Lib/ruby/jstring.i
View file

@ -11,7 +11,7 @@ SWIG_AsVal(jstring)(VALUE obj, jstring *val)
if (TYPE(obj) == T_STRING) { if (TYPE(obj) == T_STRING) {
if (val) { if (val) {
char *cstr = rb_string_value_ptr(&(obj)); char *cstr = rb_string_value_ptr(&(obj));
jsize len = RSTRING(obj)->len; jsize len = RSTRING_LEN(obj);
*val = JvNewStringLatin1(cstr, len); *val = JvNewStringLatin1(cstr, len);
} }
return SWIG_NEWOBJ; return SWIG_NEWOBJ;

12
Lib/ruby/progargcargv.i
View file

@ -11,23 +11,23 @@ char **PROG_ARGV
// argc and argv // argc and argv
%typemap(in,numinputs=0) int PROG_ARGC { %typemap(in,numinputs=0) int PROG_ARGC {
$1 = RARRAY(rb_argv)->len + 1; $1 = RARRAY_LEN(rb_argv) + 1;
} }
%typemap(in,numinputs=0) char **PROG_ARGV { %typemap(in,numinputs=0) char **PROG_ARGV {
int i, n; int i, n;
VALUE ary = rb_eval_string("[$0] + ARGV"); VALUE ary = rb_eval_string("[$0] + ARGV");
n = RARRAY(ary)->len; n = RARRAY_LEN(ary);
$1 = (char **)malloc(n + 1); $1 = (char **)malloc(n + 1);
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
VALUE v = rb_obj_as_string(RARRAY(ary)->ptr[i]); VALUE v = rb_obj_as_string(RARRAY_PTR(ary)[i]);
$1[i] = (char *)malloc(RSTRING(v)->len + 1); $1[i] = (char *)malloc(RSTRING_LEN(v) + 1);
strcpy($1[i], RSTRING(v)->ptr); strcpy($1[i], RSTRING_PTR(v));
} }
} }
%typemap(freearg) char **PROG_ARGV { %typemap(freearg) char **PROG_ARGV {
int i, n = RARRAY(rb_argv)->len + 1; int i, n = RARRAY_LEN(rb_argv) + 1;
for (i = 0; i < n; i++) free($1[i]); for (i = 0; i < n; i++) free($1[i]);
free($1); free($1);
} }

19
Lib/ruby/rubyhead.swg
View file

@ -20,6 +20,21 @@
#endif #endif
#endif #endif
/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
/* Define these for older versions so we can just write code the new way */
#ifndef RSTRING_LEN
# define RSTRING_LEN(x) RSTRING(x)->len
#endif
#ifndef RSTRING_PTR
# define RSTRING_PTR(x) RSTRING(x)->ptr
#endif
#ifndef RARRAY_LEN
# define RARRAY_LEN(x) RARRAY(x)->len
#endif
#ifndef RARRAY_PTR
# define RARRAY_PTR(x) RARRAY(x)->ptr
#endif
/* /*
* Need to be very careful about how these macros are defined, especially * Need to be very careful about how these macros are defined, especially
* when compiling C++ code or C code with an ANSI C compiler. * when compiling C++ code or C code with an ANSI C compiler.
@ -63,10 +78,10 @@
#define StringValue(s) RB_STRING_VALUE(s) #define StringValue(s) RB_STRING_VALUE(s)
#endif #endif
#ifndef StringValuePtr #ifndef StringValuePtr
#define StringValuePtr(s) RSTRING(RB_STRING_VALUE(s))->ptr #define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
#endif #endif
#ifndef StringValueLen #ifndef StringValueLen
#define StringValueLen(s) RSTRING(RB_STRING_VALUE(s))->len #define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
#endif #endif
#ifndef SafeStringValue #ifndef SafeStringValue
#define SafeStringValue(v) do {\ #define SafeStringValue(v) do {\

2
Lib/ruby/rubyrun.swg
View file

@ -157,7 +157,7 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
downcast methods. */ downcast methods. */
if (obj != Qnil) { if (obj != Qnil) {
VALUE value = rb_iv_get(obj, "__swigtype__"); VALUE value = rb_iv_get(obj, "__swigtype__");
char* type_name = RSTRING(value)->ptr; char* type_name = RSTRING_PTR(value);
if (strcmp(type->name, type_name) == 0) { if (strcmp(type->name, type_name) == 0) {
return obj; return obj;

2
Lib/ruby/rubystrings.swg
View file

@ -12,7 +12,7 @@ SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
#else #else
char *cstr = STR2CSTR(obj); char *cstr = STR2CSTR(obj);
#endif #endif
size_t size = RSTRING(obj)->len + 1; size_t size = RSTRING_LEN(obj) + 1;
if (cptr) { if (cptr) {
if (alloc) { if (alloc) {
if (*alloc == SWIG_NEWOBJ) { if (*alloc == SWIG_NEWOBJ) {

2
Lib/ruby/std_common.i
View file

@ -33,7 +33,7 @@ bool SWIG_STRING_P(VALUE x) {
return TYPE(x) == T_STRING; return TYPE(x) == T_STRING;
} }
std::string SWIG_RB2STR(VALUE x) { std::string SWIG_RB2STR(VALUE x) {
return std::string(RSTRING(x)->ptr, RSTRING(x)->len); return std::string(RSTRING_PTR(x), RSTRING_LEN(x));
} }
VALUE SWIG_STR2RB(const std::string& s) { VALUE SWIG_STR2RB(const std::string& s) {
return rb_str_new(s.data(), s.size()); return rb_str_new(s.data(), s.size());

64
Lib/ruby/std_map.i
View file

@ -50,11 +50,11 @@ namespace std {
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
$1 = std::map<K,T >(); $1 = std::map<K,T >();
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
K* k; K* k;
T* x; T* x;
VALUE key = RARRAY(keys)->ptr[i]; VALUE key = RARRAY_PTR(keys)[i];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
SWIG_ConvertPtr(key, (void **) &k, $descriptor(K *), 1); SWIG_ConvertPtr(key, (void **) &k, $descriptor(K *), 1);
SWIG_ConvertPtr(val, (void **) &x, $descriptor(T *), 1); SWIG_ConvertPtr(val, (void **) &x, $descriptor(T *), 1);
@ -73,11 +73,11 @@ namespace std {
temp = std::map<K,T >(); temp = std::map<K,T >();
$1 = &temp; $1 = &temp;
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
K* k; K* k;
T* x; T* x;
VALUE key = RARRAY(keys)->ptr[i]; VALUE key = RARRAY_PTR(keys)[i];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
SWIG_ConvertPtr(key, (void **) &k, $descriptor(K *), 1); SWIG_ConvertPtr(key, (void **) &k, $descriptor(K *), 1);
SWIG_ConvertPtr(val, (void **) &x, $descriptor(T *), 1); SWIG_ConvertPtr(val, (void **) &x, $descriptor(T *), 1);
@ -104,7 +104,7 @@ namespace std {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
if (size == 0) { if (size == 0) {
/* an empty dictionary can be of any type */ /* an empty dictionary can be of any type */
$1 = 1; $1 = 1;
@ -112,7 +112,7 @@ namespace std {
/* check the first element only */ /* check the first element only */
K* k; K* k;
T* x; T* x;
VALUE key = RARRAY(keys)->ptr[0]; VALUE key = RARRAY_PTR(keys)[0];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (SWIG_ConvertPtr(key,(void **) &k, if (SWIG_ConvertPtr(key,(void **) &k,
$descriptor(K *),0) != -1 && $descriptor(K *),0) != -1 &&
@ -137,7 +137,7 @@ namespace std {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
if (size == 0) { if (size == 0) {
/* an empty dictionary can be of any type */ /* an empty dictionary can be of any type */
$1 = 1; $1 = 1;
@ -145,7 +145,7 @@ namespace std {
/* check the first element only */ /* check the first element only */
K* k; K* k;
T* x; T* x;
VALUE key = RARRAY(keys)->ptr[0]; VALUE key = RARRAY_PTR(keys)[0];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (SWIG_ConvertPtr(key,(void **) &k, if (SWIG_ConvertPtr(key,(void **) &k,
$descriptor(K *),0) != -1 && $descriptor(K *),0) != -1 &&
@ -254,10 +254,10 @@ namespace std {
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
$1 = std::map<K,T >(); $1 = std::map<K,T >();
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
T* x; T* x;
VALUE key = RARRAY(keys)->ptr[i]; VALUE key = RARRAY_PTR(keys)[i];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (!CHECK(key)) if (!CHECK(key))
rb_raise(rb_eTypeError, rb_raise(rb_eTypeError,
@ -280,10 +280,10 @@ namespace std {
temp = std::map<K,T >(); temp = std::map<K,T >();
$1 = &temp; $1 = &temp;
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
T* x; T* x;
VALUE key = RARRAY(keys)->ptr[i]; VALUE key = RARRAY_PTR(keys)[i];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (!CHECK(key)) if (!CHECK(key))
rb_raise(rb_eTypeError, rb_raise(rb_eTypeError,
@ -312,14 +312,14 @@ namespace std {
// native sequence? // native sequence?
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
if (size == 0) { if (size == 0) {
// an empty dictionary can be of any type // an empty dictionary can be of any type
$1 = 1; $1 = 1;
} else { } else {
// check the first element only // check the first element only
T* x; T* x;
VALUE key = RARRAY(keys)->ptr[0]; VALUE key = RARRAY_PTR(keys)[0];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (CHECK(key) && if (CHECK(key) &&
SWIG_ConvertPtr(val,(void **) &x, SWIG_ConvertPtr(val,(void **) &x,
@ -343,14 +343,14 @@ namespace std {
// native sequence? // native sequence?
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
if (size == 0) { if (size == 0) {
// an empty dictionary can be of any type // an empty dictionary can be of any type
$1 = 1; $1 = 1;
} else { } else {
// check the first element only // check the first element only
T* x; T* x;
VALUE key = RARRAY(keys)->ptr[0]; VALUE key = RARRAY_PTR(keys)[0];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (CHECK(key) && if (CHECK(key) &&
SWIG_ConvertPtr(val,(void **) &x, SWIG_ConvertPtr(val,(void **) &x,
@ -452,10 +452,10 @@ namespace std {
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
$1 = std::map<K,T >(); $1 = std::map<K,T >();
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
K* k; K* k;
VALUE key = RARRAY(keys)->ptr[i]; VALUE key = RARRAY_PTR(keys)[i];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (!CHECK(val)) if (!CHECK(val))
rb_raise(rb_eTypeError, rb_raise(rb_eTypeError,
@ -478,10 +478,10 @@ namespace std {
temp = std::map<K,T >(); temp = std::map<K,T >();
$1 = &temp; $1 = &temp;
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
K* k; K* k;
VALUE key = RARRAY(keys)->ptr[i]; VALUE key = RARRAY_PTR(keys)[i];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (!CHECK(val)) if (!CHECK(val))
rb_raise(rb_eTypeError, rb_raise(rb_eTypeError,
@ -510,14 +510,14 @@ namespace std {
// native sequence? // native sequence?
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
if (size == 0) { if (size == 0) {
// an empty dictionary can be of any type // an empty dictionary can be of any type
$1 = 1; $1 = 1;
} else { } else {
// check the first element only // check the first element only
K* k; K* k;
VALUE key = RARRAY(keys)->ptr[0]; VALUE key = RARRAY_PTR(keys)[0];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (SWIG_ConvertPtr(val,(void **) &k, if (SWIG_ConvertPtr(val,(void **) &k,
$descriptor(K *),0) != -1 && $descriptor(K *),0) != -1 &&
@ -541,14 +541,14 @@ namespace std {
// native sequence? // native sequence?
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
if (size == 0) { if (size == 0) {
// an empty dictionary can be of any type // an empty dictionary can be of any type
$1 = 1; $1 = 1;
} else { } else {
// check the first element only // check the first element only
K* k; K* k;
VALUE key = RARRAY(keys)->ptr[0]; VALUE key = RARRAY_PTR(keys)[0];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (SWIG_ConvertPtr(val,(void **) &k, if (SWIG_ConvertPtr(val,(void **) &k,
$descriptor(K *),0) != -1 && $descriptor(K *),0) != -1 &&
@ -650,9 +650,9 @@ namespace std {
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
$1 = std::map<K,T >(); $1 = std::map<K,T >();
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
VALUE key = RARRAY(keys)->ptr[i]; VALUE key = RARRAY_PTR(keys)[i];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (!(CHECK_K(key) && CHECK_T(val))) if (!(CHECK_K(key) && CHECK_T(val)))
rb_raise(rb_eTypeError, rb_raise(rb_eTypeError,
@ -674,9 +674,9 @@ namespace std {
temp = std::map<K,T >(); temp = std::map<K,T >();
$1 = &temp; $1 = &temp;
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
VALUE key = RARRAY(keys)->ptr[i]; VALUE key = RARRAY_PTR(keys)[i];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (!(CHECK_K(key) && CHECK_T(val))) if (!(CHECK_K(key) && CHECK_T(val)))
rb_raise(rb_eTypeError, rb_raise(rb_eTypeError,
@ -701,13 +701,13 @@ namespace std {
// native sequence? // native sequence?
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
if (size == 0) { if (size == 0) {
// an empty dictionary can be of any type // an empty dictionary can be of any type
$1 = 1; $1 = 1;
} else { } else {
// check the first element only // check the first element only
VALUE key = RARRAY(keys)->ptr[0]; VALUE key = RARRAY_PTR(keys)[0];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (CHECK_K(key) && CHECK_T(val)) if (CHECK_K(key) && CHECK_T(val))
$1 = 1; $1 = 1;
@ -729,13 +729,13 @@ namespace std {
// native sequence? // native sequence?
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
VALUE keys = rb_funcall($input,rb_intern("keys"),0); VALUE keys = rb_funcall($input,rb_intern("keys"),0);
unsigned int size = RARRAY(keys)->len; unsigned int size = RARRAY_LEN(keys);
if (size == 0) { if (size == 0) {
// an empty dictionary can be of any type // an empty dictionary can be of any type
$1 = 1; $1 = 1;
} else { } else {
// check the first element only // check the first element only
VALUE key = RARRAY(keys)->ptr[0]; VALUE key = RARRAY_PTR(keys)[0];
VALUE val = rb_hash_aref($input,key); VALUE val = rb_hash_aref($input,key);
if (CHECK_K(key) && CHECK_T(val)) if (CHECK_K(key) && CHECK_T(val))
$1 = 1; $1 = 1;

96
Lib/ruby/std_pair.i
View file

@ -27,14 +27,14 @@ namespace std {
template<class T, class U> struct pair { template<class T, class U> struct pair {
%typemap(in) pair<T,U> (std::pair<T,U>* p) { %typemap(in) pair<T,U> (std::pair<T,U>* p) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) if (size != 2)
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
T* x; T* x;
U* y; U* y;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
SWIG_ConvertPtr(first, (void **) &x, $descriptor(T *), 1); SWIG_ConvertPtr(first, (void **) &x, $descriptor(T *), 1);
SWIG_ConvertPtr(second, (void **) &y, $descriptor(U *), 1); SWIG_ConvertPtr(second, (void **) &y, $descriptor(U *), 1);
$1 = std::make_pair(*x,*y); $1 = std::make_pair(*x,*y);
@ -48,14 +48,14 @@ namespace std {
const pair<T,U>* (std::pair<T,U> temp, const pair<T,U>* (std::pair<T,U> temp,
std::pair<T,U>* p) { std::pair<T,U>* p) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) if (size != 2)
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
T* x; T* x;
U* y; U* y;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
SWIG_ConvertPtr(first, (void **) &x, $descriptor(T *), 1); SWIG_ConvertPtr(first, (void **) &x, $descriptor(T *), 1);
SWIG_ConvertPtr(second, (void **) &y, $descriptor(U *), 1); SWIG_ConvertPtr(second, (void **) &y, $descriptor(U *), 1);
temp = std::make_pair(*x,*y); temp = std::make_pair(*x,*y);
@ -79,15 +79,15 @@ namespace std {
%typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> { %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
/* not a pair */ /* not a pair */
$1 = 0; $1 = 0;
} else { } else {
T* x; T* x;
U* y; U* y;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (SWIG_ConvertPtr(first,(void **) &x, if (SWIG_ConvertPtr(first,(void **) &x,
$descriptor(T *),0) != -1 && $descriptor(T *),0) != -1 &&
SWIG_ConvertPtr(second,(void **) &y, SWIG_ConvertPtr(second,(void **) &y,
@ -110,15 +110,15 @@ namespace std {
const pair<T,U>* { const pair<T,U>* {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
/* not a pair */ /* not a pair */
$1 = 0; $1 = 0;
} else { } else {
T* x; T* x;
U* y; U* y;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (SWIG_ConvertPtr(first,(void **) &x, if (SWIG_ConvertPtr(first,(void **) &x,
$descriptor(T *),0) != -1 && $descriptor(T *),0) != -1 &&
SWIG_ConvertPtr(second,(void **) &y, SWIG_ConvertPtr(second,(void **) &y,
@ -154,13 +154,13 @@ namespace std {
template<class U> struct pair<T,U> { template<class U> struct pair<T,U> {
%typemap(in) pair<T,U> (std::pair<T,U>* p) { %typemap(in) pair<T,U> (std::pair<T,U>* p) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) if (size != 2)
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
U* y; U* y;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (!CHECK(first)) if (!CHECK(first))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
@ -176,13 +176,13 @@ namespace std {
const pair<T,U>* (std::pair<T,U> temp, const pair<T,U>* (std::pair<T,U> temp,
std::pair<T,U>* p) { std::pair<T,U>* p) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) if (size != 2)
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
U* y; U* y;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (!CHECK(first)) if (!CHECK(first))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
@ -205,14 +205,14 @@ namespace std {
%typecheck(SWIG_TYPECHECK_MAP) pair<T,U> { %typecheck(SWIG_TYPECHECK_MAP) pair<T,U> {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
/* not a pair */ /* not a pair */
$1 = 0; $1 = 0;
} else { } else {
U* y; U* y;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (CHECK(first) && if (CHECK(first) &&
SWIG_ConvertPtr(second,(void **) &y, SWIG_ConvertPtr(second,(void **) &y,
$descriptor(U *),0) != -1) $descriptor(U *),0) != -1)
@ -234,14 +234,14 @@ namespace std {
const pair<T,U>* { const pair<T,U>* {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
/* not a pair */ /* not a pair */
$1 = 0; $1 = 0;
} else { } else {
U* y; U* y;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (CHECK(first) && if (CHECK(first) &&
SWIG_ConvertPtr(second,(void **) &y, SWIG_ConvertPtr(second,(void **) &y,
$descriptor(U *),0) != -1) $descriptor(U *),0) != -1)
@ -275,14 +275,14 @@ namespace std {
template<class T> struct pair<T,U> { template<class T> struct pair<T,U> {
%typemap(in) pair<T,U> (std::pair<T,U>* p) { %typemap(in) pair<T,U> (std::pair<T,U>* p) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
} }
T* x; T* x;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
SWIG_ConvertPtr(first, (void **) &x, $descriptor(T *), 1); SWIG_ConvertPtr(first, (void **) &x, $descriptor(T *), 1);
if (!CHECK(second)) if (!CHECK(second))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
@ -298,14 +298,14 @@ namespace std {
const pair<T,U>* (std::pair<T,U> temp, const pair<T,U>* (std::pair<T,U> temp,
std::pair<T,U>* p) { std::pair<T,U>* p) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
} }
T* x; T* x;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
SWIG_ConvertPtr(first, (void **) &x, $descriptor(T *), 1); SWIG_ConvertPtr(first, (void **) &x, $descriptor(T *), 1);
if (!CHECK(second)) if (!CHECK(second))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
@ -328,14 +328,14 @@ namespace std {
%typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> { %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
/* not a pair */ /* not a pair */
$1 = 0; $1 = 0;
} else { } else {
T* x; T* x;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (SWIG_ConvertPtr(first,(void **) &x, if (SWIG_ConvertPtr(first,(void **) &x,
$descriptor(T *),0) != -1 && $descriptor(T *),0) != -1 &&
CHECK(second)) CHECK(second))
@ -357,14 +357,14 @@ namespace std {
const pair<T,U>* { const pair<T,U>* {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
/* not a pair */ /* not a pair */
$1 = 0; $1 = 0;
} else { } else {
T* x; T* x;
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (SWIG_ConvertPtr(first,(void **) &x, if (SWIG_ConvertPtr(first,(void **) &x,
$descriptor(T *),0) != -1 && $descriptor(T *),0) != -1 &&
CHECK(second)) CHECK(second))
@ -398,13 +398,13 @@ namespace std {
template<> struct pair<T,U> { template<> struct pair<T,U> {
%typemap(in) pair<T,U> (std::pair<T,U>* p) { %typemap(in) pair<T,U> (std::pair<T,U>* p) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
} }
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (!CHECK_T(first) || !CHECK_U(second)) if (!CHECK_T(first) || !CHECK_U(second))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
@ -420,13 +420,13 @@ namespace std {
const pair<T,U>* (std::pair<T,U> temp, const pair<T,U>* (std::pair<T,U> temp,
std::pair<T,U>* p) { std::pair<T,U>* p) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
} }
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (!CHECK_T(first) || !CHECK_U(second)) if (!CHECK_T(first) || !CHECK_U(second))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"pair<" #T "," #U "> expected"); "pair<" #T "," #U "> expected");
@ -446,13 +446,13 @@ namespace std {
%typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> { %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
/* not a pair */ /* not a pair */
$1 = 0; $1 = 0;
} else { } else {
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (CHECK_T(first) && CHECK_U(second)) if (CHECK_T(first) && CHECK_U(second))
$1 = 1; $1 = 1;
else else
@ -472,13 +472,13 @@ namespace std {
const pair<T,U>* { const pair<T,U>* {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cHash)) { if (rb_obj_is_kind_of($input,rb_cHash)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size != 2) { if (size != 2) {
/* not a pair */ /* not a pair */
$1 = 0; $1 = 0;
} else { } else {
VALUE first = RARRAY($input)->ptr[0]; VALUE first = RARRAY_PTR($input)[0];
VALUE second = RARRAY($input)->ptr[1]; VALUE second = RARRAY_PTR($input)[1];
if (CHECK_T(first) && CHECK_U(second)) if (CHECK_T(first) && CHECK_U(second))
$1 = 1; $1 = 1;
else else

48
Lib/ruby/std_vector.i
View file

@ -48,10 +48,10 @@ namespace std {
template<class T> class vector { template<class T> class vector {
%typemap(in) vector<T> { %typemap(in) vector<T> {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
$1; $1;
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
VALUE o = RARRAY($input)->ptr[i]; VALUE o = RARRAY_PTR($input)[i];
T* x; T* x;
SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1); SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
$1.push_back(*x); $1.push_back(*x);
@ -65,10 +65,10 @@ namespace std {
%typemap(in) const vector<T>& (std::vector<T> temp), %typemap(in) const vector<T>& (std::vector<T> temp),
const vector<T>* (std::vector<T> temp) { const vector<T>* (std::vector<T> temp) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
$1 = &temp; $1 = &temp;
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
VALUE o = RARRAY($input)->ptr[i]; VALUE o = RARRAY_PTR($input)[i];
T* x; T* x;
SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1); SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
temp.push_back(*x); temp.push_back(*x);
@ -89,14 +89,14 @@ namespace std {
%typecheck(SWIG_TYPECHECK_VECTOR) vector<T> { %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size == 0) { if (size == 0) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
$1 = 1; $1 = 1;
} else { } else {
/* check the first element only */ /* check the first element only */
T* x; T* x;
VALUE o = RARRAY($input)->ptr[0]; VALUE o = RARRAY_PTR($input)[0];
if ((SWIG_ConvertPtr(o,(void **) &x, if ((SWIG_ConvertPtr(o,(void **) &x,
$descriptor(T *),0)) != -1) $descriptor(T *),0)) != -1)
$1 = 1; $1 = 1;
@ -117,14 +117,14 @@ namespace std {
const vector<T>* { const vector<T>* {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size == 0) { if (size == 0) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
$1 = 1; $1 = 1;
} else { } else {
/* check the first element only */ /* check the first element only */
T* x; T* x;
VALUE o = RARRAY($input)->ptr[0]; VALUE o = RARRAY_PTR($input)[0];
if ((SWIG_ConvertPtr(o,(void **) &x, if ((SWIG_ConvertPtr(o,(void **) &x,
$descriptor(T *),0)) != -1) $descriptor(T *),0)) != -1)
$1 = 1; $1 = 1;
@ -194,10 +194,10 @@ namespace std {
template<class T> class vector<T*> { template<class T> class vector<T*> {
%typemap(in) vector<T*> { %typemap(in) vector<T*> {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
$1 = std::vector<T* >(size); $1 = std::vector<T* >(size);
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
VALUE o = RARRAY($input)->ptr[i]; VALUE o = RARRAY_PTR($input)[i];
T* x; T* x;
SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1); SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
(($1_type &)$1)[i] = x; (($1_type &)$1)[i] = x;
@ -211,11 +211,11 @@ namespace std {
%typemap(in) const vector<T*>& (std::vector<T*> temp), %typemap(in) const vector<T*>& (std::vector<T*> temp),
const vector<T*>* (std::vector<T*> temp) { const vector<T*>* (std::vector<T*> temp) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
temp = std::vector<T* >(size); temp = std::vector<T* >(size);
$1 = &temp; $1 = &temp;
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
VALUE o = RARRAY($input)->ptr[i]; VALUE o = RARRAY_PTR($input)[i];
T* x; T* x;
SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1); SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
temp[i] = x; temp[i] = x;
@ -236,14 +236,14 @@ namespace std {
%typecheck(SWIG_TYPECHECK_VECTOR) vector<T*> { %typecheck(SWIG_TYPECHECK_VECTOR) vector<T*> {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size == 0) { if (size == 0) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
$1 = 1; $1 = 1;
} else { } else {
/* check the first element only */ /* check the first element only */
T* x; T* x;
VALUE o = RARRAY($input)->ptr[0]; VALUE o = RARRAY_PTR($input)[0];
if ((SWIG_ConvertPtr(o,(void **) &x, if ((SWIG_ConvertPtr(o,(void **) &x,
$descriptor(T *),0)) != -1) $descriptor(T *),0)) != -1)
$1 = 1; $1 = 1;
@ -264,14 +264,14 @@ namespace std {
const vector<T*>* { const vector<T*>* {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size == 0) { if (size == 0) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
$1 = 1; $1 = 1;
} else { } else {
/* check the first element only */ /* check the first element only */
T* x; T* x;
VALUE o = RARRAY($input)->ptr[0]; VALUE o = RARRAY_PTR($input)[0];
if ((SWIG_ConvertPtr(o,(void **) &x, if ((SWIG_ConvertPtr(o,(void **) &x,
$descriptor(T *),0)) != -1) $descriptor(T *),0)) != -1)
$1 = 1; $1 = 1;
@ -343,10 +343,10 @@ namespace std {
template<> class vector<T> { template<> class vector<T> {
%typemap(in) vector<T> { %typemap(in) vector<T> {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
$1 = std::vector<T >(size); $1 = std::vector<T >(size);
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
VALUE o = RARRAY($input)->ptr[i]; VALUE o = RARRAY_PTR($input)[i];
if (CHECK(o)) if (CHECK(o))
(($1_type &)$1)[i] = (T)(CONVERT_FROM(o)); (($1_type &)$1)[i] = (T)(CONVERT_FROM(o));
else else
@ -363,11 +363,11 @@ namespace std {
%typemap(in) const vector<T>& (std::vector<T> temp), %typemap(in) const vector<T>& (std::vector<T> temp),
const vector<T>* (std::vector<T> temp) { const vector<T>* (std::vector<T> temp) {
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
temp = std::vector<T >(size); temp = std::vector<T >(size);
$1 = &temp; $1 = &temp;
for (unsigned int i=0; i<size; i++) { for (unsigned int i=0; i<size; i++) {
VALUE o = RARRAY($input)->ptr[i]; VALUE o = RARRAY_PTR($input)[i];
if (CHECK(o)) if (CHECK(o))
temp[i] = (T)(CONVERT_FROM(o)); temp[i] = (T)(CONVERT_FROM(o));
else else
@ -387,13 +387,13 @@ namespace std {
%typecheck(SWIG_TYPECHECK_VECTOR) vector<T> { %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size == 0) { if (size == 0) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
$1 = 1; $1 = 1;
} else { } else {
/* check the first element only */ /* check the first element only */
VALUE o = RARRAY($input)->ptr[0]; VALUE o = RARRAY_PTR($input)[0];
if (CHECK(o)) if (CHECK(o))
$1 = 1; $1 = 1;
else else
@ -413,13 +413,13 @@ namespace std {
const vector<T>* { const vector<T>* {
/* native sequence? */ /* native sequence? */
if (rb_obj_is_kind_of($input,rb_cArray)) { if (rb_obj_is_kind_of($input,rb_cArray)) {
unsigned int size = RARRAY($input)->len; unsigned int size = RARRAY_LEN($input);
if (size == 0) { if (size == 0) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
$1 = 1; $1 = 1;
} else { } else {
/* check the first element only */ /* check the first element only */
VALUE o = RARRAY($input)->ptr[0]; VALUE o = RARRAY_PTR($input)[0];
if (CHECK(o)) if (CHECK(o))
$1 = 1; $1 = 1;
else else