kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

* ruby.h (struct RArray): embed small arrays.

Browse source 
(RARRAY_LEN): defined for accessing array members.
  (RARRAY_PTR): ditto.

* array.c: use RARRAY_LEN and RARRAY_PTR.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10833 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
matz 2006-09-02 14:42:08 +00:00
parent 8581164ea6
commit 2156870525
39 changed files with 804 additions and 684 deletions
Download patch file Download diff file Expand all files Collapse all files

8
ChangeLog
View file

@ -1,3 +1,11 @@
Sat Sep 2 23:37:29 2006 Yukihiro Matsumoto <matz@ruby-lang.org>
* ruby.h (struct RArray): embed small arrays.
(RARRAY_LEN): defined for accessing array members.
(RARRAY_PTR): ditto.
* array.c: use RARRAY_LEN and RARRAY_PTR.
Sat Sep 2 13:23:01 2006 Tanaka Akira <akr@fsij.org> Sat Sep 2 13:23:01 2006 Tanaka Akira <akr@fsij.org>
* common.mk (ia64.o): use the compiler driver to assemble ia64.s * common.mk (ia64.o): use the compiler driver to assemble ia64.s

746
array.c
View file

File diff suppressed because it is too large Load diff

2
dir.c
View file

@ -1630,7 +1630,7 @@ dir_s_glob(int argc, VALUE *argv, VALUE obj)
} }
else { else {
volatile VALUE v = ary; volatile VALUE v = ary;
ary = dir_globs(RARRAY(ary)->len, RARRAY(ary)->ptr, flags); ary = dir_globs(RARRAY_LEN(ary), RARRAY_PTR(ary), flags);
} }
if (rb_block_given_p()) { if (rb_block_given_p()) {

16
enum.c
View file

@ -644,21 +644,21 @@ enum_sort_by(VALUE obj)
RETURN_ENUMERATOR(obj, 0, 0); RETURN_ENUMERATOR(obj, 0, 0);
if (TYPE(obj) == T_ARRAY) { if (TYPE(obj) == T_ARRAY) {
ary = rb_ary_new2(RARRAY(obj)->len); ary = rb_ary_new2(RARRAY_LEN(obj));
} }
else { else {
ary = rb_ary_new(); ary = rb_ary_new();
} }
RBASIC(ary)->klass = 0; RBASIC(ary)->klass = 0;
rb_block_call(obj, id_each, 0, 0, sort_by_i, ary); rb_block_call(obj, id_each, 0, 0, sort_by_i, ary);
if (RARRAY(ary)->len > 1) { if (RARRAY_LEN(ary) > 1) {
ruby_qsort(RARRAY(ary)->ptr, RARRAY(ary)->len, sizeof(VALUE), sort_by_cmp, 0); ruby_qsort(RARRAY_PTR(ary), RARRAY_LEN(ary), sizeof(VALUE), sort_by_cmp, 0);
} }
if (RBASIC(ary)->klass) { if (RBASIC(ary)->klass) {
rb_raise(rb_eRuntimeError, "sort_by reentered"); rb_raise(rb_eRuntimeError, "sort_by reentered");
} }
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
RARRAY(ary)->ptr[i] = RNODE(RARRAY(ary)->ptr[i])->u2.value; RARRAY_PTR(ary)[i] = RNODE(RARRAY_PTR(ary)[i])->u2.value;
} }
RBASIC(ary)->klass = rb_cArray; RBASIC(ary)->klass = rb_cArray;
return ary; return ary;
@ -1131,10 +1131,10 @@ zip_i(VALUE val, VALUE *memo)
VALUE tmp; VALUE tmp;
int i; int i;
tmp = rb_ary_new2(RARRAY(args)->len + 1); tmp = rb_ary_new2(RARRAY_LEN(args) + 1);
rb_ary_store(tmp, 0, val); rb_ary_store(tmp, 0, val);
for (i=0; i<RARRAY(args)->len; i++) { for (i=0; i<RARRAY_LEN(args); i++) {
rb_ary_push(tmp, rb_ary_entry(RARRAY(args)->ptr[i], idx)); rb_ary_push(tmp, rb_ary_entry(RARRAY_PTR(args)[i], idx));
} }
if (rb_block_given_p()) { if (rb_block_given_p()) {
rb_yield(tmp); rb_yield(tmp);

16
enumerator.c
View file

@ -122,7 +122,7 @@ each_slice_i(VALUE val, VALUE *memo)
rb_ary_push(ary, val); rb_ary_push(ary, val);
if (RARRAY(ary)->len == size) { if (RARRAY_LEN(ary) == size) {
rb_yield(ary); rb_yield(ary);
memo[0] = rb_ary_new2(size); memo[0] = rb_ary_new2(size);
} }
@ -159,7 +159,7 @@ enum_each_slice(VALUE obj, VALUE n)
rb_block_call(obj, rb_intern("each"), 0, 0, each_slice_i, (VALUE)args); rb_block_call(obj, rb_intern("each"), 0, 0, each_slice_i, (VALUE)args);
ary = args[0]; ary = args[0];
if (RARRAY(ary)->len > 0) rb_yield(ary); if (RARRAY_LEN(ary) > 0) rb_yield(ary);
return Qnil; return Qnil;
} }
@ -183,11 +183,11 @@ each_cons_i(VALUE val, VALUE *memo)
VALUE ary = memo[0]; VALUE ary = memo[0];
long size = (long)memo[1]; long size = (long)memo[1];
if (RARRAY(ary)->len == size) { if (RARRAY_LEN(ary) == size) {
rb_ary_shift(ary); rb_ary_shift(ary);
} }
rb_ary_push(ary, val); rb_ary_push(ary, val);
if (RARRAY(ary)->len == size) { if (RARRAY_LEN(ary) == size) {
rb_yield(rb_ary_dup(ary)); rb_yield(rb_ary_dup(ary));
} }
return Qnil; return Qnil;
@ -321,8 +321,8 @@ enumerator_each(VALUE obj)
if (!rb_block_given_p()) return obj; if (!rb_block_given_p()) return obj;
e = enumerator_ptr(obj); e = enumerator_ptr(obj);
if (e->args) { if (e->args) {
argc = RARRAY(e->args)->len; argc = RARRAY_LEN(e->args);
argv = RARRAY(e->args)->ptr; argv = RARRAY_PTR(e->args);
} }
return rb_block_call(e->method, rb_intern("call"), argc, argv, e->iter, (VALUE)e); return rb_block_call(e->method, rb_intern("call"), argc, argv, e->iter, (VALUE)e);
} }
@ -352,8 +352,8 @@ enumerator_with_index(VALUE obj)
VALUE *argv = 0; VALUE *argv = 0;
if (e->args) { if (e->args) {
argc = RARRAY(e->args)->len; argc = RARRAY_LEN(e->args);
argv = RARRAY(e->args)->ptr; argv = RARRAY_PTR(e->args);
} }
return rb_block_call(e->method, rb_intern("call"), argc, argv, return rb_block_call(e->method, rb_intern("call"), argc, argv,
enumerator_with_index_i, (VALUE)&memo); enumerator_with_index_i, (VALUE)&memo);

4
error.c
View file

@ -443,8 +443,8 @@ check_backtrace(VALUE bt)
if (t != T_ARRAY) { if (t != T_ARRAY) {
rb_raise(rb_eTypeError, err); rb_raise(rb_eTypeError, err);
} }
for (i=0;i<RARRAY(bt)->len;i++) { for (i=0;i<RARRAY_LEN(bt);i++) {
if (TYPE(RARRAY(bt)->ptr[i]) != T_STRING) { if (TYPE(RARRAY_PTR(bt)[i]) != T_STRING) {
rb_raise(rb_eTypeError, err); rb_raise(rb_eTypeError, err);
} }
} }

121
eval.c
View file

