static void
struct_dealloc (PyGIStruct *self)
{
GIBaseInfo *info;
PyObject *error_type, *error_value, *error_traceback;
gboolean have_error = !!PyErr_Occurred ();
if (have_error)
PyErr_Fetch (&error_type, &error_value, &error_traceback);
info = struct_get_info (Py_TYPE (self));
if (info != NULL && g_struct_info_is_foreign ( (GIStructInfo *) info)) {
pygi_struct_foreign_release (info, pyg_pointer_get_ptr (self));
} else if (self->free_on_dealloc) {
g_free (pyg_pointer_get_ptr (self));
}
if (info != NULL) {
g_base_info_unref (info);
}
if (have_error)
PyErr_Restore (error_type, error_value, error_traceback);
Py_TYPE (self)->tp_free ((PyObject *)self);
}
static void
_struct_dealloc (PyGIStruct *self)
{
GIBaseInfo *info = _pygi_object_get_gi_info (
(PyObject *) self,
&PyGIStructInfo_Type);
if (info != NULL && g_struct_info_is_foreign ( (GIStructInfo *) info)) {
pygi_struct_foreign_release (info, ( (PyGPointer *) self)->pointer);
} else if (self->free_on_dealloc) {
g_free ( ( (PyGPointer *) self)->pointer);
}
g_base_info_unref (info);
Py_TYPE( (PyGPointer *) self )->tp_free ( (PyObject *) self);
}
static void
pygi_signal_closure_marshal(GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data)
{
PyGILState_STATE state;
PyGClosure *pc = (PyGClosure *)closure;
PyObject *params, *ret = NULL;
guint i;
GISignalInfo *signal_info;
gint n_sig_info_args;
gint sig_info_highest_arg;
GSList *list_item = NULL;
GSList *pass_by_ref_structs = NULL;
state = PyGILState_Ensure();
signal_info = ((PyGISignalClosure *)closure)->signal_info;
n_sig_info_args = g_callable_info_get_n_args(signal_info);
/* the first argument to a signal callback is instance,
but instance is not counted in the introspection data */
sig_info_highest_arg = n_sig_info_args + 1;
g_assert_cmpint(sig_info_highest_arg, ==, n_param_values);
/* construct Python tuple for the parameter values */
params = PyTuple_New(n_param_values);
for (i = 0; i < n_param_values; i++) {
/* swap in a different initial data for connect_object() */
if (i == 0 && G_CCLOSURE_SWAP_DATA(closure)) {
g_return_if_fail(pc->swap_data != NULL);
Py_INCREF(pc->swap_data);
PyTuple_SetItem(params, 0, pc->swap_data);
} else if (i == 0) {
PyObject *item = pyg_value_as_pyobject(¶m_values[i], FALSE);
if (!item) {
goto out;
}
PyTuple_SetItem(params, i, item);
} else if (i < sig_info_highest_arg) {
GIArgInfo arg_info;
GITypeInfo type_info;
GITypeTag type_tag;
GIArgument arg = { 0, };
PyObject *item = NULL;
gboolean free_array = FALSE;
gboolean pass_struct_by_ref = FALSE;
g_callable_info_load_arg(signal_info, i - 1, &arg_info);
g_arg_info_load_type(&arg_info, &type_info);
arg = _pygi_argument_from_g_value(¶m_values[i], &type_info);
type_tag = g_type_info_get_tag (&type_info);
if (type_tag == GI_TYPE_TAG_ARRAY) {
/* Skip the self argument of param_values */
arg.v_pointer = _pygi_argument_to_array (&arg,
_pygi_argument_array_length_marshal,
(void *)(param_values + 1),
signal_info,
&type_info,
&free_array);
}
/* Hack to ensure struct arguments are passed-by-reference allowing
* callback implementors to modify the struct values. This is needed
* for keeping backwards compatibility and should be removed in future
* versions which support signal output arguments as return values.
* See: https://bugzilla.gnome.org/show_bug.cgi?id=735486
*
* Note the logic here must match the logic path taken in _pygi_argument_to_object.
*/
if (type_tag == GI_TYPE_TAG_INTERFACE) {
GIBaseInfo *info = g_type_info_get_interface (&type_info);
GIInfoType info_type = g_base_info_get_type (info);
if (info_type == GI_INFO_TYPE_STRUCT ||
info_type == GI_INFO_TYPE_BOXED ||
info_type == GI_INFO_TYPE_UNION) {
GType gtype = g_registered_type_info_get_g_type ((GIRegisteredTypeInfo *) info);
gboolean is_foreign = (info_type == GI_INFO_TYPE_STRUCT) &&
(g_struct_info_is_foreign ((GIStructInfo *) info));
if (!is_foreign && !g_type_is_a (gtype, G_TYPE_VALUE) &&
g_type_is_a (gtype, G_TYPE_BOXED)) {
pass_struct_by_ref = TRUE;
}
}
g_base_info_unref (info);
}
if (pass_struct_by_ref) {
/* transfer everything will ensure the struct is not copied when wrapped. */
item = _pygi_argument_to_object (&arg, &type_info, GI_TRANSFER_EVERYTHING);
if (item && PyObject_IsInstance (item, (PyObject *) &PyGIBoxed_Type)) {
((PyGBoxed *)item)->free_on_dealloc = FALSE;
pass_by_ref_structs = g_slist_prepend (pass_by_ref_structs, item);
}
} else {
item = _pygi_argument_to_object (&arg, &type_info, GI_TRANSFER_NOTHING);
}
if (free_array) {
g_array_free (arg.v_pointer, FALSE);
}
if (item == NULL) {
PyErr_Print ();
goto out;
}
PyTuple_SetItem(params, i, item);
}
}
/* params passed to function may have extra arguments */
if (pc->extra_args) {
PyObject *tuple = params;
params = PySequence_Concat(tuple, pc->extra_args);
Py_DECREF(tuple);
}
ret = PyObject_CallObject(pc->callback, params);
if (ret == NULL) {
if (pc->exception_handler)
pc->exception_handler(return_value, n_param_values, param_values);
else
PyErr_Print();
goto out;
}
if (G_IS_VALUE(return_value) && pyg_value_from_pyobject(return_value, ret) != 0) {
PyErr_SetString(PyExc_TypeError,
"can't convert return value to desired type");
if (pc->exception_handler)
pc->exception_handler(return_value, n_param_values, param_values);
else
PyErr_Print();
}
Py_DECREF(ret);
/* Run through the list of structs which have been passed by reference and
* check if they are being held longer than the duration of the callback
* execution. This is determined if the ref count is greater than 1.
* A single ref is held by the argument list and any more would mean the callback
* stored a ref somewhere else. In this case we make an internal copy of
* the boxed struct so Python can own the memory to it.
*/
list_item = pass_by_ref_structs;
while (list_item) {
PyObject *item = list_item->data;
if (item->ob_refcnt > 1) {
_pygi_boxed_copy_in_place ((PyGIBoxed *)item);
}
list_item = g_slist_next (list_item);
}
out:
g_slist_free (pass_by_ref_structs);
Py_DECREF(params);
PyGILState_Release(state);
}
static JSBool
gjs_value_from_g_value_internal(JSContext *context,
jsval *value_p,
const GValue *gvalue,
gboolean no_copy,
GSignalQuery *signal_query,
gint arg_n)
{
GType gtype;
gtype = G_VALUE_TYPE(gvalue);
gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
"Converting gtype %s to jsval",
g_type_name(gtype));
if (gtype == G_TYPE_STRING) {
const char *v;
v = g_value_get_string(gvalue);
if (v == NULL) {
gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
"Converting NULL string to JSVAL_NULL");
*value_p = JSVAL_NULL;
} else {
if (!gjs_string_from_utf8(context, v, -1, value_p))
return JS_FALSE;
}
} else if (gtype == G_TYPE_CHAR) {
char v;
v = g_value_get_schar(gvalue);
*value_p = INT_TO_JSVAL(v);
} else if (gtype == G_TYPE_UCHAR) {
unsigned char v;
v = g_value_get_uchar(gvalue);
*value_p = INT_TO_JSVAL(v);
} else if (gtype == G_TYPE_INT) {
int v;
v = g_value_get_int(gvalue);
return JS_NewNumberValue(context, v, value_p);
} else if (gtype == G_TYPE_UINT) {
uint v;
v = g_value_get_uint(gvalue);
return JS_NewNumberValue(context, v, value_p);
} else if (gtype == G_TYPE_DOUBLE) {
double d;
d = g_value_get_double(gvalue);
return JS_NewNumberValue(context, d, value_p);
} else if (gtype == G_TYPE_FLOAT) {
double d;
d = g_value_get_float(gvalue);
return JS_NewNumberValue(context, d, value_p);
} else if (gtype == G_TYPE_BOOLEAN) {
gboolean v;
v = g_value_get_boolean(gvalue);
*value_p = BOOLEAN_TO_JSVAL(v);
} else if (g_type_is_a(gtype, G_TYPE_OBJECT) || g_type_is_a(gtype, G_TYPE_INTERFACE)) {
GObject *gobj;
JSObject *obj;
gobj = g_value_get_object(gvalue);
obj = gjs_object_from_g_object(context, gobj);
*value_p = OBJECT_TO_JSVAL(obj);
} else if (gtype == G_TYPE_STRV) {
if (!gjs_array_from_strv (context,
value_p,
g_value_get_boxed (gvalue))) {
gjs_throw(context, "Failed to convert strv to array");
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_HASH_TABLE) ||
g_type_is_a(gtype, G_TYPE_ARRAY) ||
g_type_is_a(gtype, G_TYPE_BYTE_ARRAY) ||
g_type_is_a(gtype, G_TYPE_PTR_ARRAY)) {
gjs_throw(context,
"Unable to introspect element-type of container in GValue");
return JS_FALSE;
} else if (g_type_is_a(gtype, G_TYPE_BOXED) ||
g_type_is_a(gtype, G_TYPE_VARIANT)) {
GjsBoxedCreationFlags boxed_flags;
GIBaseInfo *info;
void *gboxed;
JSObject *obj;
if (g_type_is_a(gtype, G_TYPE_BOXED))
gboxed = g_value_get_boxed(gvalue);
else
gboxed = g_value_get_variant(gvalue);
boxed_flags = GJS_BOXED_CREATION_NONE;
/* special case GError */
if (g_type_is_a(gtype, G_TYPE_ERROR)) {
obj = gjs_error_from_gerror(context, gboxed, FALSE);
*value_p = OBJECT_TO_JSVAL(obj);
return TRUE;
}
/* The only way to differentiate unions and structs is from
* their g-i info as both GBoxed */
info = g_irepository_find_by_gtype(g_irepository_get_default(),
gtype);
if (info == NULL) {
gjs_throw(context,
"No introspection information found for %s",
g_type_name(gtype));
return JS_FALSE;
}
if (g_base_info_get_type(info) == GI_INFO_TYPE_STRUCT &&
g_struct_info_is_foreign((GIStructInfo*)info)) {
JSBool ret;
GIArgument arg;
arg.v_pointer = gboxed;
ret = gjs_struct_foreign_convert_from_g_argument(context, value_p, info, &arg);
g_base_info_unref(info);
return ret;
}
switch (g_base_info_get_type(info)) {
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
if (no_copy)
boxed_flags |= GJS_BOXED_CREATION_NO_COPY;
obj = gjs_boxed_from_c_struct(context, (GIStructInfo *)info, gboxed, boxed_flags);
break;
case GI_INFO_TYPE_UNION:
obj = gjs_union_from_c_union(context, (GIUnionInfo *)info, gboxed);
break;
default:
gjs_throw(context,
"Unexpected introspection type %d for %s",
g_base_info_get_type(info),
g_type_name(gtype));
g_base_info_unref(info);
return JS_FALSE;
}
*value_p = OBJECT_TO_JSVAL(obj);
g_base_info_unref(info);
} else if (g_type_is_a(gtype, G_TYPE_ENUM)) {
return convert_int_to_enum(context, value_p, gtype, g_value_get_enum(gvalue));
} else if (g_type_is_a(gtype, G_TYPE_PARAM)) {
GParamSpec *gparam;
JSObject *obj;
gparam = g_value_get_param(gvalue);
obj = gjs_param_from_g_param(context, gparam);
*value_p = OBJECT_TO_JSVAL(obj);
} else if (signal_query && g_type_is_a(gtype, G_TYPE_POINTER)) {
JSBool res;
GArgument arg;
GIArgInfo *arg_info;
GIBaseInfo *obj;
GISignalInfo *signal_info;
GITypeInfo type_info;
obj = g_irepository_find_by_gtype(NULL, signal_query->itype);
if (!obj) {
gjs_throw(context, "Signal argument with GType %s isn't introspectable",
g_type_name(signal_query->itype));
return JS_FALSE;
}
signal_info = g_object_info_find_signal((GIObjectInfo*)obj, signal_query->signal_name);
if (!signal_info) {
gjs_throw(context, "Unknown signal.");
g_base_info_unref((GIBaseInfo*)obj);
return JS_FALSE;
}
arg_info = g_callable_info_get_arg(signal_info, arg_n - 1);
g_arg_info_load_type(arg_info, &type_info);
arg.v_pointer = g_value_get_pointer(gvalue);
res = gjs_value_from_g_argument(context, value_p, &type_info, &arg, TRUE);
g_base_info_unref((GIBaseInfo*)arg_info);
g_base_info_unref((GIBaseInfo*)signal_info);
g_base_info_unref((GIBaseInfo*)obj);
return res;
} else if (g_type_is_a(gtype, G_TYPE_POINTER)) {
gpointer pointer;
pointer = g_value_get_pointer(gvalue);
if (pointer == NULL) {
*value_p = JSVAL_NULL;
} else {
gjs_throw(context,
"Can't convert non-null pointer to JS value");
return JS_FALSE;
}
} else if (g_value_type_transformable(gtype, G_TYPE_DOUBLE)) {
GValue double_value = { 0, };
double v;
g_value_init(&double_value, G_TYPE_DOUBLE);
g_value_transform(gvalue, &double_value);
v = g_value_get_double(&double_value);
return JS_NewNumberValue(context, v, value_p);
} else if (g_value_type_transformable(gtype, G_TYPE_INT)) {
GValue int_value = { 0, };
int v;
g_value_init(&int_value, G_TYPE_INT);
g_value_transform(gvalue, &int_value);
v = g_value_get_int(&int_value);
return JS_NewNumberValue(context, v, value_p);
} else {
gjs_throw(context,
"Don't know how to convert GType %s to JavaScript object",
g_type_name(gtype));
return JS_FALSE;
}
return JS_TRUE;
}
void
_pygi_argument_release (GIArgument *arg,
GITypeInfo *type_info,
GITransfer transfer,
GIDirection direction)
{
GITypeTag type_tag;
gboolean is_out = (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT);
type_tag = g_type_info_get_tag (type_info);
switch (type_tag) {
case GI_TYPE_TAG_VOID:
/* Don't do anything, it's transparent to the C side */
break;
case GI_TYPE_TAG_BOOLEAN:
case GI_TYPE_TAG_INT8:
case GI_TYPE_TAG_UINT8:
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_INT32:
case GI_TYPE_TAG_UINT32:
case GI_TYPE_TAG_INT64:
case GI_TYPE_TAG_UINT64:
case GI_TYPE_TAG_FLOAT:
case GI_TYPE_TAG_DOUBLE:
case GI_TYPE_TAG_GTYPE:
case GI_TYPE_TAG_UNICHAR:
break;
case GI_TYPE_TAG_FILENAME:
case GI_TYPE_TAG_UTF8:
/* With allow-none support the string could be NULL */
if ((arg->v_string != NULL &&
(direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING))
|| (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
g_free (arg->v_string);
}
break;
case GI_TYPE_TAG_ARRAY:
{
GArray *array;
gsize i;
if (arg->v_pointer == NULL) {
return;
}
array = arg->v_pointer;
if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
|| (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
GITypeInfo *item_type_info;
GITransfer item_transfer;
item_type_info = g_type_info_get_param_type (type_info, 0);
item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
/* Free the items */
for (i = 0; i < array->len; i++) {
GIArgument *item;
item = &_g_array_index (array, GIArgument, i);
_pygi_argument_release (item, item_type_info, item_transfer, direction);
}
g_base_info_unref ( (GIBaseInfo *) item_type_info);
}
if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
|| (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
g_array_free (array, TRUE);
}
break;
}
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *info;
GIInfoType info_type;
info = g_type_info_get_interface (type_info);
info_type = g_base_info_get_type (info);
switch (info_type) {
case GI_INFO_TYPE_CALLBACK:
/* TODO */
break;
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
case GI_INFO_TYPE_UNION:
{
GType type;
if (arg->v_pointer == NULL) {
return;
}
type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
if (g_type_is_a (type, G_TYPE_VALUE)) {
GValue *value;
value = arg->v_pointer;
if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
|| (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
g_value_unset (value);
}
if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
|| (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
g_slice_free (GValue, value);
}
} else if (g_type_is_a (type, G_TYPE_CLOSURE)) {
if (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING) {
g_closure_unref (arg->v_pointer);
}
} else if (info_type == GI_INFO_TYPE_STRUCT &&
g_struct_info_is_foreign ((GIStructInfo*) info)) {
if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING) {
pygi_struct_foreign_release (info, arg->v_pointer);
}
} else if (g_type_is_a (type, G_TYPE_BOXED)) {
} else if (g_type_is_a (type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
g_warn_if_fail (!g_type_info_is_pointer (type_info) || transfer == GI_TRANSFER_NOTHING);
}
break;
}
case GI_INFO_TYPE_ENUM:
case GI_INFO_TYPE_FLAGS:
break;
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_OBJECT:
if (arg->v_pointer == NULL) {
return;
}
if (is_out && transfer == GI_TRANSFER_EVERYTHING) {
g_object_unref (arg->v_pointer);
}
break;
default:
g_assert_not_reached();
}
g_base_info_unref (info);
break;
}
case GI_TYPE_TAG_GLIST:
case GI_TYPE_TAG_GSLIST:
{
GSList *list;
if (arg->v_pointer == NULL) {
return;
}
list = arg->v_pointer;
if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
|| (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
GITypeInfo *item_type_info;
GITransfer item_transfer;
GSList *item;
item_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (item_type_info != NULL);
item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
/* Free the items */
for (item = list; item != NULL; item = g_slist_next (item)) {
_pygi_argument_release ( (GIArgument *) &item->data, item_type_info,
item_transfer, direction);
}
g_base_info_unref ( (GIBaseInfo *) item_type_info);
}
if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
|| (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
if (type_tag == GI_TYPE_TAG_GLIST) {
g_list_free ( (GList *) list);
} else {
/* type_tag == GI_TYPE_TAG_GSLIST */
g_slist_free (list);
}
}
break;
}
case GI_TYPE_TAG_GHASH:
{
GHashTable *hash_table;
if (arg->v_pointer == NULL) {
return;
}
hash_table = arg->v_pointer;
if (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING) {
/* We created the table without a destroy function, so keys and
* values need to be released. */
GITypeInfo *key_type_info;
GITypeInfo *value_type_info;
GITransfer item_transfer;
GHashTableIter hash_table_iter;
gpointer key;
gpointer value;
key_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (key_type_info != NULL);
value_type_info = g_type_info_get_param_type (type_info, 1);
g_assert (value_type_info != NULL);
if (direction == GI_DIRECTION_IN) {
item_transfer = GI_TRANSFER_NOTHING;
} else {
item_transfer = GI_TRANSFER_EVERYTHING;
}
g_hash_table_iter_init (&hash_table_iter, hash_table);
while (g_hash_table_iter_next (&hash_table_iter, &key, &value)) {
_pygi_argument_release ( (GIArgument *) &key, key_type_info,
item_transfer, direction);
_pygi_argument_release ( (GIArgument *) &value, value_type_info,
item_transfer, direction);
}
g_base_info_unref ( (GIBaseInfo *) key_type_info);
g_base_info_unref ( (GIBaseInfo *) value_type_info);
} else if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_CONTAINER) {
/* Be careful to avoid keys and values being freed if the
* callee gave a destroy function. */
g_hash_table_steal_all (hash_table);
}
if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
|| (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
g_hash_table_unref (hash_table);
}
break;
}
case GI_TYPE_TAG_ERROR:
{
GError *error;
if (arg->v_pointer == NULL) {
return;
}
error = * (GError **) arg->v_pointer;
if (error != NULL) {
g_error_free (error);
}
g_slice_free (GError *, arg->v_pointer);
break;
}
}
}
/**
* _pygi_argument_to_object:
* @arg: The argument to convert to an object.
* @type_info: Type info for @arg
* @transfer:
*
* If the argument is of type array, it must be encoded in a GArray, by calling
* _pygi_argument_to_array(). This logic can not be folded into this method
* as determining array lengths may require access to method call arguments.
*
* Returns: A PyObject representing @arg
*/
PyObject *
_pygi_argument_to_object (GIArgument *arg,
GITypeInfo *type_info,
GITransfer transfer)
{
GITypeTag type_tag;
PyObject *object = NULL;
type_tag = g_type_info_get_tag (type_info);
object = _pygi_marshal_to_py_basic_type (arg, type_tag, transfer);
if (object)
return object;
switch (type_tag) {
case GI_TYPE_TAG_VOID:
{
if (g_type_info_is_pointer (type_info)) {
g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
object = PyLong_FromVoidPtr (arg->v_pointer);
}
break;
}
case GI_TYPE_TAG_ARRAY:
{
/* Arrays are assumed to be packed in a GArray */
GArray *array;
GITypeInfo *item_type_info;
GITypeTag item_type_tag;
GITransfer item_transfer;
gsize i, item_size;
if (arg->v_pointer == NULL)
return PyList_New (0);
item_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (item_type_info != NULL);
item_type_tag = g_type_info_get_tag (item_type_info);
item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
array = arg->v_pointer;
item_size = g_array_get_element_size (array);
if (G_UNLIKELY (item_size > sizeof(GIArgument))) {
g_critical ("Stack overflow protection. "
"Can't copy array element into GIArgument.");
return PyList_New (0);
}
if (item_type_tag == GI_TYPE_TAG_UINT8) {
/* Return as a byte array */
object = PYGLIB_PyBytes_FromStringAndSize (array->data, array->len);
} else {
object = PyList_New (array->len);
if (object == NULL) {
g_critical ("Failure to allocate array for %u items", array->len);
g_base_info_unref ( (GIBaseInfo *) item_type_info);
break;
}
for (i = 0; i < array->len; i++) {
GIArgument item = { 0 };
PyObject *py_item;
memcpy (&item, array->data + i * item_size, item_size);
py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
if (py_item == NULL) {
Py_CLEAR (object);
_PyGI_ERROR_PREFIX ("Item %zu: ", i);
break;
}
PyList_SET_ITEM (object, i, py_item);
}
}
g_base_info_unref ( (GIBaseInfo *) item_type_info);
break;
}
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *info;
GIInfoType info_type;
info = g_type_info_get_interface (type_info);
info_type = g_base_info_get_type (info);
switch (info_type) {
case GI_INFO_TYPE_CALLBACK:
{
g_assert_not_reached();
}
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
case GI_INFO_TYPE_UNION:
{
PyObject *py_type;
GType g_type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
gboolean is_foreign = (info_type == GI_INFO_TYPE_STRUCT) &&
(g_struct_info_is_foreign ((GIStructInfo *) info));
/* Special case variant and none to force loading from py module. */
if (g_type == G_TYPE_VARIANT || g_type == G_TYPE_NONE) {
py_type = _pygi_type_import_by_gi_info (info);
} else {
py_type = _pygi_type_get_from_g_type (g_type);
}
object = pygi_arg_struct_to_py_marshal (arg,
info, /*interface_info*/
g_type,
py_type,
transfer,
FALSE, /*is_allocated*/
is_foreign);
Py_XDECREF (py_type);
break;
}
case GI_INFO_TYPE_ENUM:
case GI_INFO_TYPE_FLAGS:
{
GType type;
type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
if (type == G_TYPE_NONE) {
/* An enum with a GType of None is an enum without GType */
PyObject *py_type = _pygi_type_import_by_gi_info (info);
PyObject *py_args = NULL;
if (!py_type)
return NULL;
py_args = PyTuple_New (1);
if (PyTuple_SetItem (py_args, 0, PyLong_FromLong (arg->v_int)) != 0) {
Py_DECREF (py_args);
Py_DECREF (py_type);
return NULL;
}
object = PyObject_CallFunction (py_type, "i", arg->v_int);
Py_DECREF (py_args);
Py_DECREF (py_type);
} else if (info_type == GI_INFO_TYPE_ENUM) {
object = pyg_enum_from_gtype (type, arg->v_int);
} else {
object = pyg_flags_from_gtype (type, arg->v_uint);
}
break;
}
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_OBJECT:
object = pygi_arg_gobject_to_py_called_from_c (arg, transfer);
break;
default:
g_assert_not_reached();
}
g_base_info_unref (info);
break;
}
case GI_TYPE_TAG_GLIST:
case GI_TYPE_TAG_GSLIST:
{
GSList *list;
gsize length;
GITypeInfo *item_type_info;
GITransfer item_transfer;
gsize i;
list = arg->v_pointer;
length = g_slist_length (list);
object = PyList_New (length);
if (object == NULL) {
break;
}
item_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (item_type_info != NULL);
item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
for (i = 0; list != NULL; list = g_slist_next (list), i++) {
GIArgument item;
PyObject *py_item;
item.v_pointer = list->data;
py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
if (py_item == NULL) {
Py_CLEAR (object);
_PyGI_ERROR_PREFIX ("Item %zu: ", i);
break;
}
PyList_SET_ITEM (object, i, py_item);
}
g_base_info_unref ( (GIBaseInfo *) item_type_info);
break;
}
case GI_TYPE_TAG_GHASH:
{
GITypeInfo *key_type_info;
GITypeInfo *value_type_info;
GITransfer item_transfer;
GHashTableIter hash_table_iter;
GIArgument key;
GIArgument value;
if (arg->v_pointer == NULL) {
object = Py_None;
Py_INCREF (object);
break;
}
object = PyDict_New();
if (object == NULL) {
break;
}
key_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (key_type_info != NULL);
g_assert (g_type_info_get_tag (key_type_info) != GI_TYPE_TAG_VOID);
value_type_info = g_type_info_get_param_type (type_info, 1);
g_assert (value_type_info != NULL);
g_assert (g_type_info_get_tag (value_type_info) != GI_TYPE_TAG_VOID);
item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
g_hash_table_iter_init (&hash_table_iter, (GHashTable *) arg->v_pointer);
while (g_hash_table_iter_next (&hash_table_iter, &key.v_pointer, &value.v_pointer)) {
PyObject *py_key;
PyObject *py_value;
int retval;
py_key = _pygi_argument_to_object (&key, key_type_info, item_transfer);
if (py_key == NULL) {
break;
}
_pygi_hash_pointer_to_arg (&value, g_type_info_get_tag (value_type_info));
py_value = _pygi_argument_to_object (&value, value_type_info, item_transfer);
if (py_value == NULL) {
Py_DECREF (py_key);
break;
}
retval = PyDict_SetItem (object, py_key, py_value);
Py_DECREF (py_key);
Py_DECREF (py_value);
if (retval < 0) {
Py_CLEAR (object);
break;
}
}
g_base_info_unref ( (GIBaseInfo *) key_type_info);
g_base_info_unref ( (GIBaseInfo *) value_type_info);
break;
}
case GI_TYPE_TAG_ERROR:
{
GError *error = (GError *) arg->v_pointer;
if (error != NULL && transfer == GI_TRANSFER_NOTHING) {
/* If we have not been transferred the ownership we must copy
* the error, because pygi_error_check() is going to free it.
*/
error = g_error_copy (error);
}
if (pygi_error_check (&error)) {
PyObject *err_type;
PyObject *err_value;
PyObject *err_trace;
PyErr_Fetch (&err_type, &err_value, &err_trace);
Py_XDECREF (err_type);
Py_XDECREF (err_trace);
object = err_value;
} else {
object = Py_None;
Py_INCREF (object);
break;
}
break;
}
default:
{
g_assert_not_reached();
}
}
return object;
}
GIArgument
_pygi_argument_from_object (PyObject *object,
GITypeInfo *type_info,
GITransfer transfer)
{
GIArgument arg;
GITypeTag type_tag;
gpointer cleanup_data = NULL;
memset(&arg, 0, sizeof(GIArgument));
type_tag = g_type_info_get_tag (type_info);
/* Ignores cleanup data for now. */
if (_pygi_marshal_from_py_basic_type (object, &arg, type_tag, transfer, &cleanup_data) ||
PyErr_Occurred()) {
return arg;
}
switch (type_tag) {
case GI_TYPE_TAG_ARRAY:
{
Py_ssize_t length;
gboolean is_zero_terminated;
GITypeInfo *item_type_info;
gsize item_size;
GArray *array;
GITransfer item_transfer;
Py_ssize_t i;
if (object == Py_None) {
arg.v_pointer = NULL;
break;
}
/* Note, strings are sequences, but we cannot accept them here */
if (!PySequence_Check (object) ||
#if PY_VERSION_HEX < 0x03000000
PyString_Check (object) ||
#endif
PyUnicode_Check (object)) {
PyErr_SetString (PyExc_TypeError, "expected sequence");
break;
}
length = PySequence_Length (object);
if (length < 0) {
break;
}
is_zero_terminated = g_type_info_is_zero_terminated (type_info);
item_type_info = g_type_info_get_param_type (type_info, 0);
/* we handle arrays that are really strings specially, see below */
if (g_type_info_get_tag (item_type_info) == GI_TYPE_TAG_UINT8)
item_size = 1;
else
item_size = sizeof (GIArgument);
array = g_array_sized_new (is_zero_terminated, FALSE, item_size, length);
if (array == NULL) {
g_base_info_unref ( (GIBaseInfo *) item_type_info);
PyErr_NoMemory();
break;
}
if (g_type_info_get_tag (item_type_info) == GI_TYPE_TAG_UINT8 &&
PYGLIB_PyBytes_Check(object)) {
memcpy(array->data, PYGLIB_PyBytes_AsString(object), length);
array->len = length;
goto array_success;
}
item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
for (i = 0; i < length; i++) {
PyObject *py_item;
GIArgument item;
py_item = PySequence_GetItem (object, i);
if (py_item == NULL) {
goto array_item_error;
}
item = _pygi_argument_from_object (py_item, item_type_info, item_transfer);
Py_DECREF (py_item);
if (PyErr_Occurred()) {
goto array_item_error;
}
g_array_insert_val (array, i, item);
continue;
array_item_error:
/* Free everything we have converted so far. */
_pygi_argument_release ( (GIArgument *) &array, type_info,
GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
array = NULL;
_PyGI_ERROR_PREFIX ("Item %zd: ", i);
break;
}
array_success:
arg.v_pointer = array;
g_base_info_unref ( (GIBaseInfo *) item_type_info);
break;
}
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *info;
GIInfoType info_type;
info = g_type_info_get_interface (type_info);
info_type = g_base_info_get_type (info);
switch (info_type) {
case GI_INFO_TYPE_CALLBACK:
/* This should be handled in invoke() */
g_assert_not_reached();
break;
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
case GI_INFO_TYPE_UNION:
{
GType g_type;
PyObject *py_type;
gboolean is_foreign = (info_type == GI_INFO_TYPE_STRUCT) &&
(g_struct_info_is_foreign ((GIStructInfo *) info));
g_type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
py_type = _pygi_type_import_by_gi_info ( (GIBaseInfo *) info);
/* Note for G_TYPE_VALUE g_type:
* This will currently leak the GValue that is allocated and
* stashed in arg.v_pointer. Out argument marshaling for caller
* allocated GValues already pass in memory for the GValue.
* Further re-factoring is needed to fix this leak.
* See: https://bugzilla.gnome.org/show_bug.cgi?id=693405
*/
pygi_arg_struct_from_py_marshal (object,
&arg,
NULL, /*arg_name*/
info, /*interface_info*/
g_type,
py_type,
transfer,
FALSE, /*copy_reference*/
is_foreign,
g_type_info_is_pointer (type_info));
Py_DECREF (py_type);
break;
}
case GI_INFO_TYPE_ENUM:
case GI_INFO_TYPE_FLAGS:
{
PyObject *int_;
int_ = PYGLIB_PyNumber_Long (object);
if (int_ == NULL) {
break;
}
arg.v_int = PYGLIB_PyLong_AsLong (int_);
Py_DECREF (int_);
break;
}
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_OBJECT:
/* An error within this call will result in a NULL arg */
pygi_arg_gobject_out_arg_from_py (object, &arg, transfer);
break;
default:
g_assert_not_reached();
}
g_base_info_unref (info);
break;
}
case GI_TYPE_TAG_GLIST:
case GI_TYPE_TAG_GSLIST:
{
Py_ssize_t length;
GITypeInfo *item_type_info;
GSList *list = NULL;
GITransfer item_transfer;
Py_ssize_t i;
if (object == Py_None) {
arg.v_pointer = NULL;
break;
}
length = PySequence_Length (object);
if (length < 0) {
break;
}
item_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (item_type_info != NULL);
item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
for (i = length - 1; i >= 0; i--) {
PyObject *py_item;
GIArgument item;
py_item = PySequence_GetItem (object, i);
if (py_item == NULL) {
goto list_item_error;
}
item = _pygi_argument_from_object (py_item, item_type_info, item_transfer);
Py_DECREF (py_item);
if (PyErr_Occurred()) {
goto list_item_error;
}
if (type_tag == GI_TYPE_TAG_GLIST) {
list = (GSList *) g_list_prepend ( (GList *) list, item.v_pointer);
} else {
list = g_slist_prepend (list, item.v_pointer);
}
continue;
list_item_error:
/* Free everything we have converted so far. */
_pygi_argument_release ( (GIArgument *) &list, type_info,
GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
list = NULL;
_PyGI_ERROR_PREFIX ("Item %zd: ", i);
break;
}
arg.v_pointer = list;
g_base_info_unref ( (GIBaseInfo *) item_type_info);
break;
}
case GI_TYPE_TAG_GHASH:
{
Py_ssize_t length;
PyObject *keys;
PyObject *values;
GITypeInfo *key_type_info;
GITypeInfo *value_type_info;
GITypeTag key_type_tag;
GHashFunc hash_func;
GEqualFunc equal_func;
GHashTable *hash_table;
GITransfer item_transfer;
Py_ssize_t i;
if (object == Py_None) {
arg.v_pointer = NULL;
break;
}
length = PyMapping_Length (object);
if (length < 0) {
break;
}
keys = PyMapping_Keys (object);
if (keys == NULL) {
break;
}
values = PyMapping_Values (object);
if (values == NULL) {
Py_DECREF (keys);
break;
}
key_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (key_type_info != NULL);
value_type_info = g_type_info_get_param_type (type_info, 1);
g_assert (value_type_info != NULL);
key_type_tag = g_type_info_get_tag (key_type_info);
switch (key_type_tag) {
case GI_TYPE_TAG_UTF8:
case GI_TYPE_TAG_FILENAME:
hash_func = g_str_hash;
equal_func = g_str_equal;
break;
default:
hash_func = NULL;
equal_func = NULL;
}
hash_table = g_hash_table_new (hash_func, equal_func);
if (hash_table == NULL) {
PyErr_NoMemory();
goto hash_table_release;
}
item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
for (i = 0; i < length; i++) {
PyObject *py_key;
PyObject *py_value;
GIArgument key;
GIArgument value;
py_key = PyList_GET_ITEM (keys, i);
py_value = PyList_GET_ITEM (values, i);
key = _pygi_argument_from_object (py_key, key_type_info, item_transfer);
if (PyErr_Occurred()) {
goto hash_table_item_error;
}
value = _pygi_argument_from_object (py_value, value_type_info, item_transfer);
if (PyErr_Occurred()) {
_pygi_argument_release (&key, type_info, GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
goto hash_table_item_error;
}
g_hash_table_insert (hash_table, key.v_pointer,
_pygi_arg_to_hash_pointer (&value, g_type_info_get_tag (value_type_info)));
continue;
hash_table_item_error:
/* Free everything we have converted so far. */
_pygi_argument_release ( (GIArgument *) &hash_table, type_info,
GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
hash_table = NULL;
_PyGI_ERROR_PREFIX ("Item %zd: ", i);
break;
}
arg.v_pointer = hash_table;
hash_table_release:
g_base_info_unref ( (GIBaseInfo *) key_type_info);
g_base_info_unref ( (GIBaseInfo *) value_type_info);
Py_DECREF (keys);
Py_DECREF (values);
break;
}
case GI_TYPE_TAG_ERROR:
PyErr_SetString (PyExc_NotImplementedError, "error marshalling is not supported yet");
/* TODO */
break;
default:
g_assert_not_reached ();
}
return arg;
}
