/* :nodoc: */
static VALUE
yielder_yield(VALUE obj, VALUE args)
{
struct yielder *ptr = yielder_ptr(obj);
return rb_proc_call(ptr->proc, args);
}
static duk_ret_t ctx_call_pushed_function(duk_context *ctx) {
VALUE block; // the block to yield
struct state *state;
int nargs = duk_get_top(ctx); // number of arguments of the block (arity)
VALUE args = rb_ary_new(); // the block to yield needs an array of arguments
VALUE result; // the result returned by yielding the block
duk_push_current_function(ctx);
// get the block which is a property of the pushed function
duk_get_prop_string(ctx, -1, "block");
block = (VALUE) duk_get_pointer(ctx, -1);
duk_pop(ctx);
// get the state so that we don't need to a create a new one
duk_get_prop_string(ctx, -1, "state");
state = (struct state *) duk_get_pointer(ctx, -1);
duk_pop(ctx);
// before pushing each argument to the array, each one needs to be converted into a ruby value
for (int i = 0; i < nargs; i++)
rb_ary_push(args, ctx_stack_to_value(state, i));
result = rb_proc_call(block, args); // yield
ctx_push_ruby_object(state, result);
return 1;
}
static VALUE
proc_call(VALUE proc, VALUE args)
{
if (TYPE(args) != T_ARRAY) {
args = rb_ary_new3(1, args);
}
return rb_proc_call(proc, args);
}
void rb_parser_callback_call(VALUE self, const char *name, char *data, size_t length) {
VALUE callback = rb_hash_aref(rb_iv_get(self, "@callbacks"), ID2SYM(rb_intern(name)));
if (!NIL_P(callback)) {
VALUE args = rb_ary_new();
if (data)
rb_ary_push(args, rb_str_new(data, length));
rb_proc_call(callback, args);
}
}
static int php_ub_write(const char *str, unsigned int str_length TSRMLS_DC)
{
if (!NIL_P(callback_output)) {
VALUE args = rb_ary_new();
rb_ary_push(args, rb_str_new(str, str_length));
rb_proc_call(callback_output, args);
}
return str_length;
}
/* :nodoc: */
static VALUE
generator_each(VALUE obj)
{
struct generator *ptr = generator_ptr(obj);
VALUE yielder;
yielder = yielder_new();
return rb_proc_call(ptr->proc, rb_ary_new3(1, yielder));
}
/* :nodoc: */
static VALUE
generator_each(int argc, VALUE *argv, VALUE obj)
{
struct generator *ptr = generator_ptr(obj);
VALUE args = rb_ary_new2(argc + 1);
rb_ary_push(args, yielder_new());
if (argc > 0) {
rb_ary_cat(args, argv, argc);
}
return rb_proc_call(ptr->proc, args);
}
static VALUE
bug_proc_call_super(RB_BLOCK_CALL_FUNC_ARGLIST(yieldarg, procarg))
{
VALUE args[2];
VALUE ret;
args[0] = yieldarg;
args[1] = procarg;
ret = rb_call_super(2, args);
if (!NIL_P(blockarg)) {
ret = rb_proc_call(blockarg, ret);
}
return ret;
}
static
void call_expr_userfnc (ABSTRACT_CALLER* callback_state, ABSTRACT_ARGLIST* arglist, ABSTRACT_USERFUNC* hashvalptr, ABSTRACT_EXPRVAL* exprval) {
char* empty = "";
VALUE self = (VALUE)callback_state;
VALUE func = (VALUE)hashvalptr;
VALUE args = (VALUE)arglist;
PSTRING retvalpstr = { empty, empty };
if (hashvalptr==NULL) {
rb_raise(rb_eRuntimeError, "FATAL INTERNAL ERROR:Call_EXPR:function called but not exists");
tmplpro_set_expr_as_pstring(exprval, retvalpstr);
return;
} else if (NIL_P(func) || !rb_obj_is_kind_of(func, rb_cProc)) {
rb_raise(rb_eRuntimeError, "FATAL INTERNAL ERROR:Call_EXPR:not a Proc object");
tmplpro_set_expr_as_pstring(exprval, retvalpstr);
return;
}
/* head of args is not a true aruguments(it is a regisotry of args). */
VALUE tmp = rb_ary_shift(args);
VALUE retval = rb_proc_call(func, args);
rb_ary_unshift(args, tmp);
VALUE registory = Qnil;
switch (TYPE(retval)) {
case T_FIXNUM:
tmplpro_set_expr_as_int64(exprval, FIX2LONG(retval));
break;
case T_TRUE:
tmplpro_set_expr_as_int64(exprval, 1);
break;
case T_FALSE:
tmplpro_set_expr_as_int64(exprval, 0);
break;
case T_FLOAT:
tmplpro_set_expr_as_double(exprval, NUM2DBL(retval));
break;
case T_NIL:
tmplpro_set_expr_as_null(exprval);
break;
default:
registory = rb_ivar_get(self, rb_intern("@internal_expr_results"));
rb_ary_push(registory, retval);
retvalpstr.begin = StringValuePtr(retval);
retvalpstr.endnext = retvalpstr.begin + RSTRING_LEN(retval);
tmplpro_set_expr_as_pstring(exprval, retvalpstr);
}
return;
}
static
int is_ABSTRACT_VALUE_true_impl (ABSTRACT_DATASTATE *none, ABSTRACT_VALUE* valptr) {
VALUE val = (VALUE)valptr;
if (NIL_P(val)) return 0;
if (rb_obj_is_kind_of(val, rb_cProc)) {
val = rb_proc_call(val, rb_ary_new());
}
if (NIL_P(val) || TYPE(val) == T_FALSE) return 0;
return 1;
}
static VALUE
enumerator_size(VALUE obj)
{
struct enumerator *e = enumerator_ptr(obj);
if (e->size_fn) {
return (*e->size_fn)(e->obj, e->args, obj);
}
if (rb_obj_is_proc(e->size)) {
if (e->args)
return rb_proc_call(e->size, e->args);
else
return rb_proc_call_with_block(e->size, 0, 0, Qnil);
}
return e->size;
}
static VALUE
curry(VALUE dummy, VALUE args, int argc, VALUE *argv)
{
VALUE proc, passed, arity;
proc = RARRAY_AT(args, 0);
passed = RARRAY_AT(args, 1);
arity = RARRAY_AT(args, 2);
passed = rb_ary_plus(passed, rb_ary_new4(argc, argv));
rb_ary_freeze(passed);
if(RARRAY_LEN(passed) < FIX2INT(arity)) {
arity = make_curry_proc(proc, passed, arity);
return arity;
}
arity = rb_proc_call(proc, passed);
return arity;
}
/*
* @api private
*/
static VALUE qml_init(VALUE module, VALUE args) {
if (!NIL_P(rbqml_application)) {
rb_raise(rb_eRuntimeError, "QML already initialized");
}
rbqml_application = rb_funcall(rbqml_cApplication, rb_intern("new"), 1, args);
rbqml_engine = rb_funcall(rbqml_cEngine, rb_intern("new"), 0);
rb_gc_register_address(&rbqml_application);
rb_gc_register_address(&rbqml_engine);
VALUE blocks = rb_const_get(module, rb_intern("INIT_BLOCKS"));
for (int i = 0; i < RARRAY_LEN(blocks); ++i) {
rb_proc_call(RARRAY_AREF(blocks, i), rb_ary_new());
}
return module;
}
static
PSTRING ABSTRACT_VALUE2PSTRING_impl (ABSTRACT_DATASTATE *none, ABSTRACT_VALUE* valptr) {
VALUE val = (VALUE)valptr;
PSTRING retval = {NULL,NULL};
if (valptr == NULL) return retval;
if (rb_obj_is_kind_of(val, rb_cProc)) {
val = rb_proc_call(val, rb_ary_new());
}
if (TYPE(val) != T_STRING) {
ID to_s = rb_intern("to_s");
val = rb_funcall(val, to_s, 0);
}
retval.begin = RSTRING_PTR(val);
retval.endnext = retval.begin + RSTRING_LEN(val);
return retval;
}
VALUE
protect_fs_ruby_call_func(VALUE argv){
VALUE* argvs = (VALUE*)argv;
VALUE argc_num = argvs[0];
VALUE server_instance = argvs[1];
ID method_id = argvs[2];
int argc = FIX2INT(argc_num);
if(server_instance == Qnil){
return Qnil;
}
if (argc == -1) {
VALUE proc = (VALUE)argvs[1];
VALUE proc_argv = LL2NUM(argvs[2]);
VALUE proc_argvs = rb_ary_new();
rb_ary_push(proc_argvs, proc_argv);
rb_proc_call(proc, proc_argvs);
rb_ary_free(proc_argvs);
}
if(argc == 0){
rb_funcall(server_instance, method_id, argc, 0);
}
if(argc == 1){
VALUE argv = argvs[3];
rb_funcall(server_instance, method_id, argc, argv);
}
if(argc == 2){
VALUE node_id = argvs[3];
VALUE pack = argvs[4];
rb_funcall(server_instance, method_id, argc, node_id, pack);
}
return Qnil;
}
void
rb_call_end_proc(VALUE data)
{
rb_proc_call(data, rb_ary_new());
}