@ -1238,11 +1238,11 @@ error_print(void)
else else
warn_printf("%d", ruby_sourceline); warn_printf("%d", ruby_sourceline);
} }
else if (RARRAY(errat)->len == 0) { else if (RARRAY_LEN(errat) == 0) {
error_pos(); error_pos();
} }
else { else {
VALUE mesg = RARRAY(errat)->ptr[0]; VALUE mesg = RARRAY_PTR(errat)[0];
if (NIL_P(mesg)) error_pos(); if (NIL_P(mesg)) error_pos();
else { else {
@ -1298,21 +1298,19 @@ error_print(void)
if (!NIL_P(errat)) { if (!NIL_P(errat)) {
long i; long i;
struct RArray *ep = RARRAY(errat);
#define TRACE_MAX (TRACE_HEAD+TRACE_TAIL+5) #define TRACE_MAX (TRACE_HEAD+TRACE_TAIL+5)
#define TRACE_HEAD 8 #define TRACE_HEAD 8
#define TRACE_TAIL 5 #define TRACE_TAIL 5
ep = RARRAY(errat); for (i=1; i<RARRAY_LEN(errat); i++) {
for (i=1; i<ep->len; i++) { if (TYPE(RARRAY_PTR(errat)[i]) == T_STRING) {
if (TYPE(ep->ptr[i]) == T_STRING) { warn_printf("\tfrom %s\n", RSTRING_PTR(RARRAY_PTR(errat)[i]));
warn_printf("\tfrom %s\n", RSTRING_PTR(ep->ptr[i]));
} }
if (i == TRACE_HEAD && ep->len > TRACE_MAX) { if (i == TRACE_HEAD && RARRAY_LEN(errat) > TRACE_MAX) {
warn_printf("\t ... %ld levels...\n", warn_printf("\t ... %ld levels...\n",
ep->len - TRACE_HEAD - TRACE_TAIL); RARRAY_LEN(errat) - TRACE_HEAD - TRACE_TAIL);
i = ep->len - TRACE_TAIL; i = RARRAY_LEN(errat) - TRACE_TAIL;
} }
} }
} }
@ -1793,7 +1791,7 @@ rb_eval_cmd(VALUE cmd, VALUE arg, int level)
ruby_safe_level = level; ruby_safe_level = level;
if ((state = EXEC_TAG()) == 0) { if ((state = EXEC_TAG()) == 0) {
val = rb_funcall2(cmd, rb_intern("yield"), val = rb_funcall2(cmd, rb_intern("yield"),
RARRAY(arg)->len, RARRAY(arg)->ptr); RARRAY_LEN(arg), RARRAY_PTR(arg));
} }
ruby_safe_level = safe; ruby_safe_level = safe;
POP_TAG(); POP_TAG();
@ -1889,7 +1887,7 @@ rb_mod_nesting(void)
if (!NIL_P(cbase->nd_clss)) rb_ary_push(ary, cbase->nd_clss); if (!NIL_P(cbase->nd_clss)) rb_ary_push(ary, cbase->nd_clss);
cbase = cbase->nd_next; cbase = cbase->nd_next;
} }
if (ruby_wrapper && RARRAY(ary)->len == 0) { if (ruby_wrapper && RARRAY_LEN(ary) == 0) {
rb_ary_push(ary, ruby_wrapper); rb_ary_push(ary, ruby_wrapper);
} }
return ary; return ary;
@ -2185,9 +2183,9 @@ copy_node_scope(NODE *node, NODE *rval)
VALUE args = rb_eval(self,n);\ VALUE args = rb_eval(self,n);\
if (TYPE(args) != T_ARRAY)\ if (TYPE(args) != T_ARRAY)\
args = rb_ary_to_ary(args);\ args = rb_ary_to_ary(args);\
argc = RARRAY(args)->len;\ argc = RARRAY_LEN(args);\
argv = TMP_ALLOC(argc+extra);\ argv = TMP_ALLOC(argc+extra);\
MEMCPY(argv, RARRAY(args)->ptr, VALUE, argc);\ MEMCPY(argv, RARRAY_PTR(args), VALUE, argc);\
}\ }\
if (bpass) {\ if (bpass) {\
volatile VALUE save_block = rb_eval(self, bpass->nd_body); \ volatile VALUE save_block = rb_eval(self, bpass->nd_body); \
@ -2201,11 +2199,11 @@ copy_node_scope(NODE *node, NODE *rval)
argc = ruby_frame->argc;\ argc = ruby_frame->argc;\
if (argc && DMETHOD_P()) {\ if (argc && DMETHOD_P()) {\
if (TYPE(RBASIC(ruby_scope)->klass) != T_ARRAY ||\ if (TYPE(RBASIC(ruby_scope)->klass) != T_ARRAY ||\
RARRAY(RBASIC(ruby_scope)->klass)->len != argc) {\ RARRAY_LEN(RBASIC(ruby_scope)->klass) != argc) {\
rb_raise(rb_eRuntimeError, \ rb_raise(rb_eRuntimeError, \
"super: specify arguments explicitly");\ "super: specify arguments explicitly");\
}\ }\
argv = RARRAY(RBASIC(ruby_scope)->klass)->ptr;\ argv = RARRAY_PTR(RBASIC(ruby_scope)->klass);\
}\ }\
else {\ else {\
argv = ruby_scope->local_vars + 2;\ argv = ruby_scope->local_vars + 2;\
@ -2713,8 +2711,8 @@ when_check(NODE *tag, VALUE val, VALUE self)
break; break;
case NODE_SPLAT: case NODE_SPLAT:
elm = svalue_to_avalue(rb_eval(self, tag->nd_head)); elm = svalue_to_avalue(rb_eval(self, tag->nd_head));
for (i=0; i<RARRAY(elm)->len; i++) { for (i=0; i<RARRAY_LEN(elm); i++) {
if (when_cond(val, RARRAY(elm)->ptr[i])) { if (when_cond(val, RARRAY_PTR(elm)[i])) {
return Qtrue; return Qtrue;
} }
} }
@ -3624,8 +3622,7 @@ rb_eval(VALUE self, NODE *n)
i = node->nd_alen; i = node->nd_alen;
ary = rb_ary_new2(i); ary = rb_ary_new2(i);
for (i=0;node;node=node->nd_next) { for (i=0;node;node=node->nd_next) {
RARRAY(ary)->ptr[i++] = rb_eval(self, node->nd_head); rb_ary_push(ary, rb_eval(self, node->nd_head));
RARRAY(ary)->len = i;
} }
result = ary; result = ary;
@ -3640,8 +3637,7 @@ rb_eval(VALUE self, NODE *n)
i = node->nd_alen; i = node->nd_alen;
val = rb_ary_new2(i); val = rb_ary_new2(i);
for (i=0;node;node=node->nd_next) { for (i=0;node;node=node->nd_next) {
RARRAY(val)->ptr[i++] = rb_eval(self, node->nd_head); rb_ary_push(val, rb_eval(self, node->nd_head));
RARRAY(val)->len = i;
} }
result = val; result = val;
@ -4746,16 +4742,16 @@ rb_yield_0(VALUE val, VALUE self, VALUE klass /* OK */, int flags)
if (TYPE(val) != T_ARRAY) { if (TYPE(val) != T_ARRAY) {
rb_raise(rb_eArgError, "wrong number of arguments (1 for 0)"); rb_raise(rb_eArgError, "wrong number of arguments (1 for 0)");
} }
else if (RARRAY(val)->len != 0) { else if (RARRAY_LEN(val) != 0) {
rb_raise(rb_eArgError, "wrong number of arguments (%ld for 0)", rb_raise(rb_eArgError, "wrong number of arguments (%ld for 0)",
RARRAY(val)->len); RARRAY_LEN(val));
} }
} }
} }
else if (var == (NODE*)2) { else if (var == (NODE*)2) {
if (TYPE(val) == T_ARRAY && RARRAY(val)->len != 0) { if (TYPE(val) == T_ARRAY && RARRAY_LEN(val) != 0) {
rb_raise(rb_eArgError, "wrong number of arguments (%ld for 0)", rb_raise(rb_eArgError, "wrong number of arguments (%ld for 0)",
RARRAY(val)->len); RARRAY_LEN(val));
} }
} }
else if (!bvar && nd_type(var) == NODE_BLOCK_PASS) { else if (!bvar && nd_type(var) == NODE_BLOCK_PASS) {
@ -4765,7 +4761,7 @@ rb_yield_0(VALUE val, VALUE self, VALUE klass /* OK */, int flags)
} }
else if (nd_type(var) == NODE_ARGS) { else if (nd_type(var) == NODE_ARGS) {
if (!ary_args) val = svalue_to_avalue(val); if (!ary_args) val = svalue_to_avalue(val);
formal_assign(self, var, RARRAY(val)->len, RARRAY(val)->ptr, 0); formal_assign(self, var, RARRAY_LEN(val), RARRAY_PTR(val), 0);
} }
else if (nd_type(var) == NODE_BLOCK) { else if (nd_type(var) == NODE_BLOCK) {
if (var->nd_next) { if (var->nd_next) {
@ -4782,16 +4778,16 @@ rb_yield_0(VALUE val, VALUE self, VALUE klass /* OK */, int flags)
if (val == Qundef) { if (val == Qundef) {
rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)"); rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
} }
if (TYPE(val) == T_ARRAY && RARRAY(val)->len != 1) { if (TYPE(val) == T_ARRAY && RARRAY_LEN(val) != 1) {
rb_raise(rb_eArgError, "wrong number of arguments (%ld for 1)", rb_raise(rb_eArgError, "wrong number of arguments (%ld for 1)",
RARRAY(val)->len); RARRAY_LEN(val));
} }
} }
if (ary_args) { if (ary_args) {
if (RARRAY(val)->len == 0) if (RARRAY_LEN(val) == 0)
val = Qnil; val = Qnil;
else else
val = RARRAY(val)->ptr[0]; val = RARRAY_PTR(val)[0];
} }
assign(self, var, val, lambda); assign(self, var, val, lambda);
} }
@ -4811,11 +4807,11 @@ rb_yield_0(VALUE val, VALUE self, VALUE klass /* OK */, int flags)
POP_TAG(); POP_TAG();
if (state) goto pop_state; if (state) goto pop_state;
} }
else if (lambda && ary_args && RARRAY(val)->len != 0 && else if (lambda && ary_args && RARRAY_LEN(val) != 0 &&
(!node || nd_type(node) != NODE_IFUNC || (!node || nd_type(node) != NODE_IFUNC ||
node->nd_cfnc != bmcall)) { node->nd_cfnc != bmcall)) {
rb_raise(rb_eArgError, "wrong number of arguments (%ld for 0)", rb_raise(rb_eArgError, "wrong number of arguments (%ld for 0)",
RARRAY(val)->len); RARRAY_LEN(val));
} }
if (!node) { if (!node) {
state = 0; state = 0;
@ -4939,9 +4935,8 @@ rb_yield_values(int n, ...)
val = rb_ary_new2(n); val = rb_ary_new2(n);
va_start(args, n); va_start(args, n);
for (i=0; i<n; i++) { for (i=0; i<n; i++) {
RARRAY(val)->ptr[i] = va_arg(args, VALUE); rb_ary_push(val, va_arg(args, VALUE));
} }
RARRAY(val)->len = n;
va_end(args); va_end(args);
return rb_yield_0(val, 0, 0, 0); return rb_yield_0(val, 0, 0, 0);
} }
@ -4989,8 +4984,8 @@ massign(VALUE self, NODE *node, VALUE val, int pcall)
len = (val == Qundef) ? 0 : 1; len = (val == Qundef) ? 0 : 1;
} }
else { else {
argv = RARRAY(tmp)->ptr; argv = RARRAY_PTR(tmp);
len = RARRAY(tmp)->len; len = RARRAY_LEN(tmp);
} }
} }
list = node->nd_head; list = node->nd_head;
@ -5112,7 +5107,7 @@ assign(VALUE self, NODE *lhs, VALUE val, int pcall)
ruby_current_node = lhs; ruby_current_node = lhs;
SET_CURRENT_SOURCE(); SET_CURRENT_SOURCE();
rb_call(CLASS_OF(recv), recv, lhs->nd_mid, rb_call(CLASS_OF(recv), recv, lhs->nd_mid,
RARRAY(args)->len, RARRAY(args)->ptr, 0, scope,0); RARRAY_LEN(args), RARRAY_PTR(args), 0, scope,0);
} }
} }
break; break;
@ -5127,18 +5122,18 @@ assign(VALUE self, NODE *lhs, VALUE val, int pcall)
assign(self, lhs->nd_args, val, 0); assign(self, lhs->nd_args, val, 0);
} }
cnt = lhs->nd_head->nd_alen; cnt = lhs->nd_head->nd_alen;
if (RARRAY(val)->len < cnt) { if (RARRAY_LEN(val) < cnt) {
if (pcall) { if (pcall) {
rb_raise(rb_eArgError, "wrong number of arguments"); rb_raise(rb_eArgError, "wrong number of arguments");
} }
else { else {
while (RARRAY(val)->len < cnt) { while (RARRAY_LEN(val) < cnt) {
v = v->nd_next; v = v->nd_next;
cnt--; cnt--;
} }
} }
} }
p = RARRAY(val)->ptr + RARRAY(val)->len - cnt; p = RARRAY_PTR(val) + RARRAY_LEN(val) - cnt;
while (cnt--) { while (cnt--) {
assign(self, v->nd_head, *p++, 0); assign(self, v->nd_head, *p++, 0);
v = v->nd_next; v = v->nd_next;
@ -5505,10 +5500,10 @@ method_missing(VALUE obj, ID id, int argc, const VALUE *argv,
argc = -argc-1; argc = -argc-1;
tmp = svalue_to_avalue(argv[argc]); tmp = svalue_to_avalue(argv[argc]);
nargv = ALLOCA_N(VALUE, argc + RARRAY(tmp)->len + 1); nargv = ALLOCA_N(VALUE, argc + RARRAY_LEN(tmp) + 1);
MEMCPY(nargv+1, argv, VALUE, argc); MEMCPY(nargv+1, argv, VALUE, argc);
MEMCPY(nargv+1+argc, RARRAY(tmp)->ptr, VALUE, RARRAY(tmp)->len); MEMCPY(nargv+1+argc, RARRAY_PTR(tmp), VALUE, RARRAY_LEN(tmp));
argc += RARRAY(tmp)->len; argc += RARRAY_LEN(tmp);
} }
else { else {
@ -5614,7 +5609,7 @@ formal_assign(VALUE recv, NODE *node, int argc, const VALUE *argv, VALUE *local_
rb_bug("no argument-node"); rb_bug("no argument-node");
} }
i = node->nd_frml ? RARRAY(node->nd_frml)->len : 0; i = node->nd_frml ? RARRAY_LEN(node->nd_frml) : 0;
if (i > argc) { if (i > argc) {
rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, i); rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, i);
} }
@ -5641,7 +5636,7 @@ formal_assign(VALUE recv, NODE *node, int argc, const VALUE *argv, VALUE *local_
VALUE a = node->nd_frml; VALUE a = node->nd_frml;
for (j=0; j<i; j++) { for (j=0; j<i; j++) {
dvar_asgn_curr(SYM2ID(RARRAY(a)->ptr[j]), argv[j]); dvar_asgn_curr(SYM2ID(RARRAY_PTR(a)[j]), argv[j]);
} }
} }
argv += i; argc -= i; argv += i; argc -= i;
@ -5722,11 +5717,11 @@ rb_call0(VALUE klass, VALUE recv, ID id, ID oid,
argc %= 256; argc %= 256;
tmp = svalue_to_avalue(argv[argc]); tmp = svalue_to_avalue(argv[argc]);
nargv = TMP_ALLOC(argc + RARRAY(tmp)->len + n); nargv = TMP_ALLOC(argc + RARRAY_LEN(tmp) + n);
MEMCPY(nargv, argv, VALUE, argc); MEMCPY(nargv, argv, VALUE, argc);
MEMCPY(nargv+argc, RARRAY(tmp)->ptr, VALUE, RARRAY(tmp)->len); MEMCPY(nargv+argc, RARRAY_PTR(tmp), VALUE, RARRAY_LEN(tmp));
MEMCPY(nargv + argc + RARRAY(tmp)->len, argv + argc + 1, VALUE, n); MEMCPY(nargv + argc + RARRAY_LEN(tmp), argv + argc + 1, VALUE, n);
argc += RARRAY(tmp)->len + n; argc += RARRAY_LEN(tmp) + n;
argv = nargv; argv = nargv;
} }
switch (nd_type(body)) { switch (nd_type(body)) {
@ -5988,9 +5983,9 @@ rb_apply(VALUE recv, ID mid, VALUE args)
int argc; int argc;
VALUE *argv; VALUE *argv;
argc = RARRAY(args)->len; /* Assigns LONG, but argc is INT */ argc = RARRAY_LEN(args); /* Assigns LONG, but argc is INT */
argv = ALLOCA_N(VALUE, argc); argv = ALLOCA_N(VALUE, argc);
MEMCPY(argv, RARRAY(args)->ptr, VALUE, argc); MEMCPY(argv, RARRAY_PTR(args), VALUE, argc);
return rb_call(CLASS_OF(recv), recv, mid, argc, argv, 0, CALLING_FUNCALL, 0); return rb_call(CLASS_OF(recv), recv, mid, argc, argv, 0, CALLING_FUNCALL, 0);
} }
@ -6217,8 +6212,8 @@ rb_backtrace(void)
VALUE ary; VALUE ary;
ary = backtrace(-1); ary = backtrace(-1);
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
printf("\tfrom %s\n", RSTRING_PTR(RARRAY(ary)->ptr[i])); printf("\tfrom %s\n", RSTRING_PTR(RARRAY_PTR(ary)[i]));
} }
} }
@ -6355,9 +6350,9 @@ eval(VALUE self, VALUE src, VALUE scope, const char *file, int line)
if (!NIL_P(errat) && TYPE(errat) == T_ARRAY) { if (!NIL_P(errat) && TYPE(errat) == T_ARRAY) {
if (!NIL_P(mesg) && TYPE(mesg) == T_STRING) { if (!NIL_P(mesg) && TYPE(mesg) == T_STRING) {
rb_str_update(mesg, 0, 0, rb_str_new2(": ")); rb_str_update(mesg, 0, 0, rb_str_new2(": "));
rb_str_update(mesg, 0, 0, RARRAY(errat)->ptr[0]); rb_str_update(mesg, 0, 0, RARRAY_PTR(errat)[0]);
} }
RARRAY(errat)->ptr[0] = RARRAY(backtrace(-2))->ptr[0]; RARRAY_PTR(errat)[0] = RARRAY_PTR(backtrace(-2))[0];
} }
} }
rb_exc_raise(ruby_errinfo); rb_exc_raise(ruby_errinfo);
@ -6841,8 +6836,8 @@ rb_feature_p(const char *feature, const char *ext, int rb)
len = strlen(feature); len = strlen(feature);
elen = 0; elen = 0;
} }
for (i = 0; i < RARRAY(rb_features)->len; ++i) { for (i = 0; i < RARRAY_LEN(rb_features); ++i) {
v = RARRAY(rb_features)->ptr[i]; v = RARRAY_PTR(rb_features)[i];
f = StringValuePtr(v); f = StringValuePtr(v);
if (strncmp(f, feature, len) != 0) continue; if (strncmp(f, feature, len) != 0) continue;
if (!*(e = f + len)) { if (!*(e = f + len)) {
@ -8465,7 +8460,7 @@ proc_invoke(VALUE proc, VALUE args /* OK */, VALUE self, VALUE klass, int call)
_block.block_obj = bvar; _block.block_obj = bvar;
if (self != Qundef) _block.frame.self = self; if (self != Qundef) _block.frame.self = self;
if (klass) _block.frame.this_class = klass; if (klass) _block.frame.this_class = klass;
_block.frame.argc = call ? RARRAY(args)->len : 1; _block.frame.argc = call ? RARRAY_LEN(args) : 1;
_block.frame.flags = ruby_frame->flags; _block.frame.flags = ruby_frame->flags;
if (_block.frame.argc && (ruby_frame->flags & FRAME_DMETH)) { if (_block.frame.argc && (ruby_frame->flags & FRAME_DMETH)) {
NEWOBJ(scope, struct SCOPE); NEWOBJ(scope, struct SCOPE);
@ -9248,7 +9243,7 @@ rb_node_arity(NODE *body)
if (nd_type(body) == NODE_BLOCK) if (nd_type(body) == NODE_BLOCK)
body = body->nd_head; body = body->nd_head;
if (!body) return 0; if (!body) return 0;
n = body->nd_frml ? RARRAY(body->nd_frml)->len : 0; n = body->nd_frml ? RARRAY_LEN(body->nd_frml) : 0;
if (body->nd_opt) if (body->nd_opt)
return -n-1; return -n-1;
if (body->nd_rest) { if (body->nd_rest) {
@ -9399,7 +9394,7 @@ bmcall(VALUE args, VALUE method)
VALUE ret; VALUE ret;
a = svalue_to_avalue(args); a = svalue_to_avalue(args);
ret = rb_method_call(RARRAY(a)->len, RARRAY(a)->ptr, method); ret = rb_method_call(RARRAY_LEN(a), RARRAY_PTR(a), method);
a = Qnil; /* prevent tail call */ a = Qnil; /* prevent tail call */
return ret; return ret;
} }
@ -11115,7 +11110,7 @@ rb_thread_join(rb_thread_t th, double limit)
VALUE errat = make_backtrace(); VALUE errat = make_backtrace();
VALUE errinfo = rb_obj_dup(th->errinfo); VALUE errinfo = rb_obj_dup(th->errinfo);
if (TYPE(oldbt) == T_ARRAY && RARRAY(oldbt)->len > 0) { if (TYPE(oldbt) == T_ARRAY && RARRAY_LEN(oldbt) > 0) {
rb_ary_unshift(errat, rb_ary_entry(oldbt, 0)); rb_ary_unshift(errat, rb_ary_entry(oldbt, 0));
} }
set_backtrace(errinfo, errat); set_backtrace(errinfo, errat);
@ -12010,7 +12005,7 @@ rb_thread_start_1(void)
if ((state = EXEC_TAG()) == 0) { if ((state = EXEC_TAG()) == 0) {
if (THREAD_SAVE_CONTEXT(th) == 0) { if (THREAD_SAVE_CONTEXT(th) == 0) {
new_thread.thread = 0; new_thread.thread = 0;
th->result = rb_proc_yield(RARRAY(arg)->len, RARRAY(arg)->ptr, proc); th->result = rb_proc_yield(RARRAY_LEN(arg), RARRAY_PTR(arg), proc);
} }
th = th_save; th = th_save;
} }

10
ext/Win32API/Win32API.c
View file

@ -72,8 +72,8 @@ Win32API_initialize(self, dllname, proc, import, export)
case T_NIL: case T_NIL:
break; break;
case T_ARRAY: case T_ARRAY:
ptr = RARRAY(import)->ptr; ptr = RARRAY_PTR(import);
for (i = 0, len = RARRAY(import)->len; i < len; i++) { for (i = 0, len = RARRAY_LEN(import); i < len; i++) {
SafeStringValue(ptr[i]); SafeStringValue(ptr[i]);
switch (*(char *)RSTRING_PTR(ptr[i])) { switch (*(char *)RSTRING_PTR(ptr[i])) {
case 'N': case 'n': case 'L': case 'l': case 'N': case 'n': case 'L': case 'l':
@ -107,8 +107,8 @@ Win32API_initialize(self, dllname, proc, import, export)
break; break;
} }
if (16 < RARRAY(a_import)->len) { if (16 < RARRAY_LEN(a_import)) {
rb_raise(rb_eRuntimeError, "too many parameters: %d\n", RARRAY(a_import)->len); rb_raise(rb_eRuntimeError, "too many parameters: %d\n", RARRAY_LEN(a_import));
} }
rb_iv_set(self, "__import__", a_import); rb_iv_set(self, "__import__", a_import);
@ -159,7 +159,7 @@ Win32API_Call(argc, argv, obj)
VALUE obj_export = rb_iv_get(obj, "__export__"); VALUE obj_export = rb_iv_get(obj, "__export__");
FARPROC ApiFunction = (FARPROC)NUM2ULONG(obj_proc); FARPROC ApiFunction = (FARPROC)NUM2ULONG(obj_proc);
int items = rb_scan_args(argc, argv, "0*", &args); int items = rb_scan_args(argc, argv, "0*", &args);
int nimport = RARRAY(obj_import)->len; int nimport = RARRAY_LEN(obj_import);
if (items != nimport) if (items != nimport)

10
ext/dbm/dbm.c
View file

@ -345,8 +345,8 @@ fdbm_delete_if(VALUE obj)
GetDBM2(obj, dbmp, dbm); GetDBM2(obj, dbmp, dbm);
} }
for (i = 0; i < RARRAY(ary)->len; i++) { for (i = 0; i < RARRAY_LEN(ary); i++) {
keystr = RARRAY(ary)->ptr[i]; keystr = RARRAY_PTR(ary)[i];
StringValue(keystr); StringValue(keystr);
key.dptr = RSTRING_PTR(keystr); key.dptr = RSTRING_PTR(keystr);
key.dsize = RSTRING_LEN(keystr); key.dsize = RSTRING_LEN(keystr);
@ -355,7 +355,7 @@ fdbm_delete_if(VALUE obj)
} }
} }
if (status) rb_jump_tag(status); if (status) rb_jump_tag(status);
if (n > 0) dbmp->di_size = n - RARRAY(ary)->len; if (n > 0) dbmp->di_size = n - RARRAY_LEN(ary);
return obj; return obj;
} }
@ -405,10 +405,10 @@ static VALUE
update_i(VALUE pair, VALUE dbm) update_i(VALUE pair, VALUE dbm)
{ {
Check_Type(pair, T_ARRAY); Check_Type(pair, T_ARRAY);
if (RARRAY(pair)->len < 2) { if (RARRAY_LEN(pair) < 2) {
rb_raise(rb_eArgError, "pair must be [key, value]"); rb_raise(rb_eArgError, "pair must be [key, value]");
} }
fdbm_store(dbm, RARRAY(pair)->ptr[0], RARRAY(pair)->ptr[1]); fdbm_store(dbm, RARRAY_PTR(pair)[0], RARRAY_PTR(pair)[1]);
return Qnil; return Qnil;
} }

6
ext/dl/cfunc.c
View file

@ -226,7 +226,7 @@ rb_dlcfunc_inspect(VALUE self)
# define DECL_FUNC_CDECL(f,ret,args) ret (FUNC_CDECL(*f))(args) # define DECL_FUNC_CDECL(f,ret,args) ret (FUNC_CDECL(*f))(args)
# define DECL_FUNC_STDCALL(f,ret,args) ret (FUNC_STDCALL(*f))(args) # define DECL_FUNC_STDCALL(f,ret,args) ret (FUNC_STDCALL(*f))(args)
#define CALL_CASE switch( RARRAY(ary)->len ){ \ #define CALL_CASE switch( RARRAY_LEN(ary) ){ \
CASE(0); break; \ CASE(0); break; \
CASE(1); break; CASE(2); break; CASE(3); break; CASE(4); break; CASE(5); break; \ CASE(1); break; CASE(2); break; CASE(3); break; CASE(4); break; CASE(5); break; \
CASE(6); break; CASE(7); break; CASE(8); break; CASE(9); break; CASE(10);break; \ CASE(6); break; CASE(7); break; CASE(8); break; CASE(9); break; CASE(10);break; \
@ -256,11 +256,11 @@ rb_dlcfunc_call(VALUE self, VALUE ary)
return Qnil; return Qnil;
} }
for( i = 0; i < RARRAY(ary)->len; i++ ){ for( i = 0; i < RARRAY_LEN(ary); i++ ){
if( i >= DLSTACK_SIZE ){ if( i >= DLSTACK_SIZE ){
rb_raise(rb_eDLError, "too many arguments (stack overflow)"); rb_raise(rb_eDLError, "too many arguments (stack overflow)");
} }
stack[i] = NUM2LONG(RARRAY(ary)->ptr[i]); stack[i] = NUM2LONG(RARRAY_PTR(ary)[i]);
} }
/* calltype == CFUNC_CDECL */ /* calltype == CFUNC_CDECL */

