ruby-core

Hi,

	... and Diff is in this one :-))

	(Sorry!)

		Michal

-- 
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Michal Rokos                         Czech Technical University, Prague
E-mail:m.rokos@sh.cvut.cz      ICQ:36118339      Jabber:majkl@jabber.cz
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Attachments (1)

RubyIntVsLong.diff (31.1 KB, text/x-diff)

Index: array.c
===================================================================
RCS file: /src/ruby/array.c,v
retrieving revision 1.89
diff -u -r1.89 array.c
--- array.c	2002/08/19 06:43:58	1.89
+++ array.c	2002/08/21 11:21:24
@@ -250,7 +250,7 @@
 	    rb_raise(rb_eArgError, "wrong number of arguments");
 	}
 	for (i=0; i<len; i++) {
-	    RARRAY(ary)->ptr[i] = rb_yield(INT2NUM(i));
+	    RARRAY(ary)->ptr[i] = rb_yield(LONG2NUM(i));
 	    RARRAY(ary)->len = i + 1;
 	}
     }
@@ -595,7 +595,7 @@
 
     while (i--) {
 	if (rb_equal(RARRAY(ary)->ptr[i], val))
-	    return INT2NUM(i);
+	    return LONG2NUM(i);
     }
     return Qnil;
 }
@@ -762,7 +762,7 @@
     long i;
 
     for (i=0; i<RARRAY(ary)->len; i++) {
-	rb_yield(INT2NUM(i));
+	rb_yield(LONG2NUM(i));
     }
     return ary;
 }
@@ -783,7 +783,7 @@
 rb_ary_length(ary)
     VALUE ary;
 {
-    return INT2NUM(RARRAY(ary)->len);
+    return LONG2NUM(RARRAY(ary)->len);
 }
 
 static VALUE
@@ -1408,7 +1408,7 @@
 
     if (block_p) {
 	while (p < pend) {
-	    *p++ = rb_yield(INT2NUM(beg++));
+	    *p++ = rb_yield(LONG2NUM(beg++));
 	}
     }
     else {
@@ -1767,7 +1767,7 @@
 	if (!NIL_P(*p)) n++;
 	p++;
     }
-    return INT2NUM(n);
+    return LONG2NUM(n);
 }
 
 static long
Index: bignum.c
===================================================================
RCS file: /src/ruby/bignum.c,v
retrieving revision 1.74
diff -u -r1.74 bignum.c
--- bignum.c	2002/08/19 05:56:05	1.74
+++ bignum.c	2002/08/21 11:21:26
@@ -108,9 +108,9 @@
 	    }
 	    if (num >= 0) {
 		if (RBIGNUM(x)->sign) {
-		    if (POSFIXABLE(num)) return INT2FIX(num);
+		    if (POSFIXABLE(num)) return LONG2FIX(num);
 		}
-		else if (NEGFIXABLE(-(long)num)) return INT2FIX(-(long)num);
+		else if (NEGFIXABLE(-(long)num)) return LONG2FIX(-(long)num);
 	    }
 	}
     }
@@ -133,7 +133,6 @@
     BDIGIT *digits;
     VALUE big;
 
