Ruby 1.9.1-p378 C Расширением rb_block_call Странность
-
13-09-2020 - |
Вопрос
Я работаю с тем, что должно быть довольно простой итерацией.Я понимаю, что я мог бы выполнить это с помощью кода Ruby, но я уже работаю с расширением C, поэтому я бы предпочел сохранить эту функцию на C вместе с остальным кодом - тем более, что это следует работайте (так или иначе) без проблем.
Проблема связана с rb_block_call.Вот как README.EXT описывает rb_block_call:
VALUE rb_block_call(VALUE recv, ID mid, int argc, VALUE * argv, VALUE (*func) (ANYARGS), VALUE data2)
Вызывает метод в recv с именем метода, указанным символом mid, предоставляя функцию в качестве блока.функция получит значение из yield в качестве первого аргумента, data2 в качестве второго и argc / argv в качестве третьего / четвертого аргументов.
Итак, мое понимание (проверенное путем просмотра внутренних компонентов Ruby) заключается в том, что принимающая функция должна выглядеть следующим образом:
VALUE function( VALUE rb_yield_value, VALUE data2, int argc, VALUE argv );
И тут мы сталкиваемся с нашей проблемой.В моем варианте использования (который я приведу ниже) rb_yield_value и data2 передаются как ожидалось;argc, с другой стороны, всегда имеет значение 1, argv[ 0 ] - rb_yield_value, argv[ 1 ] - false, argv[ 2 ] - rb_yield_value, argv[ 3 ] выдает исключение.
Не имеет значения, что я принимаю за argc и argv;передача 0 и NULL приводит к тому же результату, что и 1 и ЗНАЧЕНИЕ, равное Qtrue.Все с argc / argv остается таким, как описано.
Вот код, с которым я работаю:
VALUE rb_RPBDB_DatabaseObject_internal_cursorForCallingContext( VALUE rb_self ) {
// when we are looking for the contextual iterator, we look up the current backtrace
// at each level of the backtrace we have an object and a method;
// if this object and method match keys present in self (tracking calling contexts for iteration in this iteration class) return cursor
VALUE rb_cursor_context_storage_hash = rb_RPBDB_DatabaseObject_internal_cursorContextStorageHash( rb_self );
VALUE rb_cursor = Qnil;
if ( RHASH_SIZE( rb_cursor_context_storage_hash ) ) {
rb_block_call( rb_mKernel,
rb_intern( "each_backtrace_frame" ),
1,
& rb_cursor_context_storage_hash,
rb_RPBDB_DatabaseObject_internal_each_backtrace_frame,
rb_cursor );
}
return rb_cursor;
}
// walk up the stack one frame at a time
// for each frame we need to see if object/method are defined in our context storage hash
VALUE rb_RPBDB_DatabaseObject_internal_each_backtrace_frame( VALUE rb_this_backtrace_frame_hash,
VALUE rb_cursor_return,
int argc,
VALUE* args ) {
// why are we getting 3 args when argc is 1 and none of the 3 match what was passed?
VALUE rb_cursor_context_storage_hash = args[ 0 ];
// each frame is identifiable as object/method
VALUE rb_this_frame_object = rb_hash_aref( rb_this_backtrace_frame_hash,
ID2SYM( rb_intern( "object" ) ) );
VALUE rb_this_frame_method = rb_hash_aref( rb_this_backtrace_frame_hash,
ID2SYM( rb_intern( "method" ) ) );
// we likely have "block in ..." for our method; we only want the "..."
rb_this_frame_method = ID2SYM( rb_to_id( rb_funcall( rb_obj_as_string( rb_this_frame_method ),
rb_intern( "gsub" ),
2,
rb_str_new2( "block in " ),
rb_str_new2( "" ) ) ) );
VALUE rb_cursor_object_context_hash = rb_RPBDB_DatabaseObject_internal_cursorObjectContextStorageHash( rb_cursor_context_storage_hash,
rb_this_frame_object);
if ( RHASH_SIZE( rb_cursor_object_context_hash ) ) {
rb_cursor_return = rb_hash_aref( rb_cursor_object_context_hash,
rb_this_frame_method );
}
return rb_cursor_return;
}
Внутри Ruby, похоже, не так много примеров rb_block_call с argc / argv...Самое большее один или два, и я полагаю, что все они просто передают значения внутренне, а не используют их.
Мысли?
Решение
Я довольно новичок в расширении Ruby C, но я думаю, в чем причина вашей путаницы.
VALUE rb_block_call(VALUE recv, ID mid, int argc, VALUE argv[],
VALUE (*func) (ANYARGS), VALUE data2)
argc/argv - это здесь аргументы вызываемой вами функции Ruby.
В C-функции, вызываемой как блок:
VALUE block_function(VALUE rb_yield_value, VALUE data2, int argc, VALUE argv[])
argc /argv - это аргументы блока.
Простым примером является инъекция
Вот перевод на язык Си:[1,2,3].ввести { |sum, e| sum + e }
#include "ruby.h"
static VALUE rb_puts(VALUE obj) {
return rb_funcall(rb_mKernel, rb_intern("puts"), 1, obj);
}
static VALUE inject_block(VALUE yield_value, VALUE data2, int argc, VALUE argv[]) {
printf("\nyield_value:\n");
rb_puts(yield_value);
printf("data2:\n");
rb_puts(data2);
printf("argc: %d\n", argc);
printf("argv:\n");
int i;
for(i = 0; i < argc; ++i) {
printf("argv %d:\n", i);
rb_puts(argv[i]);
}
VALUE sum = argv[0];
VALUE e = argv[1];// or yield_value
return INT2FIX(FIX2INT(sum) + FIX2INT(e));
}
static VALUE rb_block_call_test(int argc, VALUE argv[]) {
VALUE ary = rb_ary_new();
int i;
for(i = 0; i < 3; ++i) {
rb_ary_push(ary, INT2FIX(i+1));
}
VALUE block_argv[1];
block_argv[0] = INT2FIX(0);
ary = rb_block_call(ary,
rb_intern("inject"),
1, // argc
block_argv, //argv is a C-array of VALUE
inject_block,
Qtrue // data2
);
return ary;
}
void Init_rb_block_call() {
rb_define_global_function("rb_block_call_test", rb_block_call_test, 0);
}
какие выходные данные (вызова rb_block_call_test):
yield_value: 0 # sum = argv[0]
data2: true
argc: 2
argv:
argv 0: 0 # sum
argv 1: 1 # e
yield_value: 1
data2: true
argc: 2
argv:
argv 0: 1
argv 1: 2
yield_value: 3
data2: true
argc: 2
argv:
argv 0: 3
argv 1: 3
# => 6
Я считаю, что yield_value всегда равно argv[0]
Если вы хотите передать информацию между блоком и вызывающим абонентом, то используйте data2
В вашем примере я полагаю, что #each_backtrace_frame выдает один "backtrace_frame", и поэтому argc / argv блока всегда равен 1 /the_backtrace_frame.Я полагаю, что #each_backtrace_frame принимает любое количество аргументов, поскольку он не вызвал никакой ошибки, когда вы попытались передать некоторые из них.