static PyObject *
_wrap_g_irepository_get_typelib_path (PyGIRepository *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "namespace", NULL };
const char *namespace_;
const gchar *typelib_path;
if (!PyArg_ParseTupleAndKeywords (args, kwargs,
"s:Repository.get_typelib_path", kwlist, &namespace_)) {
return NULL;
}
typelib_path = g_irepository_get_typelib_path (self->repository, namespace_);
if (typelib_path == NULL) {
PyErr_Format (PyExc_RuntimeError, "Namespace '%s' not loaded", namespace_);
return NULL;
}
return PYGLIB_PyBytes_FromString (typelib_path);
}
PyObject *
_pygi_marshal_to_py_array (PyGIInvokeState *state,
PyGICallableCache *callable_cache,
PyGIArgCache *arg_cache,
GIArgument *arg)
{
GArray *array_;
PyObject *py_obj = NULL;
PyGISequenceCache *seq_cache = (PyGISequenceCache *)arg_cache;
gsize processed_items = 0;
/* GArrays make it easier to iterate over arrays
* with different element sizes but requires that
* we allocate a GArray if the argument was a C array
*/
if (seq_cache->array_type == GI_ARRAY_TYPE_C) {
gsize len;
if (seq_cache->fixed_size >= 0) {
g_assert(arg->v_pointer != NULL);
len = seq_cache->fixed_size;
} else if (seq_cache->is_zero_terminated) {
if (arg->v_pointer == NULL) {
len = 0;
} else if (seq_cache->item_cache->type_tag == GI_TYPE_TAG_UINT8) {
len = strlen (arg->v_pointer);
} else {
len = g_strv_length ((gchar **)arg->v_pointer);
}
} else {
GIArgument *len_arg = state->args[seq_cache->len_arg_index];
PyGIArgCache *arg_cache = _pygi_callable_cache_get_arg (callable_cache,
seq_cache->len_arg_index);
if (!gi_argument_to_gsize (len_arg, &len, arg_cache->type_tag)) {
return NULL;
}
}
array_ = g_array_new (FALSE,
FALSE,
seq_cache->item_size);
if (array_ == NULL) {
PyErr_NoMemory ();
if (arg_cache->transfer == GI_TRANSFER_EVERYTHING && arg->v_pointer != NULL)
g_free (arg->v_pointer);
return NULL;
}
if (array_->data != NULL)
g_free (array_->data);
array_->data = arg->v_pointer;
array_->len = len;
} else {
array_ = arg->v_pointer;
}
if (seq_cache->item_cache->type_tag == GI_TYPE_TAG_UINT8) {
if (arg->v_pointer == NULL) {
py_obj = PYGLIB_PyBytes_FromString ("");
} else {
py_obj = PYGLIB_PyBytes_FromStringAndSize (array_->data, array_->len);
}
} else {
if (arg->v_pointer == NULL) {
py_obj = PyList_New (0);
} else {
int i;
gsize item_size;
PyGIMarshalToPyFunc item_to_py_marshaller;
PyGIArgCache *item_arg_cache;
py_obj = PyList_New (array_->len);
if (py_obj == NULL)
goto err;
item_arg_cache = seq_cache->item_cache;
item_to_py_marshaller = item_arg_cache->to_py_marshaller;
item_size = g_array_get_element_size (array_);
for (i = 0; i < array_->len; i++) {
GIArgument item_arg = {0};
PyObject *py_item;
/* If we are receiving an array of pointers, simply assign the pointer
* and move on, letting the per-item marshaler deal with the
* various transfer modes and ref counts (e.g. g_variant_ref_sink).
*/
if (seq_cache->array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
item_arg.v_pointer = g_ptr_array_index ( ( GPtrArray *)array_, i);
} else if (item_arg_cache->is_pointer) {
item_arg.v_pointer = g_array_index (array_, gpointer, i);
} else if (item_arg_cache->type_tag == GI_TYPE_TAG_INTERFACE) {
PyGIInterfaceCache *iface_cache = (PyGIInterfaceCache *) item_arg_cache;
// FIXME: This probably doesn't work with boxed types or gvalues. See fx. _pygi_marshal_from_py_array()
switch (g_base_info_get_type (iface_cache->interface_info)) {
case GI_INFO_TYPE_STRUCT:
if (arg_cache->transfer == GI_TRANSFER_EVERYTHING &&
!g_type_is_a (iface_cache->g_type, G_TYPE_BOXED)) {
/* array elements are structs */
gpointer *_struct = g_malloc (item_size);
memcpy (_struct, array_->data + i * item_size,
item_size);
item_arg.v_pointer = _struct;
} else {
item_arg.v_pointer = array_->data + i * item_size;
}
break;
default:
item_arg.v_pointer = g_array_index (array_, gpointer, i);
break;
}
} else {
memcpy (&item_arg, array_->data + i * item_size, item_size);
}
py_item = item_to_py_marshaller ( state,
callable_cache,
item_arg_cache,
&item_arg);
if (py_item == NULL) {
Py_CLEAR (py_obj);
if (seq_cache->array_type == GI_ARRAY_TYPE_C)
g_array_unref (array_);
goto err;
}
PyList_SET_ITEM (py_obj, i, py_item);
processed_items++;
}
}
}
if (seq_cache->array_type == GI_ARRAY_TYPE_C)
g_array_free (array_, FALSE);
return py_obj;
err:
if (seq_cache->array_type == GI_ARRAY_TYPE_C) {
g_array_free (array_, arg_cache->transfer == GI_TRANSFER_EVERYTHING);
} else {
/* clean up unprocessed items */
if (seq_cache->item_cache->to_py_cleanup != NULL) {
int j;
PyGIMarshalCleanupFunc cleanup_func = seq_cache->item_cache->to_py_cleanup;
for (j = processed_items; j < array_->len; j++) {
cleanup_func (state,
seq_cache->item_cache,
NULL,
g_array_index (array_, gpointer, j),
FALSE);
}
}
if (arg_cache->transfer == GI_TRANSFER_EVERYTHING)
g_array_free (array_, TRUE);
}
return NULL;
}