10
ext/gdbm/gdbm.c
View file

@ -414,10 +414,10 @@ fgdbm_delete_if(VALUE obj)
GetDBM2(obj, dbmp, dbm); GetDBM2(obj, dbmp, dbm);
} }
for (i = 0; i < RARRAY(ary)->len; i++) for (i = 0; i < RARRAY_LEN(ary); i++)
rb_gdbm_delete(obj, RARRAY(ary)->ptr[i]); rb_gdbm_delete(obj, RARRAY_PTR(ary)[i]);
if (status) rb_jump_tag(status); if (status) rb_jump_tag(status);
if (n > 0) dbmp->di_size = n - RARRAY(ary)->len; if (n > 0) dbmp->di_size = n - RARRAY_LEN(ary);
return obj; return obj;
} }
@ -508,10 +508,10 @@ static VALUE
update_i(VALUE pair, VALUE dbm) update_i(VALUE pair, VALUE dbm)
{ {
Check_Type(pair, T_ARRAY); Check_Type(pair, T_ARRAY);
if (RARRAY(pair)->len < 2) { if (RARRAY_LEN(pair) < 2) {
rb_raise(rb_eArgError, "pair must be [key, value]"); rb_raise(rb_eArgError, "pair must be [key, value]");
} }
fgdbm_store(dbm, RARRAY(pair)->ptr[0], RARRAY(pair)->ptr[1]); fgdbm_store(dbm, RARRAY_PTR(pair)[0], RARRAY_PTR(pair)[1]);
return Qnil; return Qnil;
} }

8
ext/iconv/iconv.c
View file

