static gboolean
set_out_arg (JSContext *js_context,
GIFunctionInfo *func_info,
gboolean is_return_value,
GIArgInfo *arg_info,
GITypeInfo *type_info,
gpointer ptr,
jsval js_value)
{
gboolean nullable;
GITransfer transfer;
GIArgument argument;
GjsArgumentType arg_type;
if (is_return_value)
{
arg_type = GJS_ARGUMENT_RETURN_VALUE;
nullable = g_callable_info_may_return_null (func_info);
transfer = g_callable_info_get_caller_owns (func_info);
}
else
{
arg_type = GJS_ARGUMENT_ARGUMENT;
nullable = g_arg_info_may_be_null (arg_info);
transfer = g_arg_info_get_ownership_transfer (arg_info);
}
if (!gjs_value_to_g_argument (js_context, js_value, type_info, NULL,
arg_type, transfer, nullable, &argument))
{
if (is_return_value)
{
g_warning ("Error failed to convert return value to GIArgument");
}
else
{
g_warning ("Error failed to convert OUT argument '%s' from "
"jsval to GIArgument", g_base_info_get_name (arg_info));
}
return FALSE;
}
peas_gi_argument_to_pointer (type_info, &argument, ptr);
return TRUE;
}
static gboolean
peas_extension_gjs_call (PeasExtensionWrapper *exten,
GType exten_type,
GICallableInfo *func_info,
const gchar *method_name,
GIArgument *args,
GIArgument *retval)
{
PeasExtensionGjs *gexten = PEAS_EXTENSION_GJS (exten);
gboolean success = FALSE;
jsval js_method, js_retval;
jsval *js_args;
CachedArg *arg_cache;
gint i, n_args, nth_out_arg;
gint n_in_args = 0;
gint n_out_args = 0;
gint cached_args = 0;
/* Fetch the JS method we want to call */
if (!JS_GetProperty (gexten->js_context, gexten->js_object,
method_name, &js_method) ||
JSVAL_IS_VOID (js_method))
{
g_warning ("Method '%s.%s' was not found",
g_type_name (exten_type), method_name);
return FALSE;
}
if (JSVAL_IS_NULL (js_method) || !JSVAL_IS_OBJECT (js_method) ||
!JS_ObjectIsFunction (gexten->js_context, JSVAL_TO_OBJECT (js_method)))
{
g_warning ("Method '%s.%s' in not a function",
g_type_name (exten_type), method_name);
return FALSE;
}
n_args = g_callable_info_get_n_args (func_info);
if (n_args < 0)
{
g_warn_if_fail (n_args >= 0);
return FALSE;
}
js_args = g_newa (jsval, n_args);
arg_cache = g_newa (CachedArg, n_args + 1);
/* Return value is an out arg */
g_callable_info_load_return_type (func_info, &arg_cache[0].type_info);
if (g_type_info_get_tag (&arg_cache[0].type_info) != GI_TYPE_TAG_VOID)
{
++n_out_args;
arg_cache[cached_args++].ptr = &retval->v_pointer;
}
/* Handle the arguments */
for (i = 0; i < n_args; ++i, ++cached_args)
{
GIDirection direction;
g_callable_info_load_arg (func_info, i, &arg_cache[cached_args].arg_info);
direction = g_arg_info_get_direction (&arg_cache[cached_args].arg_info);
g_arg_info_load_type (&arg_cache[cached_args].arg_info,
&arg_cache[cached_args].type_info);
if (direction == GI_DIRECTION_IN &&
!gjs_value_from_g_argument (gexten->js_context, &js_args[n_in_args++],
&arg_cache[cached_args].type_info,
&args[i], TRUE))
{
g_warning ("Error failed to convert argument '%s'",
g_base_info_get_name (&arg_cache[cached_args].arg_info));
return FALSE;
}
if (direction == GI_DIRECTION_INOUT)
{
GIArgument arg;
peas_gi_pointer_to_argument (&arg_cache[cached_args].type_info,
args[i].v_pointer, &arg);
if (!gjs_value_from_g_argument (gexten->js_context, &js_args[n_in_args++],
&arg_cache[cached_args].type_info, &arg, TRUE))
{
g_warning ("Error failed to convert argument '%s'",
g_base_info_get_name (&arg_cache[cached_args].arg_info));
return FALSE;
}
}
if (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT)
{
++n_out_args;
arg_cache[cached_args].ptr = args[i].v_pointer;
}
}
success = JS_CallFunctionValue (gexten->js_context, gexten->js_object,
js_method, n_in_args, js_args, &js_retval);
if (!success)
{
if (!gjs_log_exception (gexten->js_context, NULL))
{
g_warning ("Error while calling '%s.%s'",
g_type_name (exten_type), method_name);
}
return FALSE;
}
/* First we need to release in argument */
for (i = 0; i < cached_args; ++i)
{
GIDirection direction;
/* First cached argument may be the return value */
if (i == 0 && cached_args > n_args)
continue;
direction = g_arg_info_get_direction (&arg_cache[i].arg_info);
if (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT)
{
GITransfer transfer;
transfer = g_arg_info_get_ownership_transfer (&arg_cache[i].arg_info);
if (!gjs_g_argument_release_in_arg (gexten->js_context, transfer,
&arg_cache[i].type_info,
&args[i]))
{
g_warning ("Error failed to release IN argument '%s'",
g_base_info_get_name (&arg_cache[i].arg_info));
}
}
}
/* Check that we have a valid return value */
if (n_out_args > 1)
{
if (!JSVAL_IS_OBJECT (js_retval) ||
!JS_IsArrayObject (gexten->js_context, JSVAL_TO_OBJECT (js_retval)))
{
g_warning ("Error return value is not an array");
return FALSE;
}
}
/* Set out arguments */
for (i = 0, nth_out_arg = 0; i < cached_args && success; ++i)
{
gboolean is_return_value;
is_return_value = i == 0 && cached_args > n_args;
/* Return value does not have a GIArgInfo and is always out */
if (!is_return_value)
{
GIDirection direction;
direction = g_arg_info_get_direction (&arg_cache[i].arg_info);
if (direction == GI_DIRECTION_IN)
continue;
}
if (n_out_args == 1)
{
success = set_out_arg (gexten->js_context, func_info, is_return_value,
&arg_cache[i].arg_info, &arg_cache[i].type_info,
arg_cache[i].ptr, js_retval);
break;
}
else if (n_out_args > 1)
{
jsval js_value;
if (!JS_GetElement (gexten->js_context, JSVAL_TO_OBJECT (js_retval),
nth_out_arg++, &js_value) ||
js_value == JSVAL_VOID)
{
g_warning ("Error failed to get out argument %i", nth_out_arg);
return FALSE;
}
else
{
success = set_out_arg (gexten->js_context, func_info,
is_return_value, &arg_cache[i].arg_info,
&arg_cache[i].type_info, arg_cache[i].ptr,
js_value);
}
}
}
return success;
}
void
_pygi_closure_handle (ffi_cif *cif,
void *result,
void **args,
void *data)
{
PyGILState_STATE state;
PyGICClosure *closure = data;
gint n_args, i;
GIArgInfo *arg_info;
GIDirection arg_direction;
GITypeInfo *arg_type;
GITransfer arg_transfer;
GITypeTag arg_tag;
GITypeTag return_tag;
GITransfer return_transfer;
GITypeInfo *return_type;
PyObject *retval;
PyObject *py_args;
PyObject *pyarg;
gint n_in_args, n_out_args;
/* Lock the GIL as we are coming into this code without the lock and we
may be executing python code */
state = PyGILState_Ensure();
return_type = g_callable_info_get_return_type(closure->info);
return_tag = g_type_info_get_tag(return_type);
return_transfer = g_callable_info_get_caller_owns(closure->info);
n_args = g_callable_info_get_n_args (closure->info);
py_args = PyTuple_New(n_args);
if (py_args == NULL) {
PyErr_Clear();
goto end;
}
n_in_args = 0;
for (i = 0; i < n_args; i++) {
arg_info = g_callable_info_get_arg (closure->info, i);
arg_type = g_arg_info_get_type (arg_info);
arg_transfer = g_arg_info_get_ownership_transfer(arg_info);
arg_tag = g_type_info_get_tag(arg_type);
arg_direction = g_arg_info_get_direction(arg_info);
switch (arg_tag) {
case GI_TYPE_TAG_VOID:
{
if (g_type_info_is_pointer(arg_type)) {
if (PyTuple_SetItem(py_args, n_in_args, closure->user_data) != 0) {
PyErr_Clear();
goto end;
}
n_in_args++;
continue;
}
}
case GI_TYPE_TAG_ERROR:
{
continue;
}
default:
{
pyarg = _pygi_argument_to_object (args[i],
arg_type,
arg_transfer);
if(PyTuple_SetItem(py_args, n_in_args, pyarg) != 0) {
PyErr_Clear();
goto end;
}
n_in_args++;
g_base_info_unref((GIBaseInfo*)arg_info);
g_base_info_unref((GIBaseInfo*)arg_type);
}
}
}
if(_PyTuple_Resize (&py_args, n_in_args) != 0) {
PyErr_Clear();
goto end;
}
retval = PyObject_CallObject((PyObject *)closure->function, py_args);
Py_DECREF(py_args);
if (retval == NULL) {
goto end;
}
*(GArgument*)result = _pygi_argument_from_object(retval, return_type, return_transfer);
end:
g_base_info_unref((GIBaseInfo*)return_type);
PyGILState_Release(state);
if (closure->user_data)
Py_XDECREF(closure->user_data);
/* Now that the closure has finished we can make a decision about how
to free it. Scope call gets free'd now, scope notified will be freed
when the notify is called and we can free async anytime we want
once we return from this function */
switch (closure->scope) {
case GI_SCOPE_TYPE_CALL:
_pygi_invoke_closure_free(closure);
break;
case GI_SCOPE_TYPE_NOTIFIED:
break;
case GI_SCOPE_TYPE_ASYNC:
/* Append this PyGICClosure to a list of closure that we will free
after we're done with this function invokation */
async_free_list = g_slist_prepend(async_free_list, closure);
break;
default:
g_assert_not_reached();
}
}
static void
out_arguments_to_raw_data(GICallableInfo *callable_info,
VALUE rb_results,
void *result,
GArray *out_args,
GPtrArray *args_metadata)
{
int i_rb_result = 0;
guint i;
GITypeInfo *return_type_info;
GITypeTag return_type_tag;
return_type_info = g_callable_info_get_return_type(callable_info);
return_type_tag = g_type_info_get_tag(return_type_info);
if (return_type_tag != GI_TYPE_TAG_VOID) {
GITransfer transfer;
transfer = g_callable_info_get_caller_owns(callable_info);
if (out_args->len == 0) {
VALUE rb_return_value = rb_results;
out_argument_to_raw_data(callable_info,
rb_return_value,
result,
return_type_info,
transfer,
TRUE);
} else {
out_argument_to_raw_data(callable_info,
RARRAY_AREF(rb_results, i_rb_result),
result,
return_type_info,
transfer,
TRUE);
i_rb_result++;
}
}
g_base_info_unref(return_type_info);
for (i = 0; i < args_metadata->len; i++) {
RBGIArgMetadata *metadata;
GIArgument *argument;
GITypeInfo *type_info;
GITransfer transfer;
metadata = g_ptr_array_index(args_metadata, i);
/* TODO: support GI_DIRECTION_INOUT */
if (metadata->direction != GI_DIRECTION_OUT) {
continue;
}
argument = &g_array_index(out_args, GIArgument, metadata->out_arg_index);
type_info = g_arg_info_get_type(&(metadata->arg_info));
transfer = g_arg_info_get_ownership_transfer(&(metadata->arg_info));
out_argument_to_raw_data(callable_info,
RARRAY_AREF(rb_results, i_rb_result),
argument->v_pointer,
type_info,
transfer,
FALSE);
i_rb_result++;
g_base_info_unref(type_info);
}
}
static void
invoke_callback (ffi_cif* cif, gpointer resp, gpointer* args, gpointer userdata)
{
GPerlI11nPerlCallbackInfo *info;
GICallableInfo *cb_interface;
GPerlI11nInvocationInfo iinfo = {0,};
guint i;
guint in_inout;
guint n_return_values, n_returned;
I32 context;
dGPERL_CALLBACK_MARSHAL_SP;
PERL_UNUSED_VAR (cif);
/* unwrap callback info struct from userdata */
info = (GPerlI11nPerlCallbackInfo *) userdata;
cb_interface = (GICallableInfo *) info->interface;
prepare_perl_invocation_info (&iinfo, cb_interface);
/* set perl context */
GPERL_CALLBACK_MARSHAL_INIT (info);
ENTER;
SAVETMPS;
PUSHMARK (SP);
/* find arguments; use type information from interface to find in and
* in-out args and their types, count in-out and out args, and find
* suitable converters; push in and in-out arguments onto the perl
* stack */
in_inout = 0;
for (i = 0; i < iinfo.n_args; i++) {
GIArgInfo *arg_info = g_callable_info_get_arg (cb_interface, i);
GITypeInfo *arg_type = g_arg_info_get_type (arg_info);
GITransfer transfer = g_arg_info_get_ownership_transfer (arg_info);
GIDirection direction = g_arg_info_get_direction (arg_info);
iinfo.current_pos = i;
/* the closure argument, which we handle separately, is marked
* by having get_closure == i */
if (g_arg_info_get_closure (arg_info) == (gint) i) {
g_base_info_unref ((GIBaseInfo *) arg_info);
g_base_info_unref ((GIBaseInfo *) arg_type);
continue;
}
dwarn ("arg info: %s (%p)\n"
" direction: %d\n"
" is return value: %d\n"
" is optional: %d\n"
" may be null: %d\n"
" transfer: %d\n",
g_base_info_get_name (arg_info), arg_info,
g_arg_info_get_direction (arg_info),
g_arg_info_is_return_value (arg_info),
g_arg_info_is_optional (arg_info),
g_arg_info_may_be_null (arg_info),
g_arg_info_get_ownership_transfer (arg_info));
dwarn ("arg type: %p\n"
" is pointer: %d\n"
" tag: %s (%d)\n",
arg_type,
g_type_info_is_pointer (arg_type),
g_type_tag_to_string (g_type_info_get_tag (arg_type)), g_type_info_get_tag (arg_type));
if (direction == GI_DIRECTION_IN ||
direction == GI_DIRECTION_INOUT)
{
GIArgument arg;
SV *sv;
raw_to_arg (args[i], &arg, arg_type);
sv = arg_to_sv (&arg, arg_type, transfer, &iinfo);
/* If arg_to_sv returns NULL, we take that as 'skip
* this argument'; happens for GDestroyNotify, for
* example. */
if (sv)
XPUSHs (sv_2mortal (sv));
}
if (direction == GI_DIRECTION_INOUT ||
direction == GI_DIRECTION_OUT)
{
in_inout++;
}
g_base_info_unref ((GIBaseInfo *) arg_info);
g_base_info_unref ((GIBaseInfo *) arg_type);
}
/* push user data onto the Perl stack */
if (info->data)
XPUSHs (sv_2mortal (SvREFCNT_inc (info->data)));
PUTBACK;
/* determine suitable Perl call context */
context = G_VOID | G_DISCARD;
if (iinfo.has_return_value) {
context = in_inout > 0
? G_ARRAY
: G_SCALAR;
} else {
if (in_inout == 1) {
context = G_SCALAR;
} else if (in_inout > 1) {
context = G_ARRAY;
}
}
/* do the call, demand #in-out+#out+#return-value return values */
n_return_values = iinfo.has_return_value
? in_inout + 1
: in_inout;
n_returned = info->sub_name
? call_method (info->sub_name, context)
: call_sv (info->code, context);
if (n_return_values != 0 && n_returned != n_return_values) {
ccroak ("callback returned %d values "
"but is supposed to return %d values",
n_returned, n_return_values);
}
/* call-scoped callback infos are freed by
* Glib::Object::Introspection::_FuncWrapper::DESTROY */
SPAGAIN;
/* convert in-out and out values and stuff them back into args */
if (in_inout > 0) {
SV **returned_values;
int out_index;
returned_values = g_new0 (SV *, in_inout);
/* pop scalars off the stack and put them into the array;
* reverse the order since POPs pops items off of the end of
* the stack. */
for (i = 0; i < in_inout; i++) {
returned_values[in_inout - i - 1] = POPs;
}
out_index = 0;
for (i = 0; i < iinfo.n_args; i++) {
GIArgInfo *arg_info = g_callable_info_get_arg (cb_interface, i);
GITypeInfo *arg_type = g_arg_info_get_type (arg_info);
GIDirection direction = g_arg_info_get_direction (arg_info);
gpointer out_pointer = * (gpointer *) args[i];
if (!out_pointer) {
dwarn ("skipping out arg %d\n", i);
g_base_info_unref (arg_info);
g_base_info_unref (arg_type);
continue;
}
if (direction == GI_DIRECTION_INOUT ||
direction == GI_DIRECTION_OUT)
{
GIArgument tmp_arg;
GITransfer transfer = g_arg_info_get_ownership_transfer (arg_info);
gboolean may_be_null = g_arg_info_may_be_null (arg_info);
gboolean is_caller_allocated = g_arg_info_is_caller_allocates (arg_info);
if (is_caller_allocated) {
tmp_arg.v_pointer = out_pointer;
}
sv_to_arg (returned_values[out_index], &tmp_arg,
arg_info, arg_type,
transfer, may_be_null, &iinfo);
if (!is_caller_allocated) {
arg_to_raw (&tmp_arg, out_pointer, arg_type);
}
out_index++;
}
g_base_info_unref (arg_info);
g_base_info_unref (arg_type);
}
g_free (returned_values);
}
