void *
_pygi_boxed_alloc (GIBaseInfo *info, gsize *size_out)
{
gsize size;
/* FIXME: Remove when bgo#622711 is fixed */
if (g_registered_type_info_get_g_type (info) == G_TYPE_VALUE) {
size = sizeof (GValue);
} else {
switch (g_base_info_get_type (info)) {
case GI_INFO_TYPE_UNION:
size = g_union_info_get_size ( (GIUnionInfo *) info);
break;
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
size = g_struct_info_get_size ( (GIStructInfo *) info);
break;
default:
PyErr_Format (PyExc_TypeError,
"info should be Boxed or Union, not '%d'",
g_base_info_get_type (info));
return NULL;
}
}
if( size_out != NULL)
*size_out = size;
return g_slice_alloc0 (size);
}
/* Retrieves pointer to GIArgument in given array, given that array
contains elements of type ti. */
static gssize
array_get_elt_size (GITypeInfo *ti)
{
gssize size = sizeof (gpointer);
if (!g_type_info_is_pointer (ti))
{
switch (g_type_info_get_tag (ti))
{
#define HANDLE_ELT(nameupper, nametype) \
case GI_TYPE_TAG_ ## nameupper: \
return sizeof (nametype);
HANDLE_ELT(BOOLEAN, gboolean);
HANDLE_ELT(INT8, gint8);
HANDLE_ELT(UINT8, guint8);
HANDLE_ELT(INT16, gint16);
HANDLE_ELT(UINT16, guint16);
HANDLE_ELT(INT32, gint32);
HANDLE_ELT(UINT32, guint32);
HANDLE_ELT(UNICHAR, guint32);
HANDLE_ELT(INT64, gint64);
HANDLE_ELT(UINT64, guint64);
HANDLE_ELT(FLOAT, gfloat);
HANDLE_ELT(DOUBLE, gdouble);
HANDLE_ELT(GTYPE, GType);
#undef HANDLE_ELT
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *info = g_type_info_get_interface (ti);
GIInfoType type = g_base_info_get_type (info);
if (type == GI_INFO_TYPE_STRUCT)
size = g_struct_info_get_size (info);
else if (type == GI_INFO_TYPE_UNION)
size = g_union_info_get_size (info);
g_base_info_unref (info);
break;
}
default:
break;
}
}
return size;
}
gsize
_pygi_g_type_info_size (GITypeInfo *type_info)
{
gsize size = 0;
GITypeTag type_tag;
type_tag = g_type_info_get_tag (type_info);
switch (type_tag) {
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:
size = _pygi_g_type_tag_size (type_tag);
g_assert (size > 0);
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_STRUCT:
if (g_type_info_is_pointer (type_info)) {
size = sizeof (gpointer);
} else {
size = g_struct_info_get_size ( (GIStructInfo *) info);
}
break;
case GI_INFO_TYPE_UNION:
if (g_type_info_is_pointer (type_info)) {
size = sizeof (gpointer);
} else {
size = g_union_info_get_size ( (GIUnionInfo *) info);
}
break;
case GI_INFO_TYPE_ENUM:
case GI_INFO_TYPE_FLAGS:
if (g_type_info_is_pointer (type_info)) {
size = sizeof (gpointer);
} else {
GITypeTag type_tag;
type_tag = g_enum_info_get_storage_type ( (GIEnumInfo *) info);
size = _pygi_g_type_tag_size (type_tag);
}
break;
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_OBJECT:
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_CALLBACK:
size = sizeof (gpointer);
break;
case GI_INFO_TYPE_VFUNC:
case GI_INFO_TYPE_INVALID:
case GI_INFO_TYPE_FUNCTION:
case GI_INFO_TYPE_CONSTANT:
case GI_INFO_TYPE_VALUE:
case GI_INFO_TYPE_SIGNAL:
case GI_INFO_TYPE_PROPERTY:
case GI_INFO_TYPE_FIELD:
case GI_INFO_TYPE_ARG:
case GI_INFO_TYPE_TYPE:
case GI_INFO_TYPE_UNRESOLVED:
default:
g_assert_not_reached();
break;
}
g_base_info_unref (info);
break;
}
case GI_TYPE_TAG_ARRAY:
case GI_TYPE_TAG_VOID:
case GI_TYPE_TAG_UTF8:
case GI_TYPE_TAG_FILENAME:
case GI_TYPE_TAG_GLIST:
case GI_TYPE_TAG_GSLIST:
case GI_TYPE_TAG_GHASH:
case GI_TYPE_TAG_ERROR:
size = sizeof (gpointer);
break;
}
return size;
}
static gpointer
sv_to_struct (GITransfer transfer,
GIBaseInfo * info,
GIInfoType info_type,
SV * sv)
{
HV *hv;
gsize size = 0;
GITransfer field_transfer;
gpointer pointer = NULL;
dwarn ("sv = %p\n", sv);
if (!gperl_sv_is_defined (sv))
return NULL;
if (is_struct_disguised (info)) {
gchar *package;
dwarn (" disguised struct\n");
package = get_struct_package (info);
g_assert (package);
if (!gperl_sv_is_ref (sv) || !sv_derived_from (sv, package))
ccroak ("Cannot convert scalar %p to an object of type %s",
sv, package);
g_free (package);
return INT2PTR (void *, SvIV ((SV *) SvRV (sv)));
}
if (!gperl_sv_is_hash_ref (sv))
ccroak ("need a hash ref to convert to struct of type %s",
g_base_info_get_name (info));
hv = (HV *) SvRV (sv);
switch (info_type) {
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
size = g_struct_info_get_size ((GIStructInfo *) info);
break;
case GI_INFO_TYPE_UNION:
size = g_union_info_get_size ((GIStructInfo *) info);
break;
default:
g_assert_not_reached ();
}
dwarn (" size = %"G_GSIZE_FORMAT"\n", size);
field_transfer = GI_TRANSFER_NOTHING;
dwarn (" transfer = %d\n", transfer);
switch (transfer) {
case GI_TRANSFER_EVERYTHING:
field_transfer = GI_TRANSFER_EVERYTHING;
/* fall through */
case GI_TRANSFER_CONTAINER:
/* FIXME: What if there's a special allocator for the record?
* Like GSlice? */
pointer = g_malloc0 (size);
break;
default:
pointer = gperl_alloc_temp (size);
break;
}
switch (info_type) {
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
{
gint i, n_fields =
g_struct_info_get_n_fields ((GIStructInfo *) info);
for (i = 0; i < n_fields; i++) {
GIFieldInfo *field_info;
const gchar *field_name;
SV **svp;
field_info = g_struct_info_get_field (
(GIStructInfo *) info, i);
/* FIXME: Check GIFieldInfoFlags. */
field_name = g_base_info_get_name (
(GIBaseInfo *) field_info);
dwarn (" field %d (%s)\n", i, field_name);
svp = hv_fetch (hv, field_name, strlen (field_name), 0);
if (svp && gperl_sv_is_defined (*svp)) {
set_field (field_info, pointer,
field_transfer, *svp);
}
g_base_info_unref ((GIBaseInfo *) field_info);
}
break;
}
case GI_INFO_TYPE_UNION:
ccroak ("%s: unions not handled yet", G_STRFUNC);
default:
ccroak ("%s: unhandled info type %d", G_STRFUNC, info_type);
}
return pointer;
}