@ -350,7 +350,7 @@ iconv_convert(iconv_t cd, VALUE str, int start, int length, struct iconv_env_t*
unsigned int i; unsigned int i;
rescue = iconv_fail(error, Qnil, Qnil, env, 0); rescue = iconv_fail(error, Qnil, Qnil, env, 0);
if (TYPE(rescue) == T_ARRAY) { if (TYPE(rescue) == T_ARRAY) {
str = RARRAY(rescue)->len > 0 ? RARRAY(rescue)->ptr[0] : Qnil; str = RARRAY_LEN(rescue) > 0 ? RARRAY_PTR(rescue)[0] : Qnil;
} }
if (FIXNUM_P(str) && (i = FIX2INT(str)) <= 0xff) { if (FIXNUM_P(str) && (i = FIX2INT(str)) <= 0xff) {
char c = i; char c = i;
@ -434,9 +434,9 @@ iconv_convert(iconv_t cd, VALUE str, int start, int length, struct iconv_env_t*
str = rb_str_derive(str, inptr, inlen); str = rb_str_derive(str, inptr, inlen);
rescue = iconv_fail(error, ret, str, env, errmsg); rescue = iconv_fail(error, ret, str, env, errmsg);
if (TYPE(rescue) == T_ARRAY) { if (TYPE(rescue) == T_ARRAY) {
if ((len = RARRAY(rescue)->len) > 0) if ((len = RARRAY_LEN(rescue)) > 0)
rb_str_concat(ret, RARRAY(rescue)->ptr[0]); rb_str_concat(ret, RARRAY_PTR(rescue)[0]);
if (len > 1 && !NIL_P(str = RARRAY(rescue)->ptr[1])) { if (len > 1 && !NIL_P(str = RARRAY_PTR(rescue)[1])) {
StringValue(str); StringValue(str);
inlen = length = RSTRING_LEN(str); inlen = length = RSTRING_LEN(str);
instart = inptr = RSTRING_PTR(str); instart = inptr = RSTRING_PTR(str);

2
ext/openssl/ossl.c
View file

@ -59,7 +59,7 @@ ossl_x509_ary2sk0(VALUE ary)
sk = sk_X509_new_null(); sk = sk_X509_new_null();
if (!sk) ossl_raise(eOSSLError, NULL); if (!sk) ossl_raise(eOSSLError, NULL);
for (i = 0; i < RARRAY(ary)->len; i++) { for (i = 0; i < RARRAY_LEN(ary); i++) {
val = rb_ary_entry(ary, i); val = rb_ary_entry(ary, i);
if (!rb_obj_is_kind_of(val, cX509Cert)) { if (!rb_obj_is_kind_of(val, cX509Cert)) {
sk_X509_pop_free(sk, X509_free); sk_X509_pop_free(sk, X509_free);

8
ext/openssl/ossl_ocsp.c
View file

@ -461,8 +461,8 @@ ossl_ocspbres_add_status(VALUE self, VALUE cid, VALUE status,
if(!NIL_P(ext)){ if(!NIL_P(ext)){
/* All ary's members should be X509Extension */ /* All ary's members should be X509Extension */
Check_Type(ext, T_ARRAY); Check_Type(ext, T_ARRAY);
for (i = 0; i < RARRAY(ext)->len; i++) for (i = 0; i < RARRAY_LEN(ext); i++)
OSSL_Check_Kind(RARRAY(ext)->ptr[i], cX509Ext); OSSL_Check_Kind(RARRAY_PTR(ext)[i], cX509Ext);
} }
error = 0; error = 0;
@ -490,8 +490,8 @@ ossl_ocspbres_add_status(VALUE self, VALUE cid, VALUE status,
X509_EXTENSION *x509ext; X509_EXTENSION *x509ext;
sk_X509_EXTENSION_pop_free(single->singleExtensions, X509_EXTENSION_free); sk_X509_EXTENSION_pop_free(single->singleExtensions, X509_EXTENSION_free);
single->singleExtensions = NULL; single->singleExtensions = NULL;
for(i = 0; i < RARRAY(ext)->len; i++){ for(i = 0; i < RARRAY_LEN(ext); i++){
x509ext = DupX509ExtPtr(RARRAY(ext)->ptr[i]); x509ext = DupX509ExtPtr(RARRAY_PTR(ext)[i]);
if(!OCSP_SINGLERESP_add_ext(single, x509ext, -1)){ if(!OCSP_SINGLERESP_add_ext(single, x509ext, -1)){
X509_EXTENSION_free(x509ext); X509_EXTENSION_free(x509ext);
error = 1; error = 1;

8
ext/openssl/ossl_ssl.c
View file

@ -349,8 +349,8 @@ ossl_sslctx_setup(VALUE self)
val = ossl_sslctx_get_client_ca(self); val = ossl_sslctx_get_client_ca(self);
if(!NIL_P(val)){ if(!NIL_P(val)){
if(TYPE(val) == T_ARRAY){ if(TYPE(val) == T_ARRAY){
for(i = 0; i < RARRAY(val)->len; i++){ for(i = 0; i < RARRAY_LEN(val); i++){
client_ca = GetX509CertPtr(RARRAY(val)->ptr[i]); client_ca = GetX509CertPtr(RARRAY_PTR(val)[i]);
if (!SSL_CTX_add_client_CA(ctx, client_ca)){ if (!SSL_CTX_add_client_CA(ctx, client_ca)){
/* Copies X509_NAME => FREE it. */ /* Copies X509_NAME => FREE it. */
ossl_raise(eSSLError, "SSL_CTX_add_client_CA"); ossl_raise(eSSLError, "SSL_CTX_add_client_CA");
@ -459,12 +459,12 @@ ossl_sslctx_set_ciphers(VALUE self, VALUE v)
return v; return v;
else if (TYPE(v) == T_ARRAY) { else if (TYPE(v) == T_ARRAY) {
str = rb_str_new(0, 0); str = rb_str_new(0, 0);
for (i = 0; i < RARRAY(v)->len; i++) { for (i = 0; i < RARRAY_LEN(v); i++) {
elem = rb_ary_entry(v, i); elem = rb_ary_entry(v, i);
if (TYPE(elem) == T_ARRAY) elem = rb_ary_entry(elem, 0); if (TYPE(elem) == T_ARRAY) elem = rb_ary_entry(elem, 0);
elem = rb_String(elem); elem = rb_String(elem);
rb_str_append(str, elem); rb_str_append(str, elem);
if (i < RARRAY(v)->len-1) rb_str_cat2(str, ":"); if (i < RARRAY_LEN(v)-1) rb_str_cat2(str, ":");
} }
} else { } else {
str = v; str = v;

8
ext/openssl/ossl_x509cert.c
View file

@ -557,14 +557,14 @@ ossl_x509_set_extensions(VALUE self, VALUE ary)
Check_Type(ary, T_ARRAY); Check_Type(ary, T_ARRAY);
/* All ary's members should be X509Extension */ /* All ary's members should be X509Extension */
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
OSSL_Check_Kind(RARRAY(ary)->ptr[i], cX509Ext); OSSL_Check_Kind(RARRAY_PTR(ary)[i], cX509Ext);
} }
GetX509(self, x509); GetX509(self, x509);
sk_X509_EXTENSION_pop_free(x509->cert_info->extensions, X509_EXTENSION_free); sk_X509_EXTENSION_pop_free(x509->cert_info->extensions, X509_EXTENSION_free);
x509->cert_info->extensions = NULL; x509->cert_info->extensions = NULL;
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
ext = DupX509ExtPtr(RARRAY(ary)->ptr[i]); ext = DupX509ExtPtr(RARRAY_PTR(ary)[i]);
if (!X509_add_ext(x509, ext, -1)) { /* DUPs ext - FREE it */ if (!X509_add_ext(x509, ext, -1)) { /* DUPs ext - FREE it */
X509_EXTENSION_free(ext); X509_EXTENSION_free(ext);

16
ext/openssl/ossl_x509crl.c
View file

@ -287,14 +287,14 @@ ossl_x509crl_set_revoked(VALUE self, VALUE ary)
Check_Type(ary, T_ARRAY); Check_Type(ary, T_ARRAY);
/* All ary members should be X509 Revoked */ /* All ary members should be X509 Revoked */
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
OSSL_Check_Kind(RARRAY(ary)->ptr[i], cX509Rev); OSSL_Check_Kind(RARRAY_PTR(ary)[i], cX509Rev);
} }
GetX509CRL(self, crl); GetX509CRL(self, crl);
sk_X509_REVOKED_pop_free(crl->crl->revoked, X509_REVOKED_free); sk_X509_REVOKED_pop_free(crl->crl->revoked, X509_REVOKED_free);
crl->crl->revoked = NULL; crl->crl->revoked = NULL;
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
rev = DupX509RevokedPtr(RARRAY(ary)->ptr[i]); rev = DupX509RevokedPtr(RARRAY_PTR(ary)[i]);
if (!X509_CRL_add0_revoked(crl, rev)) { /* NO DUP - don't free! */ if (!X509_CRL_add0_revoked(crl, rev)) { /* NO DUP - don't free! */
ossl_raise(eX509CRLError, NULL); ossl_raise(eX509CRLError, NULL);
} }
@ -461,14 +461,14 @@ ossl_x509crl_set_extensions(VALUE self, VALUE ary)
Check_Type(ary, T_ARRAY); Check_Type(ary, T_ARRAY);
/* All ary members should be X509 Extensions */ /* All ary members should be X509 Extensions */
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
OSSL_Check_Kind(RARRAY(ary)->ptr[i], cX509Ext); OSSL_Check_Kind(RARRAY_PTR(ary)[i], cX509Ext);
} }
GetX509CRL(self, crl); GetX509CRL(self, crl);
sk_X509_EXTENSION_pop_free(crl->crl->extensions, X509_EXTENSION_free); sk_X509_EXTENSION_pop_free(crl->crl->extensions, X509_EXTENSION_free);
crl->crl->extensions = NULL; crl->crl->extensions = NULL;
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
ext = DupX509ExtPtr(RARRAY(ary)->ptr[i]); ext = DupX509ExtPtr(RARRAY_PTR(ary)[i]);
if(!X509_CRL_add_ext(crl, ext, -1)) { /* DUPs ext - FREE it */ if(!X509_CRL_add_ext(crl, ext, -1)) { /* DUPs ext - FREE it */
X509_EXTENSION_free(ext); X509_EXTENSION_free(ext);
ossl_raise(eX509CRLError, NULL); ossl_raise(eX509CRLError, NULL);

8
ext/openssl/ossl_x509req.c
View file

@ -403,14 +403,14 @@ ossl_x509req_set_attributes(VALUE self, VALUE ary)
VALUE item; VALUE item;
Check_Type(ary, T_ARRAY); Check_Type(ary, T_ARRAY);
for (i=0;i<RARRAY(ary)->len; i++) { for (i=0;i<RARRAY_LEN(ary); i++) {
OSSL_Check_Kind(RARRAY(ary)->ptr[i], cX509Attr); OSSL_Check_Kind(RARRAY_PTR(ary)[i], cX509Attr);
} }
GetX509Req(self, req); GetX509Req(self, req);
sk_X509_ATTRIBUTE_pop_free(req->req_info->attributes, X509_ATTRIBUTE_free); sk_X509_ATTRIBUTE_pop_free(req->req_info->attributes, X509_ATTRIBUTE_free);
req->req_info->attributes = NULL; req->req_info->attributes = NULL;
for (i=0;i<RARRAY(ary)->len; i++) { for (i=0;i<RARRAY_LEN(ary); i++) {
item = RARRAY(ary)->ptr[i]; item = RARRAY_PTR(ary)[i];
attr = DupX509AttrPtr(item); attr = DupX509AttrPtr(item);
if (!X509_REQ_add1_attr(req, attr)) { if (!X509_REQ_add1_attr(req, attr)) {
ossl_raise(eX509ReqError, NULL); ossl_raise(eX509ReqError, NULL);

8
ext/openssl/ossl_x509revoked.c
View file

@ -175,14 +175,14 @@ ossl_x509revoked_set_extensions(VALUE self, VALUE ary)
VALUE item; VALUE item;
Check_Type(ary, T_ARRAY); Check_Type(ary, T_ARRAY);
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
OSSL_Check_Kind(RARRAY(ary)->ptr[i], cX509Ext); OSSL_Check_Kind(RARRAY_PTR(ary)[i], cX509Ext);
} }
GetX509Rev(self, rev); GetX509Rev(self, rev);
sk_X509_EXTENSION_pop_free(rev->extensions, X509_EXTENSION_free); sk_X509_EXTENSION_pop_free(rev->extensions, X509_EXTENSION_free);
rev->extensions = NULL; rev->extensions = NULL;
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
item = RARRAY(ary)->ptr[i]; item = RARRAY_PTR(ary)[i];
ext = DupX509ExtPtr(item); ext = DupX509ExtPtr(item);
if(!X509_REVOKED_add_ext(rev, ext, -1)) { if(!X509_REVOKED_add_ext(rev, ext, -1)) {
ossl_raise(eX509RevError, NULL); ossl_raise(eX509RevError, NULL);

64
ext/racc/cparse/cparse.c
View file

@ -88,7 +88,7 @@ num_to_long(VALUE n)
} }
#define AREF(s, idx) \ #define AREF(s, idx) \
((0 <= idx && idx < RARRAY(s)->len) ? RARRAY(s)->ptr[idx] : Qnil) ((0 <= idx && idx < RARRAY_LEN(s)) ? RARRAY_PTR(s)[idx] : Qnil)
/* ----------------------------------------------------------------------- /* -----------------------------------------------------------------------
Parser Stack Interfaces Parser Stack Interfaces
@ -101,8 +101,8 @@ static VALUE
get_stack_tail(VALUE stack, long len) get_stack_tail(VALUE stack, long len)
{ {
if (len < 0) return Qnil; /* system error */ if (len < 0) return Qnil; /* system error */
if (len > RARRAY(stack)->len) len = RARRAY(stack)->len; if (len > RARRAY_LEN(stack)) len = RARRAY_LEN(stack);
return rb_ary_new4(len, RARRAY(stack)->ptr + RARRAY(stack)->len - len); return rb_ary_new4(len, RARRAY_PTR(stack) + RARRAY_LEN(stack) - len);
} }
static void static void
@ -116,10 +116,10 @@ cut_stack_tail(VALUE stack, long len)
#define STACK_INIT_LEN 64 #define STACK_INIT_LEN 64
#define NEW_STACK() rb_ary_new2(STACK_INIT_LEN) #define NEW_STACK() rb_ary_new2(STACK_INIT_LEN)
#define PUSH(s, i) rb_ary_store(s, RARRAY(s)->len, i) #define PUSH(s, i) rb_ary_store(s, RARRAY_LEN(s), i)
#define POP(s) rb_ary_pop(s) #define POP(s) rb_ary_pop(s)
#define LAST_I(s) \ #define LAST_I(s) \
((RARRAY(s)->len > 0) ? RARRAY(s)->ptr[RARRAY(s)->len - 1] : Qnil) ((RARRAY_LEN(s) > 0) ? RARRAY_PTR(s)[RARRAY_LEN(s) - 1] : Qnil)
#define GET_TAIL(s, len) get_stack_tail(s, len) #define GET_TAIL(s, len) get_stack_tail(s, len)
#define CUT_TAIL(s, len) cut_stack_tail(s, len) #define CUT_TAIL(s, len) cut_stack_tail(s, len)
@ -329,23 +329,23 @@ initialize_params(VALUE vparams, VALUE parser, VALUE arg, VALUE lexer, VALUE lex
v->debug = RTEST(rb_ivar_get(parser, id_yydebug)); v->debug = RTEST(rb_ivar_get(parser, id_yydebug));
Check_Type(arg, T_ARRAY); Check_Type(arg, T_ARRAY);
if (!(13 <= RARRAY(arg)->len && RARRAY(arg)->len <= 14)) if (!(13 <= RARRAY_LEN(arg) && RARRAY_LEN(arg) <= 14))
rb_raise(RaccBug, "[Racc Bug] wrong arg.size %ld", RARRAY(arg)->len); rb_raise(RaccBug, "[Racc Bug] wrong arg.size %ld", RARRAY_LEN(arg));
v->action_table = assert_array (RARRAY(arg)->ptr[ 0]); v->action_table = assert_array (RARRAY_PTR(arg)[ 0]);
v->action_check = assert_array (RARRAY(arg)->ptr[ 1]); v->action_check = assert_array (RARRAY_PTR(arg)[ 1]);
v->action_default = assert_array (RARRAY(arg)->ptr[ 2]); v->action_default = assert_array (RARRAY_PTR(arg)[ 2]);
v->action_pointer = assert_array (RARRAY(arg)->ptr[ 3]); v->action_pointer = assert_array (RARRAY_PTR(arg)[ 3]);
v->goto_table = assert_array (RARRAY(arg)->ptr[ 4]); v->goto_table = assert_array (RARRAY_PTR(arg)[ 4]);
v->goto_check = assert_array (RARRAY(arg)->ptr[ 5]); v->goto_check = assert_array (RARRAY_PTR(arg)[ 5]);
v->goto_default = assert_array (RARRAY(arg)->ptr[ 6]); v->goto_default = assert_array (RARRAY_PTR(arg)[ 6]);
v->goto_pointer = assert_array (RARRAY(arg)->ptr[ 7]); v->goto_pointer = assert_array (RARRAY_PTR(arg)[ 7]);
v->nt_base = assert_integer(RARRAY(arg)->ptr[ 8]); v->nt_base = assert_integer(RARRAY_PTR(arg)[ 8]);
v->reduce_table = assert_array (RARRAY(arg)->ptr[ 9]); v->reduce_table = assert_array (RARRAY_PTR(arg)[ 9]);
v->token_table = assert_hash (RARRAY(arg)->ptr[10]); v->token_table = assert_hash (RARRAY_PTR(arg)[10]);
v->shift_n = assert_integer(RARRAY(arg)->ptr[11]); v->shift_n = assert_integer(RARRAY_PTR(arg)[11]);
v->reduce_n = assert_integer(RARRAY(arg)->ptr[12]); v->reduce_n = assert_integer(RARRAY_PTR(arg)[12]);
if (RARRAY(arg)->len > 13) { if (RARRAY_LEN(arg) > 13) {
v->use_result_var = RTEST(RARRAY(arg)->ptr[13]); v->use_result_var = RTEST(RARRAY_PTR(arg)[13]);
} }
else { else {
v->use_result_var = Qtrue; v->use_result_var = Qtrue;
@ -424,12 +424,12 @@ extract_user_token(struct cparse_params *v, VALUE block_args,
v->lex_is_iterator ? "yielded" : "returned", v->lex_is_iterator ? "yielded" : "returned",
rb_class2name(CLASS_OF(block_args))); rb_class2name(CLASS_OF(block_args)));
} }
if (RARRAY(block_args)->len != 2) { if (RARRAY_LEN(block_args) != 2) {
rb_raise(rb_eArgError, rb_raise(rb_eArgError,
"%s() %s wrong size of array (%ld for 2)", "%s() %s wrong size of array (%ld for 2)",
v->lex_is_iterator ? rb_id2name(v->lexmid) : "next_token", v->lex_is_iterator ? rb_id2name(v->lexmid) : "next_token",
v->lex_is_iterator ? "yielded" : "returned", v->lex_is_iterator ? "yielded" : "returned",
RARRAY(block_args)->len); RARRAY_LEN(block_args));
} }
*tok = AREF(block_args, 0); *tok = AREF(block_args, 0);
*val = AREF(block_args, 1); *val = AREF(block_args, 1);
@ -565,7 +565,7 @@ parse_main(struct cparse_params *v, VALUE tok, VALUE val, int resume)
accept: accept:
if (v->debug) rb_funcall(v->parser, id_d_accept, 0); if (v->debug) rb_funcall(v->parser, id_d_accept, 0);
v->retval = RARRAY(v->vstack)->ptr[0]; v->retval = RARRAY_PTR(v->vstack)[0];
v->fin = CP_FIN_ACCEPT; v->fin = CP_FIN_ACCEPT;
return; return;
@ -625,7 +625,7 @@ parse_main(struct cparse_params *v, VALUE tok, VALUE val, int resume)
error_pop: error_pop:
D_puts("(err) act not found: can't handle error token; pop"); D_puts("(err) act not found: can't handle error token; pop");
if (RARRAY(v->state)->len <= 1) { if (RARRAY_LEN(v->state) <= 1) {
v->retval = Qnil; v->retval = Qnil;
v->fin = CP_FIN_CANTPOP; v->fin = CP_FIN_CANTPOP;
return; return;
@ -694,9 +694,9 @@ reduce0(VALUE val, VALUE data, VALUE self)
VALUE goto_state; VALUE goto_state;
Data_Get_Struct(data, struct cparse_params, v); Data_Get_Struct(data, struct cparse_params, v);
reduce_len = RARRAY(v->reduce_table)->ptr[v->ruleno]; reduce_len = RARRAY_PTR(v->reduce_table)[v->ruleno];
reduce_to = RARRAY(v->reduce_table)->ptr[v->ruleno+1]; reduce_to = RARRAY_PTR(v->reduce_table)[v->ruleno+1];
method_id = RARRAY(v->reduce_table)->ptr[v->ruleno+2]; method_id = RARRAY_PTR(v->reduce_table)[v->ruleno+2];
len = NUM2LONG(reduce_len); len = NUM2LONG(reduce_len);
mid = value_to_id(method_id); mid = value_to_id(method_id);
@ -711,10 +711,10 @@ reduce0(VALUE val, VALUE data, VALUE self)
else { else {
if (mid != id_noreduce) { if (mid != id_noreduce) {
tmp_v = GET_TAIL(v->vstack, len); tmp_v = GET_TAIL(v->vstack, len);
tmp = RARRAY(tmp_v)->ptr[0]; tmp = RARRAY_PTR(tmp_v)[0];
} }
else { else {
tmp = RARRAY(v->vstack)->ptr[ RARRAY(v->vstack)->len - len ]; tmp = RARRAY_PTR(v->vstack)[ RARRAY_LEN(v->vstack) - len ];
} }
CUT_TAIL(v->vstack, len); CUT_TAIL(v->vstack, len);
if (v->debug) { if (v->debug) {
@ -743,7 +743,7 @@ reduce0(VALUE val, VALUE data, VALUE self)
} }
/* calculate transition state */ /* calculate transition state */
if (RARRAY(v->state)->len == 0) if (RARRAY_LEN(v->state) == 0)
rb_raise(RaccBug, "state stack unexpectedly empty"); rb_raise(RaccBug, "state stack unexpectedly empty");
k2 = num_to_long(LAST_I(v->state)); k2 = num_to_long(LAST_I(v->state));
k1 = num_to_long(reduce_to) - v->nt_base; k1 = num_to_long(reduce_to) - v->nt_base;

8
ext/readline/readline.c
View file

@ -170,12 +170,12 @@ readline_attempted_completion_function(const char *text, int start, int end)
ary = rb_funcall(proc, rb_intern("call"), 1, rb_tainted_str_new2(text)); ary = rb_funcall(proc, rb_intern("call"), 1, rb_tainted_str_new2(text));
if (TYPE(ary) != T_ARRAY) if (TYPE(ary) != T_ARRAY)
ary = rb_Array(ary); ary = rb_Array(ary);
matches = RARRAY(ary)->len; matches = RARRAY_LEN(ary);
if (matches == 0) if (matches == 0)
return NULL; return NULL;
result = ALLOC_N(char *, matches + 2); result = ALLOC_N(char *, matches + 2);
for (i = 0; i < matches; i++) { for (i = 0; i < matches; i++) {
temp = rb_obj_as_string(RARRAY(ary)->ptr[i]); temp = rb_obj_as_string(RARRAY_PTR(ary)[i]);
result[i + 1] = ALLOC_N(char, RSTRING_LEN(temp) + 1); result[i + 1] = ALLOC_N(char, RSTRING_LEN(temp) + 1);
strcpy(result[i + 1], RSTRING_PTR(temp)); strcpy(result[i + 1], RSTRING_PTR(temp));
} }
@ -661,7 +661,7 @@ filename_completion_proc_call(VALUE self, VALUE str)
free(matches[i]); free(matches[i]);
} }
free(matches); free(matches);
if (RARRAY(result)->len >= 2) if (RARRAY_LEN(result) >= 2)
rb_ary_shift(result); rb_ary_shift(result);
} }
else { else {
@ -686,7 +686,7 @@ username_completion_proc_call(VALUE self, VALUE str)
free(matches[i]); free(matches[i]);
} }
free(matches); free(matches);
if (RARRAY(result)->len >= 2) if (RARRAY_LEN(result) >= 2)
rb_ary_shift(result); rb_ary_shift(result);
} }
else { else {

10
ext/sdbm/init.c
View file

@ -323,8 +323,8 @@ fsdbm_delete_if(VALUE obj)
GetDBM2(obj, dbmp, dbm); GetDBM2(obj, dbmp, dbm);
} }
for (i = 0; i < RARRAY(ary)->len; i++) { for (i = 0; i < RARRAY_LEN(ary); i++) {
keystr = RARRAY(ary)->ptr[i]; keystr = RARRAY_PTR(ary)[i];
StringValue(keystr); StringValue(keystr);
key.dptr = RSTRING_PTR(keystr); key.dptr = RSTRING_PTR(keystr);
key.dsize = RSTRING_LEN(keystr); key.dsize = RSTRING_LEN(keystr);
@ -333,7 +333,7 @@ fsdbm_delete_if(VALUE obj)
} }
} }
if (status) rb_jump_tag(status); if (status) rb_jump_tag(status);
if (n > 0) dbmp->di_size = n - RARRAY(ary)->len; if (n > 0) dbmp->di_size = n - RARRAY_LEN(ary);
return obj; return obj;
} }
@ -416,10 +416,10 @@ static VALUE
update_i(VALUE pair, VALUE dbm) update_i(VALUE pair, VALUE dbm)
{ {
Check_Type(pair, T_ARRAY); Check_Type(pair, T_ARRAY);
if (RARRAY(pair)->len < 2) { if (RARRAY_LEN(pair) < 2) {
rb_raise(rb_eArgError, "pair must be [key, value]"); rb_raise(rb_eArgError, "pair must be [key, value]");
} }
fsdbm_store(dbm, RARRAY(pair)->ptr[0], RARRAY(pair)->ptr[1]); fsdbm_store(dbm, RARRAY_PTR(pair)[0], RARRAY_PTR(pair)[1]);
return Qnil; return Qnil;
} }

22
ext/socket/socket.c
View file

@ -2991,7 +2991,7 @@ make_addrinfo(struct addrinfo *res0)
for (res = res0; res; res = res->ai_next) { for (res = res0; res; res = res->ai_next) {
ary = ipaddr(res->ai_addr, do_not_reverse_lookup); ary = ipaddr(res->ai_addr, do_not_reverse_lookup);
if (res->ai_canonname) { if (res->ai_canonname) {
RARRAY(ary)->ptr[2] = rb_str_new2(res->ai_canonname); RARRAY_PTR(ary)[2] = rb_str_new2(res->ai_canonname);
} }
rb_ary_push(ary, INT2FIX(res->ai_family)); rb_ary_push(ary, INT2FIX(res->ai_family));
rb_ary_push(ary, INT2FIX(res->ai_socktype)); rb_ary_push(ary, INT2FIX(res->ai_socktype));
@ -3232,17 +3232,17 @@ sock_s_getnameinfo(int argc, VALUE *argv)
if (!NIL_P(tmp)) { if (!NIL_P(tmp)) {
sa = tmp; sa = tmp;
MEMZERO(&hints, struct addrinfo, 1); MEMZERO(&hints, struct addrinfo, 1);
if (RARRAY(sa)->len == 3) { if (RARRAY_LEN(sa) == 3) {
af = RARRAY(sa)->ptr[0]; af = RARRAY_PTR(sa)[0];
port = RARRAY(sa)->ptr[1]; port = RARRAY_PTR(sa)[1];
host = RARRAY(sa)->ptr[2]; host = RARRAY_PTR(sa)[2];
} }
else if (RARRAY(sa)->len >= 4) { else if (RARRAY_LEN(sa) >= 4) {
af = RARRAY(sa)->ptr[0]; af = RARRAY_PTR(sa)[0];
port = RARRAY(sa)->ptr[1]; port = RARRAY_PTR(sa)[1];
host = RARRAY(sa)->ptr[3]; host = RARRAY_PTR(sa)[3];
if (NIL_P(host)) { if (NIL_P(host)) {
host = RARRAY(sa)->ptr[2]; host = RARRAY_PTR(sa)[2];
} }
else { else {
/* /*
@ -3256,7 +3256,7 @@ sock_s_getnameinfo(int argc, VALUE *argv)
} }
else { else {
rb_raise(rb_eArgError, "array size should be 3 or 4, %ld given", rb_raise(rb_eArgError, "array size should be 3 or 4, %ld given",
RARRAY(sa)->len); RARRAY_LEN(sa));
} }
/* host */ /* host */
if (NIL_P(host)) { if (NIL_P(host)) {

12
ext/syck/rubyext.c
View file

@ -1023,7 +1023,7 @@ syck_const_find(VALUE const_name)
VALUE tclass = rb_cObject; VALUE tclass = rb_cObject;
VALUE tparts = rb_str_split( const_name, "::" ); VALUE tparts = rb_str_split( const_name, "::" );
int i = 0; int i = 0;
for ( i = 0; i < RARRAY(tparts)->len; i++ ) { for ( i = 0; i < RARRAY_LEN(tparts); i++ ) {
VALUE tpart = rb_to_id( rb_ary_entry( tparts, i ) ); VALUE tpart = rb_to_id( rb_ary_entry( tparts, i ) );
if ( !rb_const_defined( tclass, tpart ) ) return Qnil; if ( !rb_const_defined( tclass, tpart ) ) return Qnil;
tclass = rb_const_get( tclass, tpart ); tclass = rb_const_get( tclass, tpart );
@ -1059,7 +1059,7 @@ syck_resolver_transfer(VALUE self, VALUE type, VALUE val)
VALUE subclass_parts = rb_ary_new(); VALUE subclass_parts = rb_ary_new();
VALUE parts = rb_str_split( type, ":" ); VALUE parts = rb_str_split( type, ":" );
while ( RARRAY(parts)->len > 1 ) while ( RARRAY_LEN(parts) > 1 )
{ {
VALUE partial; VALUE partial;
rb_ary_unshift( subclass_parts, rb_ary_pop( parts ) ); rb_ary_unshift( subclass_parts, rb_ary_pop( parts ) );
@ -1077,7 +1077,7 @@ syck_resolver_transfer(VALUE self, VALUE type, VALUE val)
if ( ! NIL_P( target_class ) ) if ( ! NIL_P( target_class ) )
{ {
subclass = target_class; subclass = target_class;
if ( RARRAY(subclass_parts)->len > 0 && rb_respond_to( target_class, s_tag_subclasses ) && if ( RARRAY_LEN(subclass_parts) > 0 && rb_respond_to( target_class, s_tag_subclasses ) &&
RTEST( rb_funcall( target_class, s_tag_subclasses, 0 ) ) ) RTEST( rb_funcall( target_class, s_tag_subclasses, 0 ) ) )
{ {
VALUE subclass_v; VALUE subclass_v;
@ -1502,7 +1502,7 @@ syck_seq_value_set(VALUE self, VALUE val)
if ( !NIL_P( val ) ) { if ( !NIL_P( val ) ) {
int i; int i;
syck_seq_empty( node ); syck_seq_empty( node );
for ( i = 0; i < RARRAY( val )->len; i++ ) for ( i = 0; i < RARRAY_LEN( val ); i++ )
{ {
syck_seq_add( node, rb_ary_entry(val, i) ); syck_seq_add( node, rb_ary_entry(val, i) );
} }
@ -1587,7 +1587,7 @@ syck_map_initialize(VALUE self, VALUE type_id, VALUE val, VALUE style)
} }
keys = rb_funcall( hsh, s_keys, 0 ); keys = rb_funcall( hsh, s_keys, 0 );
for ( i = 0; i < RARRAY(keys)->len; i++ ) for ( i = 0; i < RARRAY_LEN(keys); i++ )
{ {
VALUE key = rb_ary_entry(keys, i); VALUE key = rb_ary_entry(keys, i);
syck_map_add( node, key, rb_hash_aref(hsh, key) ); syck_map_add( node, key, rb_hash_aref(hsh, key) );
@ -1622,7 +1622,7 @@ syck_map_value_set(VALUE self, VALUE val)
syck_map_empty( node ); syck_map_empty( node );
keys = rb_funcall( hsh, s_keys, 0 ); keys = rb_funcall( hsh, s_keys, 0 );
for ( i = 0; i < RARRAY(keys)->len; i++ ) for ( i = 0; i < RARRAY_LEN(keys); i++ )
{ {
VALUE key = rb_ary_entry(keys, i); VALUE key = rb_ary_entry(keys, i);
syck_map_add( node, key, rb_hash_aref(hsh, key) ); syck_map_add( node, key, rb_hash_aref(hsh, key) );

45
ext/tk/tcltklib.c
View file

@ -1133,15 +1133,15 @@ set_max_block_time(self, time)
case T_BIGNUM: case T_BIGNUM:
/* time is micro-second value */ /* time is micro-second value */
divmod = rb_funcall(time, rb_intern("divmod"), 1, LONG2NUM(1000000)); divmod = rb_funcall(time, rb_intern("divmod"), 1, LONG2NUM(1000000));
tcl_time.sec = NUM2LONG(RARRAY(divmod)->ptr[0]); tcl_time.sec = NUM2LONG(RARRAY_PTR(divmod)[0]);
tcl_time.usec = NUM2LONG(RARRAY(divmod)->ptr[1]); tcl_time.usec = NUM2LONG(RARRAY_PTR(divmod)[1]);
break; break;
case T_FLOAT: case T_FLOAT:
/* time is second value */ /* time is second value */
divmod = rb_funcall(time, rb_intern("divmod"), 1, INT2FIX(1)); divmod = rb_funcall(time, rb_intern("divmod"), 1, INT2FIX(1));
tcl_time.sec = NUM2LONG(RARRAY(divmod)->ptr[0]); tcl_time.sec = NUM2LONG(RARRAY_PTR(divmod)[0]);
tcl_time.usec = (long)(NUM2DBL(RARRAY(divmod)->ptr[1]) * 1000000); tcl_time.usec = (long)(NUM2DBL(RARRAY_PTR(divmod)[1]) * 1000000);
default: default:
{ {
@ -2595,15 +2595,14 @@ ip_ruby_cmd(clientData, interp, argc, argv)
/* get args */ /* get args */
args = rb_ary_new2(argc - 2); args = rb_ary_new2(argc - 2);
RARRAY(args)->len = 0;
for(i = 3; i < argc; i++) { for(i = 3; i < argc; i++) {
#if TCL_MAJOR_VERSION >= 8 #if TCL_MAJOR_VERSION >= 8
str = Tcl_GetStringFromObj(argv[i], &len); str = Tcl_GetStringFromObj(argv[i], &len);
DUMP2("arg:%s",str); DUMP2("arg:%s",str);
RARRAY(args)->ptr[RARRAY(args)->len++] = rb_tainted_str_new(str, len); rb_ary_push(args, rb_tainted_str_new(str, len));
#else /* TCL_MAJOR_VERSION < 8 */ #else /* TCL_MAJOR_VERSION < 8 */
DUMP2("arg:%s",argv[i]); DUMP2("arg:%s",argv[i]);
RARRAY(args)->ptr[RARRAY(args)->len++] = rb_tainted_str_new2(argv[i]); rb_ary_push(args, rb_tainted_str_new2(argv[i]));
#endif #endif
} }
@ -5516,7 +5515,7 @@ call_queue_handler(evPtr, flags)
} }
/* set result */ /* set result */
RARRAY(q->result)->ptr[0] = ret; RARRAY_PTR(q->result)[0] = ret;
/* complete */ /* complete */
*(q->done) = -1; *(q->done) = -1;
@ -5586,8 +5585,8 @@ tk_funcall(func, argc, argv, obj)
/* allocate result obj */ /* allocate result obj */
result = rb_ary_new2(1); result = rb_ary_new2(1);
RARRAY(result)->ptr[0] = Qnil; RARRAY_PTR(result)[0] = Qnil;
RARRAY(result)->len = 1; RARRAY_LEN(result) = 1;
/* construct event data */ /* construct event data */
callq->done = alloc_done; callq->done = alloc_done;
@ -5614,7 +5613,7 @@ tk_funcall(func, argc, argv, obj)
DUMP2("back from handler (current thread:%lx)", current); DUMP2("back from handler (current thread:%lx)", current);
/* get result & free allocated memory */ /* get result & free allocated memory */
ret = RARRAY(result)->ptr[0]; ret = RARRAY_PTR(result)[0];
free(alloc_done); free(alloc_done);
if (argv) free(argv); if (argv) free(argv);
@ -5834,7 +5833,7 @@ eval_queue_handler(evPtr, flags)
} }
/* set result */ /* set result */
RARRAY(q->result)->ptr[0] = ret; RARRAY_PTR(q->result)[0] = ret;
/* complete */ /* complete */
*(q->done) = -1; *(q->done) = -1;
@ -5901,8 +5900,8 @@ ip_eval(self, str)
/* allocate result obj */ /* allocate result obj */
result = rb_ary_new2(1); result = rb_ary_new2(1);
RARRAY(result)->ptr[0] = Qnil; RARRAY_PTR(result)[0] = Qnil;
RARRAY(result)->len = 1; RARRAY_LEN(result) = 1;
/* construct event data */ /* construct event data */
evq->done = alloc_done; evq->done = alloc_done;
@ -5930,7 +5929,7 @@ ip_eval(self, str)
DUMP2("back from handler (current thread:%lx)", current); DUMP2("back from handler (current thread:%lx)", current);
/* get result & free allocated memory */ /* get result & free allocated memory */
ret = RARRAY(result)->ptr[0]; ret = RARRAY_PTR(result)[0];
free(alloc_done); free(alloc_done);
free(eval_str); free(eval_str);
@ -6911,7 +6910,7 @@ invoke_queue_handler(evPtr, flags)
} }
/* set result */ /* set result */
RARRAY(q->result)->ptr[0] = ret; RARRAY_PTR(q->result)[0] = ret;
/* complete */ /* complete */
*(q->done) = -1; *(q->done) = -1;
@ -6981,8 +6980,8 @@ ip_invoke_with_position(argc, argv, obj, position)
/* allocate result obj */ /* allocate result obj */
result = rb_ary_new2(1); result = rb_ary_new2(1);
RARRAY(result)->ptr[0] = Qnil; RARRAY_PTR(result)[0] = Qnil;
RARRAY(result)->len = 1; RARRAY_LEN(result) = 1;
/* construct event data */ /* construct event data */
ivq->done = alloc_done; ivq->done = alloc_done;
@ -7008,7 +7007,7 @@ ip_invoke_with_position(argc, argv, obj, position)
DUMP2("back from handler (current thread:%lx)", current); DUMP2("back from handler (current thread:%lx)", current);
/* get result & free allocated memory */ /* get result & free allocated memory */
ret = RARRAY(result)->ptr[0]; ret = RARRAY_PTR(result)[0];
free(alloc_done); free(alloc_done);
Tcl_Release(ivq); Tcl_Release(ivq);
@ -7535,11 +7534,9 @@ lib_split_tklist_core(ip_obj, list_str)
for(idx = 0; idx < objc; idx++) { for(idx = 0; idx < objc; idx++) {
elem = get_str_from_obj(objv[idx]); elem = get_str_from_obj(objv[idx]);
if (taint_flag) OBJ_TAINT(elem); if (taint_flag) OBJ_TAINT(elem);
RARRAY(ary)->ptr[idx] = elem; rb_ary_push(ary, elem);
} }
RARRAY(ary)->len = objc;
if (old_gc == Qfalse) rb_gc_enable(); if (old_gc == Qfalse) rb_gc_enable();
rb_thread_critical = thr_crit_bup; rb_thread_critical = thr_crit_bup;
@ -7576,10 +7573,8 @@ lib_split_tklist_core(ip_obj, list_str)
elem = rb_str_new2(argv[idx]); elem = rb_str_new2(argv[idx]);
} }
/* rb_ivar_set(elem, ID_at_enc, rb_str_new2("binary")); */ /* rb_ivar_set(elem, ID_at_enc, rb_str_new2("binary")); */
RARRAY(ary)->ptr[idx] = elem; rb_ary_push(ary, elem);
} }
RARRAY(ary)->len = argc;
if (old_gc == Qfalse) rb_gc_enable(); if (old_gc == Qfalse) rb_gc_enable();
#endif #endif
} }

18
ext/win32ole/win32ole.c
View file

@ -863,7 +863,7 @@ ole_val2variant(VALUE val, VARIANT *var)
val1 = val; val1 = val;
i = 0; i = 0;
while(TYPE(val1) == T_ARRAY) { while(TYPE(val1) == T_ARRAY) {
psab[i].cElements = RARRAY(val1)->len; psab[i].cElements = RARRAY_LEN(val1);
psab[i].lLbound = 0; psab[i].lLbound = 0;
pub[i] = psab[i].cElements; pub[i] = psab[i].cElements;
pid[i] = 0; pid[i] = 0;
@ -1113,7 +1113,7 @@ ole_val2olevariantdata(VALUE val, VARTYPE vtype, struct olevariantdata *pvar)
val1 = val; val1 = val;
i = 0; i = 0;
while(TYPE(val1) == T_ARRAY) { while(TYPE(val1) == T_ARRAY) {
psab[i].cElements = RARRAY(val1)->len; psab[i].cElements = RARRAY_LEN(val1);
psab[i].lLbound = 0; psab[i].lLbound = 0;
pub[i] = psab[i].cElements; pub[i] = psab[i].cElements;
pid[i] = 0; pid[i] = 0;
@ -2544,7 +2544,7 @@ ole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types, USHORT dispkind)
VariantInit(&result); VariantInit(&result);
OLEData_Get_Struct(self, pole); OLEData_Get_Struct(self, pole);
dispParams.cArgs = RARRAY(args)->len; dispParams.cArgs = RARRAY_LEN(args);
dispParams.rgvarg = ALLOCA_N(VARIANTARG, dispParams.cArgs); dispParams.rgvarg = ALLOCA_N(VARIANTARG, dispParams.cArgs);
realargs = ALLOCA_N(VARIANTARG, dispParams.cArgs); realargs = ALLOCA_N(VARIANTARG, dispParams.cArgs);
for (i = 0, j = dispParams.cArgs - 1; i < (int)dispParams.cArgs; i++, j--) for (i = 0, j = dispParams.cArgs - 1; i < (int)dispParams.cArgs; i++, j--)
@ -2575,7 +2575,7 @@ ole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types, USHORT dispkind)
SAFEARRAYBOUND rgsabound[1]; SAFEARRAYBOUND rgsabound[1];
Check_Type(param, T_ARRAY); Check_Type(param, T_ARRAY);
rgsabound[0].lLbound = 0; rgsabound[0].lLbound = 0;
rgsabound[0].cElements = RARRAY(param)->len; rgsabound[0].cElements = RARRAY_LEN(param);
v = vt & ~(VT_ARRAY | VT_BYREF); v = vt & ~(VT_ARRAY | VT_BYREF);
V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound); V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound);
V_VT(&realargs[i]) = VT_ARRAY | v; V_VT(&realargs[i]) = VT_ARRAY | v;
@ -4060,7 +4060,7 @@ foletypelib_initialize(VALUE self, VALUE args)
VALUE retval; VALUE retval;
HRESULT hr = S_OK; HRESULT hr = S_OK;
len = RARRAY(args)->len; len = RARRAY_LEN(args);
if (len < 1 || len > 3) { if (len < 1 || len > 3) {
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", len); rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", len);
} }
@ -6233,7 +6233,7 @@ ole_search_event_at(VALUE ary, VALUE ev)
long i, len; long i, len;
long ret = -1; long ret = -1;
def_event = Qnil; def_event = Qnil;
len = RARRAY(ary)->len; len = RARRAY_LEN(ary);
for(i = 0; i < len; i++) { for(i = 0; i < len; i++) {
event = rb_ary_entry(ary, i); event = rb_ary_entry(ary, i);
event_name = rb_ary_entry(event, 1); event_name = rb_ary_entry(event, 1);
@ -6260,7 +6260,7 @@ ole_search_event(VALUE ary, VALUE ev, BOOL *is_default)
int i, len; int i, len;
*is_default = FALSE; *is_default = FALSE;
def_event = Qnil; def_event = Qnil;
len = RARRAY(ary)->len; len = RARRAY_LEN(ary);
for(i = 0; i < len; i++) { for(i = 0; i < len; i++) {
event = rb_ary_entry(ary, i); event = rb_ary_entry(ary, i);
event_name = rb_ary_entry(event, 1); event_name = rb_ary_entry(event, 1);
@ -6283,7 +6283,7 @@ ary2ptr_dispparams(VALUE ary, DISPPARAMS *pdispparams)
int i; int i;
VALUE v; VALUE v;
VARIANT *pvar; VARIANT *pvar;
for(i = 0; i < RARRAY(ary)->len && (unsigned int) i < pdispparams->cArgs; i++) { for(i = 0; i < RARRAY_LEN(ary) && (unsigned int) i < pdispparams->cArgs; i++) {
v = rb_ary_entry(ary, i); v = rb_ary_entry(ary, i);
pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1]; pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
ole_val2ptr_variant(v, pvar); ole_val2ptr_variant(v, pvar);
@ -6825,7 +6825,7 @@ folevariant_initialize(VALUE self, VALUE args)
VARTYPE vt; VARTYPE vt;
struct olevariantdata *pvar; struct olevariantdata *pvar;
len = RARRAY(args)->len; len = RARRAY_LEN(args);
if (len < 1 || len > 3) { if (len < 1 || len > 3) {
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", len); rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", len);
} }

29
file.c
View file

@ -125,15 +125,14 @@ apply2files(void (*func)(const char *, void *), VALUE vargs, void *arg)
{ {
long i; long i;
VALUE path; VALUE path;
struct RArray *args = RARRAY(vargs);
rb_secure(4); rb_secure(4);
for (i=0; i<args->len; i++) { for (i=0; i<RARRAY_LEN(vargs); i++) {
path = rb_get_path(args->ptr[i]); path = rb_get_path(RARRAY_PTR(vargs)[i]);
(*func)(StringValueCStr(path), arg); (*func)(StringValueCStr(path), arg);
} }
return args->len; return RARRAY_LEN(vargs);
} }
/* /*
@ -2875,12 +2874,12 @@ rb_file_join(VALUE ary, VALUE sep)
VALUE result, tmp; VALUE result, tmp;
char *name, *tail; char *name, *tail;
if (RARRAY(ary)->len == 0) return rb_str_new(0, 0); if (RARRAY_LEN(ary) == 0) return rb_str_new(0, 0);
len = 1; len = 1;
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
if (TYPE(RARRAY(ary)->ptr[i]) == T_STRING) { if (TYPE(RARRAY_PTR(ary)[i]) == T_STRING) {
len += RSTRING_LEN(RARRAY(ary)->ptr[i]); len += RSTRING_LEN(RARRAY_PTR(ary)[i]);
} }
else { else {
len += 10; len += 10;
@ -2888,12 +2887,12 @@ rb_file_join(VALUE ary, VALUE sep)
} }
if (!NIL_P(sep)) { if (!NIL_P(sep)) {
StringValue(sep); StringValue(sep);
len += RSTRING_LEN(sep) * RARRAY(ary)->len - 1; len += RSTRING_LEN(sep) * RARRAY_LEN(ary) - 1;
} }
result = rb_str_buf_new(len); result = rb_str_buf_new(len);
OBJ_INFECT(result, ary); OBJ_INFECT(result, ary);
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
tmp = RARRAY(ary)->ptr[i]; tmp = RARRAY_PTR(ary)[i];
switch (TYPE(tmp)) { switch (TYPE(tmp)) {
case T_STRING: case T_STRING:
break; break;
@ -4174,8 +4173,8 @@ rb_find_file_ext(VALUE *filep, const char *const *ext)
if (!rb_load_path) return 0; if (!rb_load_path) return 0;
Check_Type(rb_load_path, T_ARRAY); Check_Type(rb_load_path, T_ARRAY);
for (i=0;i<RARRAY(rb_load_path)->len;i++) { for (i=0;i<RARRAY_LEN(rb_load_path);i++) {
VALUE str = RARRAY(rb_load_path)->ptr[i]; VALUE str = RARRAY_PTR(rb_load_path)[i];
FilePathValue(str); FilePathValue(str);
if (RSTRING_LEN(str) == 0) continue; if (RSTRING_LEN(str) == 0) continue;
@ -4235,8 +4234,8 @@ rb_find_file(VALUE path)
Check_Type(rb_load_path, T_ARRAY); Check_Type(rb_load_path, T_ARRAY);
tmp = rb_ary_new(); tmp = rb_ary_new();
for (i=0;i<RARRAY(rb_load_path)->len;i++) { for (i=0;i<RARRAY_LEN(rb_load_path);i++) {
VALUE str = RARRAY(rb_load_path)->ptr[i]; VALUE str = RARRAY_PTR(rb_load_path)[i];
FilePathValue(str); FilePathValue(str);
if (RSTRING_LEN(str) > 0) { if (RSTRING_LEN(str) > 0) {
rb_ary_push(tmp, str); rb_ary_push(tmp, str);

28
gc.c
View file

@ -926,12 +926,12 @@ gc_mark_children(VALUE ptr, int lev)
case T_ARRAY: case T_ARRAY:
if (FL_TEST(obj, ELTS_SHARED)) { if (FL_TEST(obj, ELTS_SHARED)) {
ptr = obj->as.array.aux.shared; ptr = obj->as.array.as.heap.aux.shared;
goto again; goto again;
} }
else { else {
long i, len = obj->as.array.len; long i, len = RARRAY_LEN(obj);
VALUE *ptr = obj->as.array.ptr; VALUE *ptr = RARRAY_PTR(obj);
for (i=0; i < len; i++) { for (i=0; i < len; i++) {
gc_mark(*ptr++, lev); gc_mark(*ptr++, lev);
@ -945,9 +945,8 @@ gc_mark_children(VALUE ptr, int lev)
goto again; goto again;
case T_STRING: case T_STRING:
#define STR_NOEMBED FL_USER1 /* copied from string.c */
#define STR_ASSOC FL_USER3 /* copied from string.c */ #define STR_ASSOC FL_USER3 /* copied from string.c */
if (FL_TEST(obj, STR_NOEMBED) && FL_ANY(obj, ELTS_SHARED|STR_ASSOC)) { if (FL_TEST(obj, RSTRING_NOEMBED) && FL_ANY(obj, ELTS_SHARED|STR_ASSOC)) {
ptr = obj->as.string.as.heap.aux.shared; ptr = obj->as.string.as.heap.aux.shared;
goto again; goto again;
} }
@ -1175,14 +1174,15 @@ obj_free(VALUE obj)
} }
break; break;
case T_STRING: case T_STRING:
if (FL_TEST(obj, STR_NOEMBED) && if (FL_TEST(obj, RSTRING_NOEMBED) &&
RANY(obj)->as.string.as.heap.ptr && !FL_TEST(obj, ELTS_SHARED)) { RANY(obj)->as.string.as.heap.ptr && !FL_TEST(obj, ELTS_SHARED)) {
RUBY_CRITICAL(free(RANY(obj)->as.string.as.heap.ptr)); RUBY_CRITICAL(free(RANY(obj)->as.string.as.heap.ptr));
} }
break; break;
case T_ARRAY: case T_ARRAY:
if (RANY(obj)->as.array.ptr && !FL_TEST(obj, ELTS_SHARED)) { if (FL_TEST(obj, RARRAY_NOEMBED) &&
RUBY_CRITICAL(free(RANY(obj)->as.array.ptr)); RANY(obj)->as.array.as.heap.ptr && !FL_TEST(obj, ELTS_SHARED)) {
RUBY_CRITICAL(free(RANY(obj)->as.array.as.heap.ptr));
} }
break; break;
case T_HASH: case T_HASH:
@ -1833,17 +1833,17 @@ run_final(VALUE obj)
rb_thread_critical = Qtrue; rb_thread_critical = Qtrue;
args[1] = 0; args[1] = 0;
args[2] = (VALUE)ruby_safe_level; args[2] = (VALUE)ruby_safe_level;
for (i=0; i<RARRAY(finalizers)->len; i++) { for (i=0; i<RARRAY_LEN(finalizers); i++) {
args[0] = RARRAY(finalizers)->ptr[i]; args[0] = RARRAY_PTR(finalizers)[i];
if (!args[1]) args[1] = rb_ary_new3(1, objid); if (!args[1]) args[1] = rb_ary_new3(1, objid);
rb_protect((VALUE(*)(VALUE))run_single_final, (VALUE)args, &status); rb_protect((VALUE(*)(VALUE))run_single_final, (VALUE)args, &status);
} }
if (finalizer_table && st_delete(finalizer_table, (st_data_t*)&obj, &table)) { if (finalizer_table && st_delete(finalizer_table, (st_data_t*)&obj, &table)) {
for (i=0; i<RARRAY(table)->len; i++) { for (i=0; i<RARRAY_LEN(table); i++) {
VALUE final = RARRAY(table)->ptr[i]; VALUE final = RARRAY_PTR(table)[i];
args[0] = RARRAY(final)->ptr[1]; args[0] = RARRAY_PTR(final)[1];
if (!args[1]) args[1] = rb_ary_new3(1, objid); if (!args[1]) args[1] = rb_ary_new3(1, objid);
args[2] = FIX2INT(RARRAY(final)->ptr[0]); args[2] = FIX2INT(RARRAY_PTR(final)[0]);
rb_protect((VALUE(*)(VALUE))run_single_final, (VALUE)args, &status); rb_protect((VALUE(*)(VALUE))run_single_final, (VALUE)args, &status);
} }
} }

34
hash.c
View file

@ -1828,8 +1828,8 @@ env_each_key(VALUE ehash)
RETURN_ENUMERATOR(ehash, 0, 0); RETURN_ENUMERATOR(ehash, 0, 0);
rb_secure(4); rb_secure(4);
keys = env_keys(); keys = env_keys();
for (i=0; i<RARRAY(keys)->len; i++) { for (i=0; i<RARRAY_LEN(keys); i++) {
rb_yield(RARRAY(keys)->ptr[i]); rb_yield(RARRAY_PTR(keys)[i]);
} }
return ehash; return ehash;
} }
@ -1863,8 +1863,8 @@ env_each_value(VALUE ehash)
RETURN_ENUMERATOR(ehash, 0, 0); RETURN_ENUMERATOR(ehash, 0, 0);
rb_secure(4); rb_secure(4);
values = env_values(); values = env_values();
for (i=0; i<RARRAY(values)->len; i++) { for (i=0; i<RARRAY_LEN(values); i++) {
rb_yield(RARRAY(values)->ptr[i]); rb_yield(RARRAY_PTR(values)[i]);
} }
return ehash; return ehash;
} }
@ -1889,12 +1889,12 @@ env_each_i(VALUE ehash, int values)
} }
FREE_ENVIRON(environ); FREE_ENVIRON(environ);
for (i=0; i<RARRAY(ary)->len; i+=2) { for (i=0; i<RARRAY_LEN(ary); i+=2) {
if (values) { if (values) {
rb_yield_values(2, RARRAY(ary)->ptr[i], RARRAY(ary)->ptr[i+1]); rb_yield_values(2, RARRAY_PTR(ary)[i], RARRAY_PTR(ary)[i+1]);
} }
else { else {
rb_yield(rb_assoc_new(RARRAY(ary)->ptr[i], RARRAY(ary)->ptr[i+1])); rb_yield(rb_assoc_new(RARRAY_PTR(ary)[i], RARRAY_PTR(ary)[i+1]));
} }
} }
return ehash; return ehash;
@ -1923,12 +1923,12 @@ env_reject_bang(void)
rb_secure(4); rb_secure(4);
keys = env_keys(); keys = env_keys();
for (i=0; i<RARRAY(keys)->len; i++) { for (i=0; i<RARRAY_LEN(keys); i++) {
VALUE val = rb_f_getenv(Qnil, RARRAY(keys)->ptr[i]); VALUE val = rb_f_getenv(Qnil, RARRAY_PTR(keys)[i]);
if (!NIL_P(val)) { if (!NIL_P(val)) {
if (RTEST(rb_yield_values(2, RARRAY(keys)->ptr[i], val))) { if (RTEST(rb_yield_values(2, RARRAY_PTR(keys)[i], val))) {
FL_UNSET(RARRAY(keys)->ptr[i], FL_TAINT); FL_UNSET(RARRAY_PTR(keys)[i], FL_TAINT);
env_delete(Qnil, RARRAY(keys)->ptr[i]); env_delete(Qnil, RARRAY_PTR(keys)[i]);
del++; del++;
} }
} }
@ -1992,10 +1992,10 @@ env_clear(void)
rb_secure(4); rb_secure(4);
keys = env_keys(); keys = env_keys();
for (i=0; i<RARRAY(keys)->len; i++) { for (i=0; i<RARRAY_LEN(keys); i++) {
VALUE val = rb_f_getenv(Qnil, RARRAY(keys)->ptr[i]); VALUE val = rb_f_getenv(Qnil, RARRAY_PTR(keys)[i]);
if (!NIL_P(val)) { if (!NIL_P(val)) {
env_delete(Qnil, RARRAY(keys)->ptr[i]); env_delete(Qnil, RARRAY_PTR(keys)[i]);
} }
} }
return envtbl; return envtbl;
@ -2239,8 +2239,8 @@ env_replace(VALUE env, VALUE hash)
hash = to_hash(hash); hash = to_hash(hash);
rb_hash_foreach(hash, env_replace_i, keys); rb_hash_foreach(hash, env_replace_i, keys);
for (i=0; i<RARRAY(keys)->len; i++) { for (i=0; i<RARRAY_LEN(keys); i++) {
env_delete(env, RARRAY(keys)->ptr[i]); env_delete(env, RARRAY_PTR(keys)[i]);
} }
return env; return env;
} }

46
io.c
View file

@ -3163,10 +3163,10 @@ rb_io_s_popen(int argc, VALUE *argv, VALUE klass)
} }
tmp = rb_check_array_type(pname); tmp = rb_check_array_type(pname);
if (!NIL_P(tmp)) { if (!NIL_P(tmp)) {
VALUE *argv = ALLOCA_N(VALUE, RARRAY(tmp)->len); VALUE *argv = ALLOCA_N(VALUE, RARRAY_LEN(tmp));
MEMCPY(argv, RARRAY(tmp)->ptr, VALUE, RARRAY(tmp)->len); MEMCPY(argv, RARRAY_PTR(tmp), VALUE, RARRAY_LEN(tmp));
port = pipe_open(RARRAY(tmp)->len, argv, mode); port = pipe_open(RARRAY_LEN(tmp), argv, mode);
pname = tmp; pname = tmp;
} }
else { else {
@ -3784,8 +3784,8 @@ io_puts_ary(VALUE ary, VALUE out, int recur)
VALUE tmp; VALUE tmp;
long i; long i;
for (i=0; i<RARRAY(ary)->len; i++) { for (i=0; i<RARRAY_LEN(ary); i++) {
tmp = RARRAY(ary)->ptr[i]; tmp = RARRAY_PTR(ary)[i];
if (recur) { if (recur) {
tmp = rb_str_new2("[...]"); tmp = rb_str_new2("[...]");
} }
@ -4233,7 +4233,7 @@ next_argv(void)
} }
if (init_p == 0) { if (init_p == 0) {
if (RARRAY(rb_argv)->len > 0) { if (RARRAY_LEN(rb_argv) > 0) {
next_p = 1; next_p = 1;
} }
else { else {
@ -4246,7 +4246,7 @@ next_argv(void)
if (next_p == 1) { if (next_p == 1) {
next_p = 0; next_p = 0;
retry: retry:
if (RARRAY(rb_argv)->len > 0) { if (RARRAY_LEN(rb_argv) > 0) {
filename = rb_ary_shift(rb_argv); filename = rb_ary_shift(rb_argv);
fn = StringValuePtr(filename); fn = StringValuePtr(filename);
if (strlen(fn) == 1 && fn[0] == '-') { if (strlen(fn) == 1 && fn[0] == '-') {
@ -4549,8 +4549,8 @@ select_internal(VALUE read, VALUE write, VALUE except, struct timeval *tp, rb_fd
if (!NIL_P(read)) { if (!NIL_P(read)) {
Check_Type(read, T_ARRAY); Check_Type(read, T_ARRAY);
for (i=0; i<RARRAY(read)->len; i++) { for (i=0; i<RARRAY_LEN(read); i++) {
GetOpenFile(rb_io_get_io(RARRAY(read)->ptr[i]), fptr); GetOpenFile(rb_io_get_io(RARRAY_PTR(read)[i]), fptr);
rb_fd_set(fptr->fd, &fds[0]); rb_fd_set(fptr->fd, &fds[0]);
if (READ_DATA_PENDING(fptr)) { /* check for buffered data */ if (READ_DATA_PENDING(fptr)) { /* check for buffered data */
pending++; pending++;
@ -4569,8 +4569,8 @@ select_internal(VALUE read, VALUE write, VALUE except, struct timeval *tp, rb_fd
if (!NIL_P(write)) { if (!NIL_P(write)) {
Check_Type(write, T_ARRAY); Check_Type(write, T_ARRAY);
for (i=0; i<RARRAY(write)->len; i++) { for (i=0; i<RARRAY_LEN(write); i++) {
GetOpenFile(rb_io_get_io(RARRAY(write)->ptr[i]), fptr); GetOpenFile(rb_io_get_io(RARRAY_PTR(write)[i]), fptr);
rb_fd_set(fptr->fd, &fds[1]); rb_fd_set(fptr->fd, &fds[1]);
if (max < fptr->fd) max = fptr->fd; if (max < fptr->fd) max = fptr->fd;
} }
@ -4581,8 +4581,8 @@ select_internal(VALUE read, VALUE write, VALUE except, struct timeval *tp, rb_fd
if (!NIL_P(except)) { if (!NIL_P(except)) {
Check_Type(except, T_ARRAY); Check_Type(except, T_ARRAY);
for (i=0; i<RARRAY(except)->len; i++) { for (i=0; i<RARRAY_LEN(except); i++) {
GetOpenFile(rb_io_get_io(RARRAY(except)->ptr[i]), fptr); GetOpenFile(rb_io_get_io(RARRAY_PTR(except)[i]), fptr);
rb_fd_set(fptr->fd, &fds[2]); rb_fd_set(fptr->fd, &fds[2]);
if (max < fptr->fd) max = fptr->fd; if (max < fptr->fd) max = fptr->fd;
} }
@ -4607,9 +4607,9 @@ select_internal(VALUE read, VALUE write, VALUE except, struct timeval *tp, rb_fd
if (interrupt_flag == 0) { if (interrupt_flag == 0) {
if (rp) { if (rp) {
list = RARRAY(res)->ptr[0]; list = RARRAY_PTR(res)[0];
for (i=0; i< RARRAY(read)->len; i++) { for (i=0; i< RARRAY_LEN(read); i++) {
GetOpenFile(rb_io_get_io(RARRAY(read)->ptr[i]), fptr); GetOpenFile(rb_io_get_io(RARRAY_PTR(read)[i]), fptr);
if (rb_fd_isset(fptr->fd, &fds[0]) || if (rb_fd_isset(fptr->fd, &fds[0]) ||
rb_fd_isset(fptr->fd, &fds[3])) { rb_fd_isset(fptr->fd, &fds[3])) {
rb_ary_push(list, rb_ary_entry(read, i)); rb_ary_push(list, rb_ary_entry(read, i));
@ -4618,9 +4618,9 @@ select_internal(VALUE read, VALUE write, VALUE except, struct timeval *tp, rb_fd
} }
if (wp) { if (wp) {
list = RARRAY(res)->ptr[1]; list = RARRAY_PTR(res)[1];
for (i=0; i< RARRAY(write)->len; i++) { for (i=0; i< RARRAY_LEN(write); i++) {
GetOpenFile(rb_io_get_io(RARRAY(write)->ptr[i]), fptr); GetOpenFile(rb_io_get_io(RARRAY_PTR(write)[i]), fptr);
if (rb_fd_isset(fptr->fd, &fds[1])) { if (rb_fd_isset(fptr->fd, &fds[1])) {
rb_ary_push(list, rb_ary_entry(write, i)); rb_ary_push(list, rb_ary_entry(write, i));
} }
@ -4628,9 +4628,9 @@ select_internal(VALUE read, VALUE write, VALUE except, struct timeval *tp, rb_fd
} }
if (ep) { if (ep) {
list = RARRAY(res)->ptr[2]; list = RARRAY_PTR(res)[2];
for (i=0; i< RARRAY(except)->len; i++) { for (i=0; i< RARRAY_LEN(except); i++) {
GetOpenFile(rb_io_get_io(RARRAY(except)->ptr[i]), fptr); GetOpenFile(rb_io_get_io(RARRAY_PTR(except)[i]), fptr);
if (rb_fd_isset(fptr->fd, &fds[2])) { if (rb_fd_isset(fptr->fd, &fds[2])) {
rb_ary_push(list, rb_ary_entry(except, i)); rb_ary_push(list, rb_ary_entry(except, i));
} }
@ -5328,7 +5328,7 @@ argf_readpartial(int argc, VALUE *argv)
} }
argf_close(current_file); argf_close(current_file);
next_p = 1; next_p = 1;
if (RARRAY(rb_argv)->len == 0) if (RARRAY_LEN(rb_argv) == 0)
rb_eof_error(); rb_eof_error();
if (NIL_P(str)) if (NIL_P(str))
str = rb_str_new(NULL, 0); str = rb_str_new(NULL, 0);

14
marshal.c
View file

@ -552,8 +552,8 @@ w_object(VALUE obj, struct dump_arg *arg, int limit)
w_uclass(obj, rb_cArray, arg); w_uclass(obj, rb_cArray, arg);
w_byte(TYPE_ARRAY, arg); w_byte(TYPE_ARRAY, arg);
{ {
long len = RARRAY(obj)->len; long len = RARRAY_LEN(obj);
VALUE *ptr = RARRAY(obj)->ptr; VALUE *ptr = RARRAY_PTR(obj);
w_long(len, arg); w_long(len, arg);
while (len--) { while (len--) {
@ -592,7 +592,7 @@ w_object(VALUE obj, struct dump_arg *arg, int limit)
w_long(len, arg); w_long(len, arg);
mem = rb_struct_members(obj); mem = rb_struct_members(obj);
for (i=0; i<len; i++) { for (i=0; i<len; i++) {
w_symbol(SYM2ID(RARRAY(mem)->ptr[i]), arg); w_symbol(SYM2ID(RARRAY_PTR(mem)[i]), arg);
w_object(RSTRUCT_PTR(obj)[i], arg, limit); w_object(RSTRUCT_PTR(obj)[i], arg, limit);
} }
} }
@ -963,7 +963,7 @@ r_object0(struct load_arg *arg, VALUE proc, int *ivp, VALUE extmod)
rb_ary_push(extmod, m); rb_ary_push(extmod, m);
v = r_object0(arg, 0, 0, extmod); v = r_object0(arg, 0, 0, extmod);
while (RARRAY(extmod)->len > 0) { while (RARRAY_LEN(extmod) > 0) {
m = rb_ary_pop(extmod); m = rb_ary_pop(extmod);
rb_extend_object(v, m); rb_extend_object(v, m);
} }
@ -1145,11 +1145,11 @@ r_object0(struct load_arg *arg, VALUE proc, int *ivp, VALUE extmod)
for (i=0; i<len; i++) { for (i=0; i<len; i++) {
slot = r_symbol(arg); slot = r_symbol(arg);
if (RARRAY(mem)->ptr[i] != ID2SYM(slot)) { if (RARRAY_PTR(mem)[i] != ID2SYM(slot)) {
rb_raise(rb_eTypeError, "struct %s not compatible (:%s for :%s)", rb_raise(rb_eTypeError, "struct %s not compatible (:%s for :%s)",
rb_class2name(klass), rb_class2name(klass),
rb_id2name(slot), rb_id2name(slot),
rb_id2name(SYM2ID(RARRAY(mem)->ptr[i]))); rb_id2name(SYM2ID(RARRAY_PTR(mem)[i])));
} }
rb_struct_aset(v, LONG2FIX(i), r_object(arg)); rb_struct_aset(v, LONG2FIX(i), r_object(arg));
} }
@ -1182,7 +1182,7 @@ r_object0(struct load_arg *arg, VALUE proc, int *ivp, VALUE extmod)
v = rb_obj_alloc(klass); v = rb_obj_alloc(klass);
if (! NIL_P(extmod)) { if (! NIL_P(extmod)) {
while (RARRAY(extmod)->len > 0) { while (RARRAY_LEN(extmod) > 0) {
VALUE m = rb_ary_pop(extmod); VALUE m = rb_ary_pop(extmod);
rb_extend_object(v, m); rb_extend_object(v, m);
} }

6
numeric.c
View file

@ -132,15 +132,15 @@ do_coerce(VALUE *x, VALUE *y, int err)
a[0] = *x; a[1] = *y; a[0] = *x; a[1] = *y;
ary = rb_rescue(coerce_body, (VALUE)a, err?coerce_rescue:0, (VALUE)a); ary = rb_rescue(coerce_body, (VALUE)a, err?coerce_rescue:0, (VALUE)a);
if (TYPE(ary) != T_ARRAY || RARRAY(ary)->len != 2) { if (TYPE(ary) != T_ARRAY || RARRAY_LEN(ary) != 2) {
if (err) { if (err) {
rb_raise(rb_eTypeError, "coerce must return [x, y]"); rb_raise(rb_eTypeError, "coerce must return [x, y]");
} }
return Qfalse; return Qfalse;
} }
*x = RARRAY(ary)->ptr[0]; *x = RARRAY_PTR(ary)[0];
*y = RARRAY(ary)->ptr[1]; *y = RARRAY_PTR(ary)[1];
return Qtrue; return Qtrue;
} }

8
object.c
View file

@ -1057,13 +1057,13 @@ sym_call(VALUE args, VALUE sym)
{ {
VALUE obj; VALUE obj;
if (RARRAY(args)->len < 1) { if (RARRAY_LEN(args) < 1) {
rb_raise(rb_eArgError, "no receiver given"); rb_raise(rb_eArgError, "no receiver given");
} }
obj = RARRAY(args)->ptr[0]; obj = RARRAY_PTR(args)[0];
return rb_funcall3(obj, (ID)sym, return rb_funcall3(obj, (ID)sym,
RARRAY(args)->len - 1, RARRAY_LEN(args) - 1,
RARRAY(args)->ptr + 1); RARRAY_PTR(args) + 1);
} }
/* /*

18
pack.c
View file

@ -452,12 +452,12 @@ pack_pack(VALUE ary, VALUE fmt)
pend = p + RSTRING_LEN(fmt); pend = p + RSTRING_LEN(fmt);
res = rb_str_buf_new(0); res = rb_str_buf_new(0);
items = RARRAY(ary)->len; items = RARRAY_LEN(ary);
idx = 0; idx = 0;
#define TOO_FEW (rb_raise(rb_eArgError, toofew), 0) #define TOO_FEW (rb_raise(rb_eArgError, toofew), 0)
#define THISFROM (items > 0 ? RARRAY(ary)->ptr[idx] : TOO_FEW) #define THISFROM (items > 0 ? RARRAY_PTR(ary)[idx] : TOO_FEW)
#define NEXTFROM (items-- > 0 ? RARRAY(ary)->ptr[idx++] : TOO_FEW) #define NEXTFROM (items-- > 0 ? RARRAY_PTR(ary)[idx++] : TOO_FEW)
while (p < pend) { while (p < pend) {
if (RSTRING_PTR(fmt) + RSTRING_LEN(fmt) != pend) { if (RSTRING_PTR(fmt) + RSTRING_LEN(fmt) != pend) {
@ -949,9 +949,9 @@ pack_pack(VALUE ary, VALUE fmt)
VALUE big128 = rb_uint2big(128); VALUE big128 = rb_uint2big(128);
while (TYPE(from) == T_BIGNUM) { while (TYPE(from) == T_BIGNUM) {
from = rb_big_divmod(from, big128); from = rb_big_divmod(from, big128);
c = NUM2INT(RARRAY(from)->ptr[1]) | 0x80; /* mod */ c = NUM2INT(RARRAY_PTR(from)[1]) | 0x80; /* mod */
rb_str_buf_cat(buf, &c, sizeof(char)); rb_str_buf_cat(buf, &c, sizeof(char));
from = RARRAY(from)->ptr[0]; /* div */ from = RARRAY_PTR(from)[0]; /* div */
} }
} }
@ -1868,8 +1868,8 @@ pack_unpack(VALUE str, VALUE fmt)
if (!(a = rb_str_associated(str))) { if (!(a = rb_str_associated(str))) {
rb_raise(rb_eArgError, "no associated pointer"); rb_raise(rb_eArgError, "no associated pointer");
} }
p = RARRAY(a)->ptr; p = RARRAY_PTR(a);
pend = p + RARRAY(a)->len; pend = p + RARRAY_LEN(a);
while (p < pend) { while (p < pend) {
if (TYPE(*p) == T_STRING && RSTRING_PTR(*p) == t) { if (TYPE(*p) == T_STRING && RSTRING_PTR(*p) == t) {
if (len < RSTRING_LEN(*p)) { if (len < RSTRING_LEN(*p)) {
@ -1913,8 +1913,8 @@ pack_unpack(VALUE str, VALUE fmt)
if (!(a = rb_str_associated(str))) { if (!(a = rb_str_associated(str))) {
rb_raise(rb_eArgError, "no associated pointer"); rb_raise(rb_eArgError, "no associated pointer");
} }
p = RARRAY(a)->ptr; p = RARRAY_PTR(a);
pend = p + RARRAY(a)->len; pend = p + RARRAY_LEN(a);
while (p < pend) { while (p < pend) {
if (TYPE(*p) == T_STRING && RSTRING_PTR(*p) == t) { if (TYPE(*p) == T_STRING && RSTRING_PTR(*p) == t) {
tmp = *p; tmp = *p;

12
process.c
View file

@ -1167,11 +1167,11 @@ rb_check_argv(int argc, VALUE *argv)
prog = 0; prog = 0;
tmp = rb_check_array_type(argv[0]); tmp = rb_check_array_type(argv[0]);
if (!NIL_P(tmp)) { if (!NIL_P(tmp)) {
if (RARRAY(tmp)->len != 2) { if (RARRAY_LEN(tmp) != 2) {
rb_raise(rb_eArgError, "wrong first argument"); rb_raise(rb_eArgError, "wrong first argument");
} }
prog = RARRAY(tmp)->ptr[0]; prog = RARRAY_PTR(tmp)[0];
argv[0] = RARRAY(tmp)->ptr[1]; argv[0] = RARRAY_PTR(tmp)[1];
SafeStringValue(prog); SafeStringValue(prog);
} }
for (i = 0; i < argc; i++) { for (i = 0; i < argc; i++) {
@ -2647,14 +2647,14 @@ proc_setgroups(VALUE obj, VALUE ary)
Check_Type(ary, T_ARRAY); Check_Type(ary, T_ARRAY);
ngroups = RARRAY(ary)->len; ngroups = RARRAY_LEN(ary);
if (ngroups > maxgroups) if (ngroups > maxgroups)
rb_raise(rb_eArgError, "too many groups, %lu max", (unsigned long)maxgroups); rb_raise(rb_eArgError, "too many groups, %lu max", (unsigned long)maxgroups);
groups = ALLOCA_N(rb_gid_t, ngroups); groups = ALLOCA_N(rb_gid_t, ngroups);
for (i = 0; i < ngroups && i < RARRAY(ary)->len; i++) { for (i = 0; i < ngroups && i < RARRAY_LEN(ary); i++) {
VALUE g = RARRAY(ary)->ptr[i]; VALUE g = RARRAY_PTR(ary)[i];
if (FIXNUM_P(g)) { if (FIXNUM_P(g)) {
groups[i] = FIX2INT(g); groups[i] = FIX2INT(g);

6
ruby.c
View file

@ -390,8 +390,8 @@ process_sflag(void)
long n; long n;
VALUE *args; VALUE *args;
n = RARRAY(rb_argv)->len; n = RARRAY_LEN(rb_argv);
args = RARRAY(rb_argv)->ptr; args = RARRAY_PTR(rb_argv);
while (n > 0) { while (n > 0) {
VALUE v = *args++; VALUE v = *args++;
char *s = StringValuePtr(v); char *s = StringValuePtr(v);
@ -434,7 +434,7 @@ process_sflag(void)
} }
rb_gv_set(s, v); rb_gv_set(s, v);
} }
n = RARRAY(rb_argv)->len - n; n = RARRAY_LEN(rb_argv) - n;
while (n--) { while (n--) {
rb_ary_shift(rb_argv); rb_ary_shift(rb_argv);
} }

28
ruby.h
View file

@ -390,15 +390,33 @@ struct RString {
RSTRING(str)->as.ary : \ RSTRING(str)->as.ary : \
RSTRING(str)->as.heap.ptr) RSTRING(str)->as.heap.ptr)
#define RARRAY_EMBED_LEN_MAX 3
struct RArray { struct RArray {
struct RBasic basic; struct RBasic basic;
long len;
union { union {
long capa; struct {
VALUE shared; long len;
} aux; union {
VALUE *ptr; long capa;
VALUE shared;
} aux;
VALUE *ptr;
} heap;
VALUE ary[RARRAY_EMBED_LEN_MAX];
} as;
}; };
#define RARRAY_NOEMBED FL_USER3
#define RARRAY_EMBED_LEN_MASK (FL_USER4|FL_USER5)
#define RARRAY_EMBED_LEN_SHIFT (FL_USHIFT+4)
#define RARRAY_LEN(a) \
(!(RBASIC(a)->flags & RARRAY_NOEMBED) ? \
(long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \
(RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)) : \
RARRAY(a)->as.heap.len)
#define RARRAY_PTR(a) \
(!(RBASIC(a)->flags & RARRAY_NOEMBED) ? \
RARRAY(a)->as.ary : \
RARRAY(a)->as.heap.ptr)
struct RRegexp { struct RRegexp {
struct RBasic basic; struct RBasic basic;

11
string.c
View file

@ -43,6 +43,7 @@ VALUE rb_cString;
FL_SET(str, STR_NOEMBED);\ FL_SET(str, STR_NOEMBED);\
STR_SET_EMBED_LEN(str, 0);\ STR_SET_EMBED_LEN(str, 0);\
} while (0) } while (0)
#define STR_SET_EMBED(str) FL_UNSET(str, STR_NOEMBED)
#define STR_EMBED_P(str) (!FL_TEST(str, STR_NOEMBED)) #define STR_EMBED_P(str) (!FL_TEST(str, STR_NOEMBED))
#define STR_SET_EMBED_LEN(str, n) do { \ #define STR_SET_EMBED_LEN(str, n) do { \
long tmp_n = (n);\ long tmp_n = (n);\
@ -299,7 +300,7 @@ rb_str_shared_replace(VALUE str, VALUE str2)
rb_str_modify(str); rb_str_modify(str);
if (OBJ_TAINTED(str2)) OBJ_TAINT(str); if (OBJ_TAINTED(str2)) OBJ_TAINT(str);
if (RSTRING_LEN(str2) <= RSTRING_EMBED_LEN_MAX) { if (RSTRING_LEN(str2) <= RSTRING_EMBED_LEN_MAX) {
FL_UNSET(str, STR_NOEMBED); STR_SET_EMBED(str);
memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), RSTRING_LEN(str2)+1); memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), RSTRING_LEN(str2)+1);
STR_SET_EMBED_LEN(str, RSTRING_LEN(str2)); STR_SET_EMBED_LEN(str, RSTRING_LEN(str2));
return; return;
@ -482,7 +483,7 @@ static VALUE
rb_str_format_m(VALUE str, VALUE arg) rb_str_format_m(VALUE str, VALUE arg)
{ {
if (TYPE(arg) == T_ARRAY) { if (TYPE(arg) == T_ARRAY) {
return rb_str_format(RARRAY(arg)->len, RARRAY(arg)->ptr, str); return rb_str_format(RARRAY_LEN(arg), RARRAY_PTR(arg), str);
} }
return rb_str_format(1, &arg, str); return rb_str_format(1, &arg, str);
} }
@ -2301,7 +2302,7 @@ rb_str_clear(VALUE str)
if (str_independent(str)) { if (str_independent(str)) {
free(RSTRING_PTR(str)); free(RSTRING_PTR(str));
} }
FL_UNSET(str, STR_NOEMBED); STR_SET_EMBED(str);
STR_SET_EMBED_LEN(str, 0); STR_SET_EMBED_LEN(str, 0);
RSTRING_PTR(str)[0] = 0; RSTRING_PTR(str)[0] = 0;
return str; return str;
@ -3505,8 +3506,8 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str)
rb_ary_push(result, tmp); rb_ary_push(result, tmp);
} }
if (NIL_P(limit) && lim == 0) { if (NIL_P(limit) && lim == 0) {
while (RARRAY(result)->len > 0 && while (RARRAY_LEN(result) > 0 &&
RSTRING_LEN(RARRAY(result)->ptr[RARRAY(result)->len-1]) == 0) RSTRING_LEN(RARRAY_PTR(result)[RARRAY_LEN(result)-1]) == 0)
rb_ary_pop(result); rb_ary_pop(result);
} }

54
struct.c
View file

@ -47,9 +47,9 @@ rb_struct_members(VALUE s)
{ {
VALUE members = rb_struct_s_members(rb_obj_class(s)); VALUE members = rb_struct_s_members(rb_obj_class(s));
if (RSTRUCT_LEN(s) != RARRAY(members)->len) { if (RSTRUCT_LEN(s) != RARRAY_LEN(members)) {
rb_raise(rb_eTypeError, "struct size differs (%ld required %ld given)", rb_raise(rb_eTypeError, "struct size differs (%ld required %ld given)",
RARRAY(members)->len, RSTRUCT_LEN(s)); RARRAY_LEN(members), RSTRUCT_LEN(s));
} }
return members; return members;
} }
@ -61,8 +61,8 @@ rb_struct_s_members_m(VALUE klass)
VALUE *p, *pend; VALUE *p, *pend;
members = rb_struct_s_members(klass); members = rb_struct_s_members(klass);
ary = rb_ary_new2(RARRAY(members)->len); ary = rb_ary_new2(RARRAY_LEN(members));
p = RARRAY(members)->ptr; pend = p + RARRAY(members)->len; p = RARRAY_PTR(members); pend = p + RARRAY_LEN(members);
while (p < pend) { while (p < pend) {
rb_ary_push(ary, rb_str_new2(rb_id2name(SYM2ID(*p)))); rb_ary_push(ary, rb_str_new2(rb_id2name(SYM2ID(*p))));
p++; p++;
@ -97,8 +97,8 @@ rb_struct_getmember(VALUE obj, ID id)
members = rb_struct_members(obj); members = rb_struct_members(obj);
slot = ID2SYM(id); slot = ID2SYM(id);
for (i=0; i<RARRAY(members)->len; i++) { for (i=0; i<RARRAY_LEN(members); i++) {
if (RARRAY(members)->ptr[i] == slot) { if (RARRAY_PTR(members)[i] == slot) {
return RSTRUCT_PTR(obj)[i]; return RSTRUCT_PTR(obj)[i];
} }
} }
@ -154,8 +154,8 @@ rb_struct_set(VALUE obj, VALUE val)
members = rb_struct_members(obj); members = rb_struct_members(obj);
rb_struct_modify(obj); rb_struct_modify(obj);
for (i=0; i<RARRAY(members)->len; i++) { for (i=0; i<RARRAY_LEN(members); i++) {
slot = RARRAY(members)->ptr[i]; slot = RARRAY_PTR(members)[i];
if (rb_id_attrset(SYM2ID(slot)) == rb_frame_this_func()) { if (rb_id_attrset(SYM2ID(slot)) == rb_frame_this_func()) {
return RSTRUCT_PTR(obj)[i] = val; return RSTRUCT_PTR(obj)[i] = val;
} }
@ -191,15 +191,15 @@ make_struct(VALUE name, VALUE members, VALUE klass)
} }
nstr = rb_define_class_under(klass, rb_id2name(id), klass); nstr = rb_define_class_under(klass, rb_id2name(id), klass);
} }
rb_iv_set(nstr, "__size__", LONG2NUM(RARRAY(members)->len)); rb_iv_set(nstr, "__size__", LONG2NUM(RARRAY_LEN(members)));
rb_iv_set(nstr, "__members__", members); rb_iv_set(nstr, "__members__", members);
rb_define_alloc_func(nstr, struct_alloc); rb_define_alloc_func(nstr, struct_alloc);
rb_define_singleton_method(nstr, "new", rb_class_new_instance, -1); rb_define_singleton_method(nstr, "new", rb_class_new_instance, -1);
rb_define_singleton_method(nstr, "[]", rb_class_new_instance, -1); rb_define_singleton_method(nstr, "[]", rb_class_new_instance, -1);
rb_define_singleton_method(nstr, "members", rb_struct_s_members_m, 0); rb_define_singleton_method(nstr, "members", rb_struct_s_members_m, 0);
for (i=0; i< RARRAY(members)->len; i++) { for (i=0; i< RARRAY_LEN(members); i++) {
ID id = SYM2ID(RARRAY(members)->ptr[i]); ID id = SYM2ID(RARRAY_PTR(members)[i]);
if (rb_is_local_id(id) || rb_is_const_id(id)) { if (rb_is_local_id(id) || rb_is_const_id(id)) {
if (i < N_REF_FUNC) { if (i < N_REF_FUNC) {
rb_define_method_id(nstr, id, ref_func[i], 0); rb_define_method_id(nstr, id, ref_func[i], 0);
@ -278,9 +278,9 @@ rb_struct_s_def(int argc, VALUE *argv, VALUE klass)
ID id; ID id;
rb_scan_args(argc, argv, "1*", &name, &rest); rb_scan_args(argc, argv, "1*", &name, &rest);
for (i=0; i<RARRAY(rest)->len; i++) { for (i=0; i<RARRAY_LEN(rest); i++) {
id = rb_to_id(RARRAY(rest)->ptr[i]); id = rb_to_id(RARRAY_PTR(rest)[i]);
RARRAY(rest)->ptr[i] = ID2SYM(id); RARRAY_PTR(rest)[i] = ID2SYM(id);
} }
if (!NIL_P(name)) { if (!NIL_P(name)) {
VALUE tmp = rb_check_string_type(name); VALUE tmp = rb_check_string_type(name);
@ -312,13 +312,13 @@ rb_struct_initialize(VALUE self, VALUE values)
rb_struct_modify(self); rb_struct_modify(self);
size = rb_struct_iv_get(klass, "__size__"); size = rb_struct_iv_get(klass, "__size__");
n = FIX2LONG(size); n = FIX2LONG(size);
if (n < RARRAY(values)->len) { if (n < RARRAY_LEN(values)) {
rb_raise(rb_eArgError, "struct size differs"); rb_raise(rb_eArgError, "struct size differs");
} }
MEMCPY(RSTRUCT_PTR(self), RARRAY(values)->ptr, VALUE, RARRAY(values)->len); MEMCPY(RSTRUCT_PTR(self), RARRAY_PTR(values), VALUE, RARRAY_LEN(values));
if (n > RARRAY(values)->len) { if (n > RARRAY_LEN(values)) {
rb_mem_clear(RSTRUCT_PTR(self)+RARRAY(values)->len, rb_mem_clear(RSTRUCT_PTR(self)+RARRAY_LEN(values),
n-RARRAY(values)->len); n-RARRAY_LEN(values));
} }
return Qnil; return Qnil;
} }
@ -351,7 +351,7 @@ struct_alloc(VALUE klass)
VALUE VALUE
rb_struct_alloc(VALUE klass, VALUE values) rb_struct_alloc(VALUE klass, VALUE values)
{ {
return rb_class_new_instance(RARRAY(values)->len, RARRAY(values)->ptr, klass); return rb_class_new_instance(RARRAY_LEN(values), RARRAY_PTR(values), klass);
} }
VALUE VALUE
@ -456,7 +456,7 @@ inspect_struct(VALUE s, VALUE dummy, int recur)
if (i > 0) { if (i > 0) {
rb_str_cat2(str, ", "); rb_str_cat2(str, ", ");
} }
slot = RARRAY(members)->ptr[i]; slot = RARRAY_PTR(members)[i];
id = SYM2ID(slot); id = SYM2ID(slot);
if (rb_is_local_id(id) || rb_is_const_id(id)) { if (rb_is_local_id(id) || rb_is_const_id(id)) {
p = rb_id2name(id); p = rb_id2name(id);
@ -535,9 +535,9 @@ rb_struct_aref_id(VALUE s, ID id)
long i, len; long i, len;
members = rb_struct_members(s); members = rb_struct_members(s);
len = RARRAY(members)->len; len = RARRAY_LEN(members);
for (i=0; i<len; i++) { for (i=0; i<len; i++) {
if (SYM2ID(RARRAY(members)->ptr[i]) == id) { if (SYM2ID(RARRAY_PTR(members)[i]) == id) {
return RSTRUCT_PTR(s)[i]; return RSTRUCT_PTR(s)[i];
} }
} }
@ -592,13 +592,13 @@ rb_struct_aset_id(VALUE s, ID id, VALUE val)
members = rb_struct_members(s); members = rb_struct_members(s);
rb_struct_modify(s); rb_struct_modify(s);
len = RARRAY(members)->len; len = RARRAY_LEN(members);
if (RSTRUCT_LEN(s) != RARRAY(members)->len) { if (RSTRUCT_LEN(s) != RARRAY_LEN(members)) {
rb_raise(rb_eTypeError, "struct size differs (%ld required %ld given)", rb_raise(rb_eTypeError, "struct size differs (%ld required %ld given)",
RARRAY(members)->len, RSTRUCT_LEN(s)); RARRAY_LEN(members), RSTRUCT_LEN(s));
} }
for (i=0; i<len; i++) { for (i=0; i<len; i++) {
if (SYM2ID(RARRAY(members)->ptr[i]) == id) { if (SYM2ID(RARRAY_PTR(members)[i]) == id) {
RSTRUCT_PTR(s)[i] = val; RSTRUCT_PTR(s)[i] = val;
return val; return val;
} }