-    i = 0;
     big = bignew(DIGSPERLONG, 1);
     digits = BDIGITS(big);
     while (i < DIGSPERLONG) {
@@ -169,7 +168,7 @@
 rb_uint2inum(n)
     unsigned long n;
 {
-    if (POSFIXABLE(n)) return INT2FIX(n);
+    if (POSFIXABLE(n)) return LONG2FIX(n);
     return rb_uint2big(n);
 }
 
@@ -177,7 +176,7 @@
 rb_int2inum(n)
     long n;
 {
-    if (FIXABLE(n)) return INT2FIX(n);
+    if (FIXABLE(n)) return LONG2FIX(n);
     return rb_int2big(n);
 }
 
@@ -217,20 +216,20 @@
 {
     unsigned LONG_LONG q;
     long neg = 0;
-    long i = 0;
+    long i;
     BDIGIT *digits;
     VALUE big;
 
     memcpy(&q, buf, SIZEOF_LONG_LONG);
     if (sign) {
-	if (FIXABLE((LONG_LONG)q)) return INT2FIX((LONG_LONG)q);
+	if (FIXABLE((LONG_LONG)q)) return LONG2FIX((LONG_LONG)q);
 	if ((LONG_LONG)q < 0) {
 	    q = -(LONG_LONG)q;
 	    neg = 1;
 	}
     }
     else {
-	if (POSFIXABLE(q)) return INT2FIX(q);
+	if (POSFIXABLE(q)) return LONG2FIX(q);
     }
 
     i = 0;
@@ -410,10 +409,10 @@
 	}
 
 	if (POSFIXABLE(val)) {
-	    if (sign) return INT2FIX(val);
+	    if (sign) return LONG2FIX(val);
 	    else {
 		long result = -(long)val;
-		return INT2FIX(result);
+		return LONG2FIX(result);
 	    }
 	}
 	else {
@@ -498,7 +497,7 @@
     int badcheck;
 {
     char *s;
-    int len;
+    long len;
 
     StringValue(str);
     s = RSTRING(str)->ptr;
@@ -527,7 +526,6 @@
     BDIGIT *digits;
     VALUE big;
 
-    i = 0;
     big = bignew(DIGSPERLL, 1);
     digits = BDIGITS(big);
     while (i < DIGSPERLL) {
@@ -563,7 +561,7 @@
 rb_ull2inum(n)
     unsigned LONG_LONG n;
 {
-    if (POSFIXABLE(n)) return INT2FIX(n);
+    if (POSFIXABLE(n)) return LONG2FIX(n);
     return rb_ull2big(n);
 }
 
@@ -571,7 +569,7 @@
 rb_ll2inum(n)
     LONG_LONG n;
 {
-    if (FIXABLE(n)) return INT2FIX(n);
+    if (FIXABLE(n)) return LONG2FIX(n);
     return rb_ll2big(n);
 }
 
@@ -937,9 +935,8 @@
     VALUE z = 0;
     BDIGIT *zds;
     BDIGIT_DBL_SIGNED num;
-    long i;
-
-    i = RBIGNUM(x)->len;
+    long i = RBIGNUM(x)->len;
+    
     /* if x is larger than y, swap */
     if (RBIGNUM(x)->len < RBIGNUM(y)->len) {
 	z = x; x = y; y = z;	/* swap x y */
@@ -1585,12 +1582,11 @@
 {
     BDIGIT *xds, *zds;
     int shift = NUM2INT(y);
-    int s1 = shift/BITSPERDIG;
-    int s2 = shift%BITSPERDIG;
+    long s1 = shift/BITSPERDIG;
+    long s2 = shift%BITSPERDIG;
     VALUE z;
     BDIGIT_DBL num = 0;
-    long i = RBIGNUM(x)->len;
-    long j;
+    long i, j;
 
     if (shift < 0) return rb_big_lshift(x, INT2FIX(-shift));
 
@@ -1625,7 +1621,7 @@
 {
     BDIGIT *xds;
     int shift;
-    int s1, s2;
+    long s1, s2;
 
     if (TYPE(y) == T_BIGNUM) {
 	if (!RBIGNUM(y)->sign || RBIGNUM(x)->sign)
@@ -1662,7 +1658,7 @@
     for (i=0; i<len; i++) {
 	key ^= *digits++;
     }
-    return INT2FIX(key);
+    return LONG2FIX(key);
 }
 
 static VALUE
@@ -1697,9 +1693,8 @@
     double *rand_buf;
 {
     VALUE v;
-    long len;
-
-    len = RBIGNUM(max)->len;
+    long len = RBIGNUM(max)->len;
+    
     if (len == 0 && BDIGITS(max)[0] == 0) {
 	return rb_float_new(rand_buf[0]);
     }
@@ -1715,7 +1710,7 @@
 rb_big_size(big)
     VALUE big;
 {
-    return INT2FIX(RBIGNUM(big)->len*SIZEOF_BDIGITS);
+    return LONG2FIX(RBIGNUM(big)->len*SIZEOF_BDIGITS);
 }
 
 void
Index: error.c
===================================================================
RCS file: /src/ruby/error.c,v
retrieving revision 1.46
diff -u -r1.46 error.c
--- error.c	2002/08/15 11:49:39	1.46
+++ error.c	2002/08/21 11:21:28
@@ -378,7 +378,7 @@
 check_backtrace(bt)
     VALUE bt;
 {
-    int i;
+    long i;
     static char *err = "backtrace must be Array of String";
 
     if (!NIL_P(bt)) {
Index: eval.c
===================================================================
RCS file: /src/ruby/eval.c,v
retrieving revision 1.317
diff -u -r1.317 eval.c
--- eval.c	2002/08/21 08:30:05	1.317
+++ eval.c	2002/08/21 11:21:42
@@ -949,7 +949,7 @@
     VALUE errat = Qnil;		/* OK */
     volatile VALUE eclass;
     char *einfo;
-    int elen;
+    long elen;
 
     if (NIL_P(ruby_errinfo)) return;
 
@@ -1028,7 +1028,7 @@
     }
 
     if (!NIL_P(errat)) {
-	int i;
+	long i;
 	struct RArray *ep = RARRAY(errat);
 
 #define TRACE_MAX (TRACE_HEAD+TRACE_TAIL+5)
@@ -2337,7 +2337,7 @@
 		}
 		if (nd_type(tag->nd_head) == NODE_WHEN) {
 		    VALUE v = rb_eval(self, tag->nd_head->nd_head);
-		    int i;
+		    long i;
 
 		    if (TYPE(v) != T_ARRAY) v = rb_ary_to_ary(v);
 		    for (i=0; i<RARRAY(v)->len; i++) {
@@ -2380,7 +2380,7 @@
 		    }
 		    if (nd_type(tag->nd_head) == NODE_WHEN) {
 			VALUE v = rb_eval(self, tag->nd_head->nd_head);
-			int i;
+			long i;
 
 			if (TYPE(v) != T_ARRAY) v = rb_ary_to_ary(v);
 			for (i=0; i<RARRAY(v)->len; i++) {
@@ -3070,7 +3070,7 @@
       case NODE_ARRAY:
 	{
 	    VALUE ary;
-	    int i;
+	    long i;
 
 	    i = node->nd_alen;
 	    ary = rb_ary_new2(i);
@@ -3424,7 +3424,7 @@
     int state;
     struct FRAME frame;
     VALUE result;		/* OK */
-    NODE * cnode = ruby_current_node;
+    NODE * cnode = ruby_current_node; /* NOT IN USE, is it OK? */
     TMP_PROTECT;
 
     frame = *ruby_frame;
@@ -4764,7 +4764,7 @@
     int argc;
     VALUE *argv;
 
-    argc = RARRAY(args)->len;
+    argc = RARRAY(args)->len; /* Assigns LONG, but argc is INT */
     argv = ALLOCA_N(VALUE, argc);
     MEMCPY(argv, RARRAY(args)->ptr, VALUE, argc);
     return rb_call(CLASS_OF(recv), recv, mid, argc, argv, 1);
@@ -4788,7 +4788,6 @@
     return vid;
 }
 
-
 #ifdef HAVE_STDARG_PROTOTYPES
 #include <stdarg.h>
 #define va_init_list(a,b) va_start(a,b)
@@ -4812,7 +4811,7 @@
     VALUE *argv;
 
     if (n > 0) {
-	int i;
+	long i;
 
 	argv = ALLOCA_N(VALUE, n);
 
@@ -4940,7 +4939,7 @@
 void
 rb_backtrace()
 {
-    int i;
+    long i;
     VALUE ary;
 
     ary = backtrace(-1);
@@ -5446,7 +5445,7 @@
 {
     VALUE v;
     char *f;
-    int i, len = strlen(feature);
+    long i, len = strlen(feature);
 
     for (i = 0; i < RARRAY(rb_features)->len; ++i) {
 	v = RARRAY(rb_features)->ptr[i];
@@ -5609,7 +5608,7 @@
 
 	    SCOPE_SET(SCOPE_PUBLIC);
 	    handle = dln_load(RSTRING(fname)->ptr);
-	    rb_ary_push(ruby_dln_librefs, INT2NUM((long)handle));
+	    rb_ary_push(ruby_dln_librefs, LONG2NUM((long)handle));
 	}
 	POP_TAG();
 	SCOPE_SET(old_vmode);
Index: file.c
===================================================================
RCS file: /src/ruby/file.c,v
retrieving revision 1.104
diff -u -r1.104 file.c
--- file.c	2002/08/20 10:42:33	1.104
+++ file.c	2002/08/21 11:21:46
@@ -85,7 +85,7 @@
     VALUE vargs;
     void *arg;
 {
-    int i;
+    long i;
     VALUE path;
     struct RArray *args = RARRAY(vargs);
 
@@ -2427,7 +2427,7 @@
     char *path, *found;
     char *f = RSTRING(*filep)->ptr;
     VALUE fname;
-    int i, j;
+    long i, j;
 
     if (f[0] == '~') {
 	fname = rb_file_s_expand_path(1, filep);
@@ -2508,7 +2508,7 @@
     }
 
     if (rb_load_path) {
-	int i;
+	long i;
 
 	Check_Type(rb_load_path, T_ARRAY);
 	tmp = rb_ary_new();
Index: gc.c
===================================================================
RCS file: /src/ruby/gc.c,v
retrieving revision 1.96
diff -u -r1.96 gc.c
--- gc.c	2002/08/12 07:39:08	1.96
+++ gc.c	2002/08/21 11:21:48
@@ -1415,7 +1415,8 @@
 run_final(obj)
     VALUE obj;
 {
-    int i, status;
+    long i;
+    int status;
     VALUE args[2], table;
 
     args[1] = rb_ary_new3(1, rb_obj_id(obj)); /* make obj into id */
Index: hash.c
===================================================================
RCS file: /src/ruby/hash.c,v
retrieving revision 1.74
diff -u -r1.74 hash.c
--- hash.c	2002/08/19 05:56:05	1.74
+++ hash.c	2002/08/21 11:21:52
@@ -372,8 +365,6 @@
 rb_hash_default_proc(hash)
     VALUE hash;
 {
-    VALUE key;
-
     if (FL_TEST(hash, HASH_PROC_DEFAULT)) {
 	return RHASH(hash)->ifnone;
     }
@@ -1339,7 +1330,8 @@
 {
     volatile VALUE keys;
     VALUE *ptr;
-    int len, del = 0;
+    long len;
+    int del = 0;
 
     rb_secure(4);
     keys = env_keys();
Index: io.c
===================================================================
RCS file: /src/ruby/io.c,v
retrieving revision 1.147
diff -u -r1.147 io.c
--- io.c	2002/08/21 08:30:05	1.147
+++ io.c	2002/08/21 11:21:56
@@ -672,7 +672,7 @@
     VALUE io;
 {
     OpenFile *fptr;
-    int n, len;
+    long n, len;
     VALUE length, str;
 
     rb_scan_args(argc, argv, "01", &length);
@@ -683,7 +683,7 @@
 	return read_all(fptr, remain_size(fptr));
     }
 
-    len = NUM2INT(length);
+    len = NUM2LONG(length);
     if (len < 0) {
 	rb_raise(rb_eArgError, "negative length %d given", len);
     }
@@ -859,7 +859,8 @@
     else {
 	int c, newline;
 	char *rsptr;
-	int rslen, rspara = 0;
+	long rslen;
+	int rspara = 0;
 
 	StringValue(rs);
 	rslen = RSTRING(rs)->len;
@@ -1346,7 +1347,7 @@
 {
     OpenFile *fptr;
     FILE *f;
-    int n;
+    long n;
 
     rb_secure(4);
     if (TYPE(str) != T_STRING)
@@ -1366,7 +1367,7 @@
 
     if (n == -1) rb_sys_fail(fptr->path);
 
-    return INT2FIX(n);
+    return LONG2FIX(n);
 }
 
 static VALUE
@@ -1374,10 +1375,10 @@
     VALUE io, len;
 {
     OpenFile *fptr;
-    int n, ilen;
+    long n, ilen;
     VALUE str;
 
-    ilen = NUM2INT(len);
+    ilen = NUM2LONG(len);
     GetOpenFile(io, fptr);
     rb_io_check_readable(fptr);
 
@@ -2396,7 +2397,7 @@
     VALUE ary, out;
 {
     VALUE tmp;
-    int i;
+    long i;
 
     for (i=0; i<RARRAY(ary)->len; i++) {
 	tmp = RARRAY(ary)->ptr[i];
@@ -2979,7 +2980,8 @@
     fd_set *rp, *wp, *ep;
     struct timeval *tp, timerec;
     OpenFile *fptr;
-    int i, max = 0, n;
+    long i;
+    int max = 0, n;
     int interrupt_flag = 0;
     int pending = 0;
 
@@ -3140,7 +3142,7 @@
 #if !defined(MSDOS) && !defined(__human68k__)
     int cmd = NUM2ULONG(req);
     OpenFile *fptr;
-    int len = 0;
+    long len = 0;
     long narg = 0;
     int retval;
 
@@ -3151,7 +3153,7 @@
 	narg = 0;
     }
     else if (FIXNUM_P(arg)) {
-	narg = FIX2INT(arg);
+	narg = FIX2LONG(arg);
     }
     else if (arg == Qtrue) {
 	narg = 1;
@@ -3253,10 +3255,10 @@
     rb_secure(2);
     if (argc == 0)
 	rb_raise(rb_eArgError, "too few arguments for syscall");
-    arg[0] = NUM2INT(argv[0]); argv++;
+    arg[0] = NUM2LONG(argv[0]); argv++;
     while (items--) {
 	if (FIXNUM_P(*argv)) {
-	    arg[i] = (unsigned long)NUM2INT(*argv);
+	    arg[i] = (unsigned long)NUM2LONG(*argv);
 	}
 	else {
 	    VALUE v = *argv;
@@ -3529,9 +3531,9 @@
     VALUE *argv;
 {
     VALUE tmp, str;
-    int len = 0;
+    long len = 0;
 
-    if (argc == 1) len = NUM2INT(argv[0]);
+    if (argc == 1) len = NUM2LONG(argv[0]);
     str = Qnil;
 
   retry:
@@ -3556,7 +3558,7 @@
     }
     if (RSTRING(tmp)->len < len) {
 	len -= RSTRING(tmp)->len;
-	argv[0] = INT2FIX(len);
+	argv[0] = LONG2FIX(len);
 	goto retry;
     }
 
Index: marshal.c
===================================================================
RCS file: /src/ruby/marshal.c,v
retrieving revision 1.63
diff -u -r1.63 marshal.c
--- marshal.c	2002/08/16 02:52:25	1.63
+++ marshal.c	2002/08/21 11:21:59
@@ -820,7 +820,7 @@
     switch (type) {
       case TYPE_LINK:
 	id = r_long(arg);
-	v = rb_hash_aref(arg->data, INT2FIX(id));
+	v = rb_hash_aref(arg->data, LONG2FIX(id));
 	if (NIL_P(v)) {
 	    rb_raise(rb_eArgError, "dump format error (unlinked)");
 	}
@@ -864,7 +864,7 @@
       case TYPE_FIXNUM:
 	{
 	    long i = r_long(arg);
-	    v = INT2FIX(i);
+	    v = LONG2FIX(i);
 	}
 	break;
 
@@ -1004,7 +1004,7 @@
 			     rb_id2name(slot),
 			     rb_id2name(SYM2ID(RARRAY(mem)->ptr[i])));
 		}
-		rb_struct_aset(v, INT2FIX(i), r_object(arg));
+		rb_struct_aset(v, LONG2FIX(i), r_object(arg));
 	    }
 	}
 	break;
Index: numeric.c
===================================================================
RCS file: /src/ruby/numeric.c,v
retrieving revision 1.55
diff -u -r1.55 numeric.c
--- numeric.c	2002/08/19 05:56:05	1.55
+++ numeric.c	2002/08/21 11:22:00
@@ -701,7 +701,7 @@
 	return rb_dbl2big(f);
     }
     val = f;
-    return INT2FIX(val);
+    return LONG2FIX(val);
 }
 
 static VALUE
@@ -715,7 +715,7 @@
 	return rb_dbl2big(f);
     }
     val = f;
-    return INT2FIX(val);
+    return LONG2FIX(val);
 }
 
 static VALUE
@@ -732,7 +732,7 @@
 	return rb_dbl2big(f);
     }
     val = f;
-    return INT2FIX(val);
+    return LONG2FIX(val);
 }
 
 static VALUE
@@ -749,7 +749,7 @@
 	return rb_dbl2big(f);
     }
     val = f;
-    return INT2FIX(val);
+    return LONG2FIX(val);
 }
 
 static VALUE
@@ -804,13 +804,13 @@
 
 	if (diff > 0) {
 	    while (i <= end) {
-		rb_yield(INT2FIX(i));
+		rb_yield(LONG2FIX(i));
 		i += diff;
 	    }
 	}
 	else {
 	    while (i >= end) {
-		rb_yield(INT2FIX(i));
+		rb_yield(LONG2FIX(i));
 		i += diff;
 	    }
 	}
@@ -942,7 +942,7 @@
     v = rb_num2long(val);
     if (!FIXABLE(v))
 	rb_raise(rb_eRangeError, "integer %ld out of range of fixnum", v);
-    return INT2FIX(v);
+    return LONG2FIX(v);
 }
 
 #if HAVE_LONG_LONG
@@ -1139,7 +1139,7 @@
 	a = FIX2LONG(x);
 	b = FIX2LONG(y);
 	c = a + b;
-	r = INT2FIX(c);
+	r = LONG2FIX(c);
 
 	if (FIX2LONG(r) != c) {
 	    r = rb_big_plus(rb_int2big(a), rb_int2big(b));
@@ -1163,7 +1163,7 @@
 	a = FIX2LONG(x);
 	b = FIX2LONG(y);
 	c = a - b;
-	r = INT2FIX(c);
+	r = LONG2FIX(c);
 
 	if (FIX2LONG(r) != c) {
 	    r = rb_big_minus(rb_int2big(a), rb_int2big(b));
@@ -1189,7 +1189,7 @@
 
 	b = FIX2LONG(y);
 	c = a * b;
-	r = INT2FIX(c);
+	r = LONG2FIX(c);
 
 	if (FIX2LONG(r) != c || c/a != b) {
 	    r = rb_big_mul(rb_int2big(a), rb_int2big(b));
@@ -1239,7 +1239,7 @@
 	long div;
 
 	fixdivmod(FIX2LONG(x), FIX2LONG(y), &div, 0);
-	return INT2NUM(div);
+	return LONG2NUM(div);
     }
     return rb_num_coerce_bin(x, y);
 }
@@ -1252,7 +1252,7 @@
 	long mod;
 
 	fixdivmod(FIX2LONG(x), FIX2LONG(y), 0, &mod);
-	return INT2NUM(mod);
+	return LONG2NUM(mod);
     }
     return rb_num_coerce_bin(x, y);
 }
@@ -1266,7 +1266,7 @@
 
 	fixdivmod(FIX2LONG(x), FIX2LONG(y), &div, &mod);
 
-	return rb_assoc_new(INT2NUM(div), INT2NUM(mod));
+	return rb_assoc_new(LONG2NUM(div), LONG2NUM(mod));
     }
     return rb_num_coerce_bin(x, y);
 }
@@ -1438,7 +1438,7 @@
     val = NUM2LONG(x);
     width = NUM2LONG(y);
     if (width < 0)
-	return fix_rshift(x, INT2FIX(-width));
+	return fix_rshift(x, LONG2FIX(-width));
     if (width > (sizeof(VALUE)*CHAR_BIT-1)
 	|| ((unsigned long)val)>>(sizeof(VALUE)*CHAR_BIT-1-width) > 0) {
 	return rb_big_lshift(rb_int2big(val), y);
@@ -1455,7 +1455,7 @@
 
     i = NUM2LONG(y);
     if (i < 0)
-	return fix_lshift(x, INT2FIX(-i));
+	return fix_lshift(x, LONG2FIX(-i));
     if (i == 0) return x;
     val = FIX2LONG(x);
     if (i >= sizeof(long)*CHAR_BIT-1) {
@@ -1463,7 +1463,7 @@
 	return INT2FIX(0);
     }
     val = RSHIFT(val, i);
-    return INT2FIX(val);
+    return LONG2FIX(val);
 }
 
 static VALUE
@@ -1540,7 +1540,7 @@
 
 	end = FIX2LONG(to);
 	for (i = FIX2LONG(from); i <= end; i++) {
-	    rb_yield(INT2FIX(i));
+	    rb_yield(LONG2FIX(i));
 	}
     }
     else {
@@ -1564,7 +1564,7 @@
 
 	end = FIX2LONG(to);
 	for (i=FIX2LONG(from); i >= end; i--) {
-	    rb_yield(INT2FIX(i));
+	    rb_yield(LONG2FIX(i));
 	}
     }
     else {
@@ -1588,7 +1588,7 @@
 
 	end = FIX2LONG(num);
 	for (i=0; i<end; i++) {
-	    rb_yield(INT2FIX(i));
+	    rb_yield(LONG2FIX(i));
 	}
     }
     else {
Index: object.c
===================================================================
RCS file: /src/ruby/object.c,v
retrieving revision 1.83
diff -u -r1.83 object.c
--- object.c	2002/08/19 05:56:05	1.83
+++ object.c	2002/08/21 11:22:03
@@ -68,7 +68,7 @@
     VALUE obj;
 {
     if (SPECIAL_CONST_P(obj)) {
-	return INT2NUM((long)obj);
+	return LONG2NUM((long)obj);
     }
     return (VALUE)((long)obj|FIXNUM_FLAG);
 }
@@ -472,7 +472,7 @@
 {
     ID id = SYM2ID(sym);
 
-    return INT2FIX(id);
+    return LONG2FIX(id);
 }
 
 static VALUE
@@ -731,7 +731,7 @@
       case T_STRING:
 	return rb_intern(RSTRING(name)->ptr);
       case T_FIXNUM:
-	id = FIX2INT(name);
+	id = FIX2LONG(name);
 	if (!rb_id2name(id)) {
 	    rb_raise(rb_eArgError, "%d is not a symbol", id);
 	}
@@ -1050,7 +1050,7 @@
     int badcheck;
 {
     char *s;
-    int len;
+    long len;
 
     StringValue(str);
     s = RSTRING(str)->ptr;
@@ -1133,7 +1133,7 @@
 char*
 rb_str2cstr(str, len)
     VALUE str;
-    int *len;
+    long *len;
 {
     StringValue(str);
     if (len) *len = RSTRING(str)->len;
Index: pack.c
===================================================================
RCS file: /src/ruby/pack.c,v
retrieving revision 1.41
diff -u -r1.41 pack.c
--- pack.c	2002/06/28 14:53:03	1.41
+++ pack.c	2002/08/21 11:22:05
@@ -338,9 +338,8 @@
     char *p, *pend;
     VALUE res, from, associates = 0;
     char type;
-    long items, len, idx;
+    long items, len, idx, plen;
     char *ptr;
-    int plen;
 #ifdef NATINT_PACK
     int natint;		/* native integer */
 #endif
@@ -1074,7 +1073,8 @@
     char *p, *pend;
     VALUE ary;
     char type;
-    int len, tmp, star;
+    long len;
+    int tmp, star;
 #ifdef NATINT_PACK
     int natint;			/* native integer */
 #endif
@@ -1493,7 +1493,7 @@
 	    {
 		VALUE buf = infected_str_new(0, (send - s)*3/4, str);
 		char *ptr = RSTRING(buf)->ptr;
-		int total = 0;
+		long total = 0;
 
 		while (s < send && *s > ' ' && *s < 'a') {
 		    long a,b,c,d;
Index: parse.y
===================================================================
RCS file: /src/ruby/parse.y,v
retrieving revision 1.205
diff -u -r1.205 parse.y
--- parse.y	2002/08/15 11:49:39	1.205
+++ parse.y	2002/08/21 11:22:13
@@ -954,7 +954,7 @@
 			if ($2 && nd_type($2) == NODE_LIT && FIXNUM_P($2->nd_lit)) {
 			    long i = FIX2LONG($2->nd_lit);
 
-			    $2->nd_lit = INT2NUM(-i);
+			    $2->nd_lit = LONG2NUM(-i);
 			    $$ = $2;
 			}
 			else {
@@ -3020,7 +3020,7 @@
 {
     int c, func, indent = 0;
     char *eos;
-    int len;
+    long len;
     VALUE str = 0, line;
 
     eos = RSTRING(here->nd_lit)->ptr;
Index: process.c
===================================================================
RCS file: /src/ruby/process.c,v
retrieving revision 1.53
diff -u -r1.53 process.c
--- process.c	2002/07/11 08:22:10	1.53
+++ process.c	2002/08/21 11:22:15
@@ -1033,9 +1033,8 @@
     VALUE obj, pid;
 {
 #if defined(HAVE_GETPGID) && !defined(__CHECKER__)
-    int i;
+    int i = getpgid(NUM2INT(pid));
 
-    i = getpgid(NUM2INT(pid));
     if (i < 0) rb_sys_fail(0);
     return INT2NUM(i);
 #else
@@ -1148,9 +1147,8 @@
 proc_setuid(obj, id)
     VALUE obj, id;
 {
-    int uid;
+    int uid = NUM2INT(id);
 
-    uid = NUM2INT(id);
 #if defined(HAVE_SETRESUID) &&  !defined(__CHECKER__)
     if (setresuid(uid, -1, -1) < 0) rb_sys_fail(0);
 #elif defined HAVE_SETREUID
@@ -1182,9 +1180,8 @@
 proc_setgid(obj, id)
     VALUE obj, id;
 {
-    int gid;
+    int gid = NUM2INT(id);
 
-    gid = NUM2INT(id);
 #if defined(HAVE_SETRESGID) && !defined(__CHECKER__)
     if (setresgid(gid, -1, -1) < 0) rb_sys_fail(0);
 #elif defined HAVE_SETREGID
@@ -1239,6 +1236,7 @@
     VALUE obj;
 {
     int egid = getegid();
+
     return INT2FIX(egid);
 }
 
Index: random.c
===================================================================
RCS file: /src/ruby/random.c,v
retrieving revision 1.23
diff -u -r1.23 random.c
--- random.c	2002/08/13 09:21:13	1.23
+++ random.c	2002/08/21 11:22:16
@@ -200,7 +200,7 @@
     }
     old = rand_init(seed);
 
-    return UINT2NUM(old);
+    return ULONG2NUM(old);
 }
 
 static VALUE
Index: range.c
===================================================================
RCS file: /src/ruby/range.c,v
retrieving revision 1.42
diff -u -r1.42 range.c
--- range.c	2002/07/30 10:22:32	1.42
+++ range.c	2002/08/21 11:22:17
@@ -247,7 +247,7 @@
 
 	if (!EXCL(range)) end += 1;
 	for (i=FIX2LONG(b); i<end; i+=unit) {
-	    rb_yield(INT2NUM(i));
+	    rb_yield(LONG2NUM(i));
 	}
     }
     else if (rb_obj_is_kind_of(b, rb_cNumeric)) {
Index: re.c
===================================================================
RCS file: /src/ruby/re.c,v
retrieving revision 1.74
diff -u -r1.74 re.c
--- re.c	2002/08/20 07:36:01	1.74
+++ re.c	2002/08/21 11:22:20
@@ -66,7 +66,7 @@
         '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
 };
 #else
->>> "You lose. You will need a translation table for your character set." <<<
+# error >>> "You lose. You will need a translation table for your character set." <<<
 #endif
 
 #define MIN(a,b) (((a)>(b))?(b):(a))
@@ -217,7 +217,7 @@
 rb_reg_expr_str(str, s, len)
     VALUE str;
     const char *s;
-    int len;
+    long len;
 {
     const char *p, *pend;
     int need_escape = 0;
@@ -274,7 +274,7 @@
 static VALUE
 rb_reg_desc(s, len, re)
     const char *s;
-    int len;
+    long len;
     VALUE re;
 {
     VALUE str = rb_str_buf_new2("/");
@@ -425,7 +425,7 @@
 static void
 rb_reg_raise(s, len, err, re)
     const char *s;
-    int len;
+    long len;
     const char *err;
     VALUE re;
 {
@@ -482,7 +482,8 @@
 static Regexp*
 make_regexp(s, len, flags)
     const char *s;
-    int len, flags;
+    long len;
+    int flags;
 {
     Regexp *rp;
     char *err;
@@ -503,10 +504,10 @@
 	rp->options = flags;
     }
     err = re_compile_pattern(s, len, rp);
+
     if (err != NULL) {
 	rb_reg_raise(s, len, err, 0);
     }
-
     return rp;
 }
 
@@ -650,12 +651,12 @@
     }
 }
 
-int
+long
 rb_reg_adjust_startpos(re, str, pos, reverse)
     VALUE re, str;
-    int pos, reverse;
+    long pos, reverse;
 {
-    int range;
+    long range;
 
     rb_reg_check(re);
     if (may_need_recompile) rb_reg_prepare_re(re);
@@ -676,15 +677,15 @@
 			      pos, range);
 }
 
-int
+long
 rb_reg_search(re, str, pos, reverse)
     VALUE re, str;
-    int pos, reverse;
+    long pos, reverse;
 {
-    int result;
+    long result;
     VALUE match;
     static struct re_registers regs;
-    int range;
+    long range;
 
     if (pos > RSTRING(str)->len || pos < 0) {
 	rb_backref_set(Qnil);
@@ -948,7 +949,7 @@
 rb_reg_initialize(obj, s, len, options)
     VALUE obj;
     const char *s;
-    int len;
+    long len;
     int options;		/* CASEFOLD  = 1 */
 				/* EXTENDED  = 2 */
 				/* MULTILINE = 4 */
Index: re.h
===================================================================
RCS file: /src/ruby/re.h,v
retrieving revision 1.13
diff -u -r1.13 re.h
--- re.h	2002/07/26 06:12:39	1.13
+++ re.h	2002/08/21 11:22:20
@@ -29,9 +29,9 @@
 #define RMATCH(obj)  (R_CAST(RMatch)(obj))
 
 VALUE rb_reg_regcomp _((VALUE));
-int rb_reg_search _((VALUE, VALUE, int, int));
+long rb_reg_search _((VALUE, VALUE, long, long));
 VALUE rb_reg_regsub _((VALUE, VALUE, struct re_registers *));
-int rb_reg_adjust_startpos _((VALUE, VALUE, int, int));
+long rb_reg_adjust_startpos _((VALUE, VALUE, long, long));
 void rb_match_busy _((VALUE));
 VALUE rb_reg_quote _((VALUE));
 
Index: regex.h
===================================================================
RCS file: /src/ruby/regex.h,v
retrieving revision 1.17
diff -u -r1.17 regex.h
--- regex.h	2002/04/24 04:54:14	1.17
+++ regex.h	2002/08/21 11:22:20
@@ -185,7 +185,6 @@
   regoff_t rm_eo;  /* Byte offset from string's start to substring's end.  */
 } regmatch_t;
 
-
 #ifdef __STDC__
 
 extern char *re_compile_pattern (const char *, int, struct re_pattern_buffer *);
Index: ruby.c
===================================================================
RCS file: /src/ruby/ruby.c,v
retrieving revision 1.63
diff -u -r1.63 ruby.c
--- ruby.c	2002/08/12 13:39:22	1.63
+++ ruby.c	2002/08/21 11:22:21
@@ -338,7 +338,7 @@
 process_sflag()
 {
     if (sflag) {
-	int n;
+	long n;
 	VALUE *args;
 
 	n = RARRAY(rb_argv)->len;
@@ -881,7 +881,7 @@
     ID id;
 {
     char *s;
-    int i;
+    long i;
     static int len;
 
     if (origargv == 0) rb_raise(rb_eRuntimeError, "$0 not initialized");
Index: ruby.h
===================================================================
RCS file: /src/ruby/ruby.h,v
retrieving revision 1.66
diff -u -r1.66 ruby.h
--- ruby.h	2002/05/14 06:22:26	1.66
+++ ruby.h	2002/08/21 11:22:23
@@ -261,7 +261,7 @@
 #define NUM2DBL(x) rb_num2dbl((VALUE)(x))
 
 /* obsolete API - use StringValue() */
-char *rb_str2cstr _((VALUE,int*));
+char *rb_str2cstr _((VALUE,long*));
 /* obsolete API - use StringValuePtr() */
 #define STR2CSTR(x) rb_str2cstr((VALUE)(x),0)
 
Index: sprintf.c
===================================================================
RCS file: /src/ruby/sprintf.c,v
retrieving revision 1.23
diff -u -r1.23 sprintf.c
--- sprintf.c	2002/06/04 07:34:15	1.23
+++ sprintf.c	2002/08/21 11:22:23
@@ -256,7 +256,7 @@
 	  case 's':
 	    {
 		VALUE arg = GETARG();
-		int len;
+		long len;
 
 		str = rb_obj_as_string(arg);
 		if (OBJ_TAINTED(str)) tainted = 1;
Index: string.c
===================================================================
RCS file: /src/ruby/string.c,v
retrieving revision 1.110
diff -u -r1.110 string.c
--- string.c	2002/08/06 06:20:43	1.110
+++ string.c	2002/08/21 11:22:28
@@ -359,7 +359,7 @@
 rb_str_length(str)
     VALUE str;
 {
-    return INT2NUM(RSTRING(str)->len);
+    return LONG2NUM(RSTRING(str)->len);
 }
 
 static VALUE
@@ -875,7 +875,7 @@
 	  char *p = RSTRING(str)->ptr;
 
 	  for (;pos<len;pos++) {
-	      if (p[pos] == c) return INT2NUM(pos);
+	      if (p[pos] == c) return LONG2NUM(pos);
 	  }
 	  return Qnil;
       }
@@ -886,7 +886,7 @@
     }
 
     if (pos == -1) return Qnil;
-    return INT2NUM(pos);
+    return LONG2NUM(pos);
 }
 
 static long
@@ -927,10 +927,10 @@
 {
     VALUE sub;
     VALUE position;
-    int pos;
+    long pos;
 
     if (rb_scan_args(argc, argv, "11", &sub, &position) == 2) {
-	pos = NUM2INT(position);
+	pos = NUM2LONG(position);
         if (pos < 0) {
 	    pos += RSTRING(str)->len;
 	    if (pos < 0) {
@@ -952,12 +952,12 @@
 	    pos = rb_reg_adjust_startpos(sub, str, pos, 1);
 	    pos = rb_reg_search(sub, str, pos, 1);
 	}
-	if (pos >= 0) return INT2NUM(pos);
+	if (pos >= 0) return LONG2NUM(pos);
 	break;
 
       case T_STRING:
 	pos = rb_str_rindex(str, sub, pos);
-	if (pos >= 0) return INT2NUM(pos);
+	if (pos >= 0) return LONG2NUM(pos);
 	break;
 
       case T_FIXNUM:
@@ -967,7 +967,7 @@
 	  char *pbeg = RSTRING(str)->ptr;
 
 	  while (pbeg <= p) {
-	      if (*p == c) return INT2NUM(p - RSTRING(str)->ptr);
+	      if (*p == c) return LONG2NUM(p - RSTRING(str)->ptr);
 	      p--;
 	  }
 	  return Qnil;
@@ -995,7 +995,7 @@
 	if (start == -1) {
 	    return Qnil;
 	}
-	return INT2NUM(start);
+	return LONG2NUM(start);
 
       default:
 	return rb_funcall(y, rb_intern("=~"), 1, x);
@@ -1197,7 +1197,7 @@
 	if (TYPE(argv[0]) == T_REGEXP) {
 	    return rb_str_subpat(str, argv[0], NUM2INT(argv[1]));
 	}
-	return rb_str_substr(str, NUM2INT(argv[0]), NUM2INT(argv[1]));
+	return rb_str_substr(str, NUM2LONG(argv[0]), NUM2LONG(argv[1]));
     }
     if (argc != 1) {
 	rb_raise(rb_eArgError, "wrong number of arguments(%d for 1)", argc);
@@ -1208,8 +1208,7 @@
 void
 rb_str_update(str, beg, len, val)
     VALUE str;
-    long beg;
-    long len;
+    long beg, len;
     VALUE val;
 {
     if (len < 0) rb_raise(rb_eIndexError, "negative length %ld", len);
@@ -1293,7 +1292,7 @@
     switch (TYPE(indx)) {
       case T_FIXNUM:
       num_index:
-	idx = NUM2INT(indx);
+	idx = NUM2LONG(indx);
 	if (RSTRING(str)->len <= idx) {
 	  out_of_range:
 	    rb_raise(rb_eIndexError, "index %ld out of string", idx);
@@ -1353,7 +1352,7 @@
 	    rb_str_subpat_set(str, argv[0], NUM2INT(argv[1]), argv[2]);
 	}
 	else {
-	    rb_str_update(str, NUM2INT(argv[0]), NUM2INT(argv[1]), argv[2]);
+	    rb_str_update(str, NUM2LONG(argv[0]), NUM2LONG(argv[1]), argv[2]);
 	}
 	return argv[2];
     }
@@ -2615,10 +2614,9 @@
 {
     VALUE rs;
     int newline;
-    int rslen;
     char *p = RSTRING(str)->ptr, *pend = p + RSTRING(str)->len, *s;
     char *ptr = p;
-    long len = RSTRING(str)->len;
+    long len = RSTRING(str)->len, rslen;
     VALUE line;
 
     if (rb_scan_args(argc, argv, "01", &rs) == 0) {
@@ -2733,9 +2731,8 @@
 {
     VALUE rs;
     int newline;
-    int rslen;
     char *p = RSTRING(str)->ptr;
-    long len = RSTRING(str)->len;
+    long len = RSTRING(str)->len, rslen;
 
     if (rb_scan_args(argc, argv, "01", &rs) == 0) {
 	if (len == 0) return Qnil;
Index: struct.c
===================================================================
RCS file: /src/ruby/struct.c,v
retrieving revision 1.33
diff -u -r1.33 struct.c
--- struct.c	2002/05/14 06:22:26	1.33
+++ struct.c	2002/08/21 11:22:30
@@ -166,7 +166,7 @@
 	}
 	nstr = rb_define_class_under(klass, cname, klass);
     }
-    rb_iv_set(nstr, "__size__", INT2NUM(RARRAY(member)->len));
+    rb_iv_set(nstr, "__size__", LONG2NUM(RARRAY(member)->len));
     rb_iv_set(nstr, "__member__", member);
 
     rb_define_singleton_method(nstr, "allocate", struct_alloc, 0);
@@ -576,7 +576,7 @@
 rb_struct_size(s)
     VALUE s;
 {
-    return INT2FIX(RSTRUCT(s)->len);
+    return LONG2FIX(RSTRUCT(s)->len);
 }
 
 void
Index: time.c
===================================================================
RCS file: /src/ruby/time.c,v
retrieving revision 1.62
diff -u -r1.62 time.c
--- time.c	2002/08/19 05:56:05	1.62
+++ time.c	2002/08/21 11:22:33
@@ -688,7 +688,7 @@
     struct time_object *tobj;
 
     GetTimeval(time, tobj);
-    return INT2NUM(tobj->tv.tv_usec);
+    return LONG2NUM(tobj->tv.tv_usec);
 }
 
 static VALUE
@@ -783,7 +783,7 @@
 
     GetTimeval(time, tobj);
     hash = tobj->tv.tv_sec ^ tobj->tv.tv_usec;
-    return INT2FIX(hash);
+    return LONG2FIX(hash);
 }
 
 static VALUE
@@ -1276,9 +1276,8 @@
 {
     struct time_object *tobj;
     char buffer[SMALLBUF];
-    char *fmt;
-    char *buf = buffer;
-    int len;
+    char *fmt, *buf = buffer;
+    long len;
     VALUE str;
 
     GetTimeval(time, tobj);
Index: util.c
===================================================================
RCS file: /src/ruby/util.c,v
retrieving revision 1.27
diff -u -r1.27 util.c
--- util.c	2002/05/29 05:20:33	1.27
+++ util.c	2002/08/21 11:22:34
@@ -166,7 +166,7 @@
     int baselen;
     int extlen = strlen(suffix);
     char *s, *t, *p;
-    int slen;
+    long slen;
     char buf[1024];
 
     if (RSTRING(str)->len > 1000)

Thread

Prev Next

In This Thread

Prev Next

[#290] — Florian Frank <flori@...>

[#291] Kernel Thread implementation — Matthew Bloch <mattbee@...>

[#297] GC longjmp macros — Michal Rokos <m.rokos@...>

[#298] Is there a bug in Matrix or Complex? — Jim Freeze <jim@...>

[#308] Q: OSSL in std. distr? — Michal Rokos <m.rokos@...>

[#309] Progress on incremental GC? — "Timothy J. Wood" <tjw@...>

[#314] resolv.rb on 1.6.7 — Dave Thomas <Dave@...>

[#316] Embeding Ruby in C++ code. — Kostas Katsamakas <kmak@...>

[#318] C and Ruby... — Kostas Katsamakas <kmak@...>

[#321] Ruby module, Warn(ing) interface — Michal Rokos <m.rokos@...>

[#326] Implications of a #force_free method in Object? — Matthew Bloch <mattbee@...>

[#328] Int vs Long — Michal Rokos <m.rokos@...>

[#329] Int vs Long #2 — Michal Rokos <m.rokos@...>

[#337] Int vs Long (2nd part) — Michal Rokos <m.rokos@...>

[#340] Int vs Long #3 — Michal Rokos <m.rokos@...>

[#345] Bug in gc.c or misunderstanding on my part? — "Timothy J. Wood" <tjw@...>

[#349] Array#select — Michal Rokos <m.rokos@...>

[#353] File (struct stat handling) — Michal Rokos <m.rokos@...>

[#355] Array and .*ALLOC.* changes — Michal Rokos <m.rokos@...>

[#358] node.h for eval.c — Michal Rokos <m.rokos@...>

[#363] Ruby embedding limitations — "Timothy J. Wood" <tjw@...>

[#367] RE: Welcome to our (ruby-core ML) You are added automatically — Girish Sharangpani <girishs@...>

[#372] rb_class_path — Michal Rokos <m.rokos@...>

[#376] Virtual host and port number in CGI — Raymond Blum <raymond@...>

[#382] Port match to new dup, clone framework — Michal Rokos <m.rokos@...>

[#387] rb_str_replace — Michal Rokos <m.rokos@...>

[#392] io.c read_all — Michal Rokos <m.rokos@...>

[#393] in dln.c — Michal Rokos <m.rokos@...>

[#394] in file.c — Michal Rokos <m.rokos@...>

[#395] CVS version and win32 naming — "Rich Kilmer" <rich@...>

[Cleanup?] Int vs Long #2

Attachments (1)

Thread

In This Thread

[#355] Array and .ALLOC. changes — Michal Rokos <m.rokos@...>