gi/pygi-value.c

   1
   2 /* -*- Mode: C; c-basic-offset: 4 -*-
   3  * vim: tabstop=4 shiftwidth=4 expandtab
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <Python.h>
  20 #include "pygi-value.h"
  21 #include "pygi-struct.h"
  22 #include "pygi-python-compat.h"
  23 #include "pygi-basictype.h"
  24 #include "pygobject-object.h"
  25 #include "pygi-type.h"
  26 #include "pygenum.h"
  27 #include "pygpointer.h"
  28 #include "pygboxed.h"
  29 #include "pygflags.h"
  30 #include "pygparamspec.h"
  31
  32
  33 GIArgument
  34 _pygi_argument_from_g_value(const GValue *value,
  35                             GITypeInfo *type_info)
  36 {
  37     GIArgument arg = { 0, };
  38
  39     GITypeTag type_tag = g_type_info_get_tag (type_info);
  40
  41     /* For the long handling: long can be equivalent to
  42        int32 or int64, depending on the architecture, but
  43        gi doesn't tell us (and same for ulong)
  44     */
  45     switch (type_tag) {
  46         case GI_TYPE_TAG_BOOLEAN:
  47             arg.v_boolean = g_value_get_boolean (value);
  48             break;
  49         case GI_TYPE_TAG_INT8:
  50             arg.v_int8 = g_value_get_schar (value);
  51             break;
  52         case GI_TYPE_TAG_INT16:
  53         case GI_TYPE_TAG_INT32:
  54             if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_LONG))
  55                 arg.v_int32 = (gint32)g_value_get_long (value);
  56             else
  57                 arg.v_int32 = (gint32)g_value_get_int (value);
  58             break;
  59         case GI_TYPE_TAG_INT64:
  60             if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_LONG))
  61                 arg.v_int64 = g_value_get_long (value);
  62             else
  63                 arg.v_int64 = g_value_get_int64 (value);
  64             break;
  65         case GI_TYPE_TAG_UINT8:
  66             arg.v_uint8 = g_value_get_uchar (value);
  67             break;
  68         case GI_TYPE_TAG_UINT16:
  69         case GI_TYPE_TAG_UINT32:
  70             if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_ULONG))
  71                 arg.v_uint32 = (guint32)g_value_get_ulong (value);
  72             else
  73                 arg.v_uint32 = (guint32)g_value_get_uint (value);
  74             break;
  75         case GI_TYPE_TAG_UINT64:
  76             if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_ULONG))
  77                 arg.v_uint64 = g_value_get_ulong (value);
  78             else
  79                 arg.v_uint64 = g_value_get_uint64 (value);
  80             break;
  81         case GI_TYPE_TAG_UNICHAR:
  82             arg.v_uint32 = g_value_get_schar (value);
  83             break;
  84         case GI_TYPE_TAG_FLOAT:
  85             arg.v_float = g_value_get_float (value);
  86             break;
  87         case GI_TYPE_TAG_DOUBLE:
  88             arg.v_double = g_value_get_double (value);
  89             break;
  90         case GI_TYPE_TAG_GTYPE:
  91             arg.v_size = g_value_get_gtype (value);
  92             break;
  93         case GI_TYPE_TAG_UTF8:
  94         case GI_TYPE_TAG_FILENAME:
  95             /* Callers are responsible for ensuring the GValue stays alive
  96              * long enough for the string to be copied. */
  97             arg.v_string = (char *)g_value_get_string (value);
  98             break;
  99         case GI_TYPE_TAG_GLIST:
 100         case GI_TYPE_TAG_GSLIST:
 101         case GI_TYPE_TAG_ARRAY:
 102         case GI_TYPE_TAG_GHASH:
 103             if (G_VALUE_HOLDS_BOXED (value))
 104                 arg.v_pointer = g_value_get_boxed (value);
 105             else
 106                 /* e. g. GSettings::change-event */
 107                 arg.v_pointer = g_value_get_pointer (value);
 108             break;
 109         case GI_TYPE_TAG_INTERFACE:
 110         {
 111             GIBaseInfo *info;
 112             GIInfoType info_type;
 113
 114             info = g_type_info_get_interface (type_info);
 115             info_type = g_base_info_get_type (info);
 116
 117             g_base_info_unref (info);
 118
 119             switch (info_type) {
 120                 case GI_INFO_TYPE_FLAGS:
 121                     arg.v_uint = g_value_get_flags (value);
 122                     break;
 123                 case GI_INFO_TYPE_ENUM:
 124                     arg.v_int = g_value_get_enum (value);
 125                     break;
 126                 case GI_INFO_TYPE_INTERFACE:
 127                 case GI_INFO_TYPE_OBJECT:
 128                     if (G_VALUE_HOLDS_PARAM (value))
 129                       arg.v_pointer = g_value_get_param (value);
 130                     else
 131                       arg.v_pointer = g_value_get_object (value);
 132                     break;
 133                 case GI_INFO_TYPE_BOXED:
 134                 case GI_INFO_TYPE_STRUCT:
 135                 case GI_INFO_TYPE_UNION:
 136                     if (G_VALUE_HOLDS (value, G_TYPE_BOXED)) {
 137                         arg.v_pointer = g_value_get_boxed (value);
 138                     } else if (G_VALUE_HOLDS (value, G_TYPE_VARIANT)) {
 139                         arg.v_pointer = g_value_get_variant (value);
 140                     } else if (G_VALUE_HOLDS (value, G_TYPE_POINTER)) {
 141                         arg.v_pointer = g_value_get_pointer (value);
 142                     } else {
 143                         PyErr_Format (PyExc_NotImplementedError,
 144                                       "Converting GValue's of type '%s' is not implemented.",
 145                                       g_type_name (G_VALUE_TYPE (value)));
 146                     }
 147                     break;
 148                 default:
 149                     PyErr_Format (PyExc_NotImplementedError,
 150                                   "Converting GValue's of type '%s' is not implemented.",
 151                                   g_info_type_to_string (info_type));
 152                     break;
 153             }
 154             break;
 155         }
 156         case GI_TYPE_TAG_ERROR:
 157             arg.v_pointer = g_value_get_boxed (value);
 158             break;
 159         case GI_TYPE_TAG_VOID:
 160             arg.v_pointer = g_value_get_pointer (value);
 161             break;
 162         default:
 163             break;
 164     }
 165
 166     return arg;
 167 }
 168
 169
 170 /* Ignore g_value_array deprecations. Although they are deprecated,
 171  * we still need to support the marshaling of them in PyGObject.
 172  */
 173 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 174
 175 static int
 176 pyg_value_array_from_pyobject(GValue *value,
 177                               PyObject *obj,
 178                               const GParamSpecValueArray *pspec)
 179 {
 180     Py_ssize_t seq_len;
 181     GValueArray *value_array;
 182     guint len, i;
 183
 184     seq_len = PySequence_Length(obj);
 185     if (seq_len == -1) {
 186         PyErr_Clear();
 187         return -1;
 188     }
 189     len = (guint)seq_len;
 190
 191     if (pspec && pspec->fixed_n_elements > 0 && len != pspec->fixed_n_elements)
 192         return -1;
 193
 194     value_array = g_value_array_new(len);
 195
 196     for (i = 0; i < len; ++i) {
 197         PyObject *item = PySequence_GetItem(obj, i);
 198         GType type;
 199
 200         if (! item) {
 201             PyErr_Clear();
 202             g_value_array_free(value_array);
 203             return -1;
 204         }
 205
 206         if (pspec && pspec->element_spec)
 207             type = G_PARAM_SPEC_VALUE_TYPE(pspec->element_spec);
 208         else if (item == Py_None)
 209             type = G_TYPE_POINTER; /* store None as NULL */
 210         else {
 211             type = pyg_type_from_object((PyObject*)Py_TYPE(item));
 212             if (! type) {
 213                 PyErr_Clear();
 214                 g_value_array_free(value_array);
 215                 Py_DECREF(item);
 216                 return -1;
 217             }
 218         }
 219
 220         if (type == G_TYPE_VALUE) {
 221             const GValue * item_value = pyg_boxed_get(item, GValue);
 222             g_value_array_append(value_array, item_value);
 223         } else {
 224             GValue item_value = { 0, };
 225             int status;
 226
 227             g_value_init(&item_value, type);
 228             status = (pspec && pspec->element_spec)
 229                 ? pyg_param_gvalue_from_pyobject(&item_value, item, pspec->element_spec)
 230                 : pyg_value_from_pyobject(&item_value, item);
 231             Py_DECREF(item);
 232
 233             if (status == -1) {
 234                 g_value_array_free(value_array);
 235                 g_value_unset(&item_value);
 236                 return -1;
 237             }
 238             g_value_array_append(value_array, &item_value);
 239             g_value_unset(&item_value);
 240         }
 241     }
 242
 243     g_value_take_boxed(value, value_array);
 244     return 0;
 245 }
 246
 247 G_GNUC_END_IGNORE_DEPRECATIONS
 248
 249 static int
 250 pyg_array_from_pyobject(GValue *value,
 251                         PyObject *obj)
 252 {
 253     Py_ssize_t len, i;
 254     GArray *array;
 255
 256     len = PySequence_Length(obj);
 257     if (len == -1) {
 258         PyErr_Clear();
 259         return -1;
 260     }
 261
 262     array = g_array_new(FALSE, TRUE, sizeof(GValue));
 263
 264     for (i = 0; i < len; ++i) {
 265         PyObject *item = PySequence_GetItem(obj, i);
 266         GType type;
 267         GValue item_value = { 0, };
 268         int status;
 269
 270         if (! item) {
 271             PyErr_Clear();
 272             g_array_free(array, FALSE);
 273             return -1;
 274         }
 275
 276         if (item == Py_None)
 277             type = G_TYPE_POINTER; /* store None as NULL */
 278         else {
 279             type = pyg_type_from_object((PyObject*)Py_TYPE(item));
 280             if (! type) {
 281                 PyErr_Clear();
 282                 g_array_free(array, FALSE);
 283                 Py_DECREF(item);
 284                 return -1;
 285             }
 286         }
 287
 288         g_value_init(&item_value, type);
 289         status = pyg_value_from_pyobject(&item_value, item);
 290         Py_DECREF(item);
 291
 292         if (status == -1) {
 293             g_array_free(array, FALSE);
 294             g_value_unset(&item_value);
 295             return -1;
 296         }
 297
 298         g_array_append_val(array, item_value);
 299     }
 300
 301     g_value_take_boxed(value, array);
 302     return 0;
 303 }
 304
 305 /**
 306  * pyg_value_from_pyobject_with_error:
 307  * @value: the GValue object to store the converted value in.
 308  * @obj: the Python object to convert.
 309  *
 310  * This function converts a Python object and stores the result in a
 311  * GValue.  The GValue must be initialised in advance with
 312  * g_value_init().  If the Python object can't be converted to the
 313  * type of the GValue, then an error is returned.
 314  *
 315  * Returns: 0 on success, -1 on error.
 316  */
 317 int
 318 pyg_value_from_pyobject_with_error(GValue *value, PyObject *obj)
 319 {
 320     GType value_type = G_VALUE_TYPE(value);
 321
 322     switch (G_TYPE_FUNDAMENTAL(value_type)) {
 323     case G_TYPE_INTERFACE:
 324         /* we only handle interface types that have a GObject prereq */
 325         if (g_type_is_a(value_type, G_TYPE_OBJECT)) {
 326             if (obj == Py_None)
 327                 g_value_set_object(value, NULL);
 328             else {
 329                 if (!PyObject_TypeCheck(obj, &PyGObject_Type)) {
 330                     PyErr_SetString(PyExc_TypeError, "GObject is required");
 331                     return -1;
 332                 }
 333                 if (!G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj),
 334                         value_type)) {
 335                     PyErr_SetString(PyExc_TypeError, "Invalid GObject type for assignment");
 336                     return -1;
 337                 }
 338                 g_value_set_object(value, pygobject_get(obj));
 339             }
 340         } else {
 341             PyErr_SetString(PyExc_TypeError, "Unsupported conversion");
 342             return -1;
 343         }
 344         break;
 345     case G_TYPE_CHAR:
 346     {
 347         gint8 temp;
 348         if (pygi_gschar_from_py (obj, &temp)) {
 349             g_value_set_schar (value, temp);
 350             return 0;
 351         } else
 352             return -1;
 353     }
 354     case G_TYPE_UCHAR:
 355     {
 356         guchar temp;
 357         if (pygi_guchar_from_py (obj, &temp)) {
 358             g_value_set_uchar (value, temp);
 359             return 0;
 360         } else
 361             return -1;
 362     }
 363     case G_TYPE_BOOLEAN:
 364     {
 365         gboolean temp;
 366         if (pygi_gboolean_from_py (obj, &temp)) {
 367             g_value_set_boolean (value, temp);
 368             return 0;
 369         } else
 370             return -1;
 371     }
 372     case G_TYPE_INT:
 373     {
 374         gint temp;
 375         if (pygi_gint_from_py (obj, &temp)) {
 376             g_value_set_int (value, temp);
 377             return 0;
 378         } else
 379             return -1;
 380     }
 381     case G_TYPE_UINT:
 382     {
 383         guint temp;
 384         if (pygi_guint_from_py (obj, &temp)) {
 385             g_value_set_uint (value, temp);
 386             return 0;
 387         } else
 388             return -1;
 389     }
 390     case G_TYPE_LONG:
 391     {
 392         glong temp;
 393         if (pygi_glong_from_py (obj, &temp)) {
 394             g_value_set_long (value, temp);
 395             return 0;
 396         } else
 397             return -1;
 398     }
 399     case G_TYPE_ULONG:
 400     {
 401         gulong temp;
 402         if (pygi_gulong_from_py (obj, &temp)) {
 403             g_value_set_ulong (value, temp);
 404             return 0;
 405         } else
 406             return -1;
 407     }
 408     case G_TYPE_INT64:
 409     {
 410         gint64 temp;
 411         if (pygi_gint64_from_py (obj, &temp)) {
 412             g_value_set_int64 (value, temp);
 413             return 0;
 414         } else
 415             return -1;
 416     }
 417     case G_TYPE_UINT64:
 418     {
 419         guint64 temp;
 420         if (pygi_guint64_from_py (obj, &temp)) {
 421             g_value_set_uint64 (value, temp);
 422             return 0;
 423         } else
 424             return -1;
 425     }
 426     case G_TYPE_ENUM:
 427     {
 428         gint val = 0;
 429         if (pyg_enum_get_value(G_VALUE_TYPE(value), obj, &val) < 0) {
 430             return -1;
 431         }
 432         g_value_set_enum(value, val);
 433     }
 434     break;
 435     case G_TYPE_FLAGS:
 436     {
 437         guint val = 0;
 438         if (pyg_flags_get_value(G_VALUE_TYPE(value), obj, &val) < 0) {
 439             return -1;
 440         }
 441         g_value_set_flags(value, val);
 442         return 0;
 443     }
 444     break;
 445     case G_TYPE_FLOAT:
 446     {
 447         gfloat temp;
 448         if (pygi_gfloat_from_py (obj, &temp)) {
 449             g_value_set_float (value, temp);
 450             return 0;
 451         } else
 452             return -1;
 453     }
 454     case G_TYPE_DOUBLE:
 455     {
 456         gdouble temp;
 457         if (pygi_gdouble_from_py (obj, &temp)) {
 458             g_value_set_double (value, temp);
 459             return 0;
 460         } else
 461             return -1;
 462     }
 463     case G_TYPE_STRING:
 464     {
 465         gchar *temp;
 466         if (pygi_utf8_from_py (obj, &temp)) {
 467             g_value_take_string (value, temp);
 468             return 0;
 469         } else {
 470             /* also allows setting anything implementing __str__ */
 471             PyObject* str;
 472             PyErr_Clear ();
 473             str = PyObject_Str (obj);
 474             if (str == NULL)
 475                 return -1;
 476             if (pygi_utf8_from_py (str, &temp)) {
 477                 Py_DECREF (str);
 478                 g_value_take_string (value, temp);
 479                 return 0;
 480             }
 481             Py_DECREF (str);
 482             return -1;
 483         }
 484     }
 485     case G_TYPE_POINTER:
 486         if (obj == Py_None)
 487             g_value_set_pointer(value, NULL);
 488         else if (PyObject_TypeCheck(obj, &PyGPointer_Type) &&
 489                 G_VALUE_HOLDS(value, ((PyGPointer *)obj)->gtype))
 490             g_value_set_pointer(value, pyg_pointer_get(obj, gpointer));
 491         else if (PyCapsule_CheckExact (obj))
 492             g_value_set_pointer(value, PyCapsule_GetPointer (obj, NULL));
 493         else if (G_VALUE_HOLDS_GTYPE (value))
 494             g_value_set_gtype (value, pyg_type_from_object (obj));
 495         else {
 496             PyErr_SetString(PyExc_TypeError, "Expected pointer");
 497             return -1;
 498         }
 499         break;
 500     case G_TYPE_BOXED: {
 501         PyGTypeMarshal *bm;
 502         gboolean holds_value_array;
 503
 504         G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 505         holds_value_array = G_VALUE_HOLDS(value, G_TYPE_VALUE_ARRAY);
 506         G_GNUC_END_IGNORE_DEPRECATIONS
 507
 508         if (obj == Py_None)
 509             g_value_set_boxed(value, NULL);
 510         else if (G_VALUE_HOLDS(value, PY_TYPE_OBJECT))
 511             g_value_set_boxed(value, obj);
 512         else if (PyObject_TypeCheck(obj, &PyGBoxed_Type) &&
 513                 G_VALUE_HOLDS(value, ((PyGBoxed *)obj)->gtype))
 514             g_value_set_boxed(value, pyg_boxed_get(obj, gpointer));
 515         else if (G_VALUE_HOLDS(value, G_TYPE_VALUE)) {
 516             GType type;
 517             GValue *n_value;
 518
 519             type = pyg_type_from_object((PyObject*)Py_TYPE(obj));
 520             if (G_UNLIKELY (! type)) {
 521                 return -1;
 522             }
 523             n_value = g_new0 (GValue, 1);
 524             g_value_init (n_value, type);
 525             g_value_take_boxed (value, n_value);
 526             return pyg_value_from_pyobject_with_error (n_value, obj);
 527         }
 528         else if (PySequence_Check(obj) && holds_value_array)
 529             return pyg_value_array_from_pyobject(value, obj, NULL);
 530
 531         else if (PySequence_Check(obj) &&
 532                 G_VALUE_HOLDS(value, G_TYPE_ARRAY))
 533             return pyg_array_from_pyobject(value, obj);
 534         else if (PYGLIB_PyUnicode_Check(obj) &&
 535                 G_VALUE_HOLDS(value, G_TYPE_GSTRING)) {
 536             GString *string;
 537             char *buffer;
 538             Py_ssize_t len;
 539             if (PYGLIB_PyUnicode_AsStringAndSize(obj, &buffer, &len))
 540                 return -1;
 541             string = g_string_new_len(buffer, len);
 542             g_value_set_boxed(value, string);
 543             g_string_free (string, TRUE);
 544             break;
 545         }
 546         else if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))) != NULL)
 547             return bm->tovalue(value, obj);
 548         else if (PyCapsule_CheckExact (obj))
 549             g_value_set_boxed(value, PyCapsule_GetPointer (obj, NULL));
 550         else {
 551             PyErr_SetString(PyExc_TypeError, "Expected Boxed");
 552             return -1;
 553         }
 554         break;
 555     }
 556     case G_TYPE_PARAM:
 557         /* we need to support both the wrapped _gi.GParamSpec and the GI
 558          * GObject.ParamSpec */
 559         if (G_IS_PARAM_SPEC (pygobject_get (obj)))
 560             g_value_set_param(value, G_PARAM_SPEC (pygobject_get (obj)));
 561         else if (pyg_param_spec_check (obj))
 562             g_value_set_param(value, PyCapsule_GetPointer (obj, NULL));
 563         else {
 564             PyErr_SetString(PyExc_TypeError, "Expected ParamSpec");
 565             return -1;
 566         }
 567         break;
 568     case G_TYPE_OBJECT:
 569         if (obj == Py_None) {
 570             g_value_set_object(value, NULL);
 571         } else if (PyObject_TypeCheck(obj, &PyGObject_Type) &&
 572                 G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj),
 573                         G_VALUE_TYPE(value))) {
 574             g_value_set_object(value, pygobject_get(obj));
 575         } else {
 576             PyErr_SetString(PyExc_TypeError, "Expected GObject");
 577             return -1;
 578         }
 579         break;
 580     case G_TYPE_VARIANT:
 581     {
 582         if (obj == Py_None)
 583             g_value_set_variant(value, NULL);
 584         else if (pyg_type_from_object_strict(obj, FALSE) == G_TYPE_VARIANT)
 585             g_value_set_variant(value, pyg_boxed_get(obj, GVariant));
 586         else {
 587             PyErr_SetString(PyExc_TypeError, "Expected Variant");
 588             return -1;
 589         }
 590         break;
 591     }
 592     default:
 593     {
 594         PyGTypeMarshal *bm;
 595         if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))) != NULL) {
 596             return bm->tovalue(value, obj);
 597         } else {
 598             PyErr_SetString(PyExc_TypeError, "Unknown value type");
 599             return -1;
 600         }
 601         break;
 602     }
 603     }
 604
 605     /* If an error occurred, unset the GValue but don't clear the Python error. */
 606     if (PyErr_Occurred()) {
 607         g_value_unset(value);
 608         return -1;
 609     }
 610
 611     return 0;
 612 }
 613
 614 /**
 615  * pyg_value_from_pyobject:
 616  * @value: the GValue object to store the converted value in.
 617  * @obj: the Python object to convert.
 618  *
 619  * Same basic function as pyg_value_from_pyobject_with_error but clears
 620  * any Python errors before returning.
 621  *
 622  * Returns: 0 on success, -1 on error.
 623  */
 624 int
 625 pyg_value_from_pyobject(GValue *value, PyObject *obj)
 626 {
 627     int res = pyg_value_from_pyobject_with_error (value, obj);
 628
 629     if (PyErr_Occurred()) {
 630         PyErr_Clear();
 631         return -1;
 632     }
 633     return res;
 634 }
 635
 636 /**
 637  * pygi_value_to_py_basic_type:
 638  * @value: the GValue object.
 639  * @handled: (out): TRUE if the return value is defined
 640  *
 641  * This function creates/returns a Python wrapper object that
 642  * represents the GValue passed as an argument limited to supporting basic types
 643  * like ints, bools, and strings.
 644  *
 645  * Returns: a PyObject representing the value.
 646  */
 647 PyObject *
 648 pygi_value_to_py_basic_type (const GValue *value, GType fundamental, gboolean *handled)
 649 {
 650     *handled = TRUE;
 651     switch (fundamental) {
 652         case G_TYPE_CHAR:
 653             return PYGLIB_PyLong_FromLong (g_value_get_schar (value));
 654         case G_TYPE_UCHAR:
 655             return PYGLIB_PyLong_FromLong (g_value_get_uchar (value));
 656         case G_TYPE_BOOLEAN:
 657             return pygi_gboolean_to_py (g_value_get_boolean (value));
 658         case G_TYPE_INT:
 659             return pygi_gint_to_py (g_value_get_int (value));
 660         case G_TYPE_UINT:
 661             return pygi_guint_to_py (g_value_get_uint (value));
 662         case G_TYPE_LONG:
 663             return pygi_glong_to_py (g_value_get_long(value));
 664         case G_TYPE_ULONG:
 665             return pygi_gulong_to_py (g_value_get_ulong (value));
 666         case G_TYPE_INT64:
 667             return pygi_gint64_to_py (g_value_get_int64 (value));
 668         case G_TYPE_UINT64:
 669             return pygi_guint64_to_py (g_value_get_uint64 (value));
 670         case G_TYPE_ENUM:
 671             return pyg_enum_from_gtype (G_VALUE_TYPE (value),
 672                                         g_value_get_enum (value));
 673         case G_TYPE_FLAGS:
 674             return pyg_flags_from_gtype (G_VALUE_TYPE (value),
 675                                          g_value_get_flags (value));
 676         case G_TYPE_FLOAT:
 677             return pygi_gfloat_to_py (g_value_get_float (value));
 678         case G_TYPE_DOUBLE:
 679             return pygi_gdouble_to_py (g_value_get_double (value));
 680         case G_TYPE_STRING:
 681             return pygi_utf8_to_py (g_value_get_string (value));
 682         default:
 683             *handled = FALSE;
 684             return NULL;
 685     }
 686 }
 687
 688 /**
 689  * value_to_py_structured_type:
 690  * @value: the GValue object.
 691  * @copy_boxed: true if boxed values should be copied.
 692  *
 693  * This function creates/returns a Python wrapper object that
 694  * represents the GValue passed as an argument.
 695  *
 696  * Returns: a PyObject representing the value or NULL and sets an error;
 697  */
 698 static PyObject *
 699 value_to_py_structured_type (const GValue *value, GType fundamental, gboolean copy_boxed)
 700 {
 701     const gchar *type_name;
 702
 703     switch (fundamental) {
 704     case G_TYPE_INTERFACE:
 705         if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT))
 706             return pygobject_new(g_value_get_object(value));
 707         else
 708             break;
 709
 710     case G_TYPE_POINTER:
 711         if (G_VALUE_HOLDS_GTYPE (value))
 712             return pyg_type_wrapper_new (g_value_get_gtype (value));
 713         else
 714             return pyg_pointer_new(G_VALUE_TYPE(value),
 715                     g_value_get_pointer(value));
 716     case G_TYPE_BOXED: {
 717         PyGTypeMarshal *bm;
 718         gboolean holds_value_array;
 719
 720         G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 721         holds_value_array = G_VALUE_HOLDS(value, G_TYPE_VALUE_ARRAY);
 722         G_GNUC_END_IGNORE_DEPRECATIONS
 723
 724         if (G_VALUE_HOLDS(value, PY_TYPE_OBJECT)) {
 725             PyObject *ret = (PyObject *)g_value_dup_boxed(value);
 726             if (ret == NULL) {
 727                 Py_INCREF(Py_None);
 728                 return Py_None;
 729             }
 730             return ret;
 731         } else if (G_VALUE_HOLDS(value, G_TYPE_VALUE)) {
 732             GValue *n_value = g_value_get_boxed (value);
 733             return pyg_value_as_pyobject(n_value, copy_boxed);
 734         } else if (holds_value_array) {
 735             GValueArray *array = (GValueArray *) g_value_get_boxed(value);
 736             Py_ssize_t n_values = array ? array->n_values : 0;
 737             PyObject *ret = PyList_New(n_values);
 738             int i;
 739             for (i = 0; i < n_values; ++i)
 740                 PyList_SET_ITEM(ret, i, pyg_value_as_pyobject
 741                         (array->values + i, copy_boxed));
 742             return ret;
 743         } else if (G_VALUE_HOLDS(value, G_TYPE_GSTRING)) {
 744             GString *string = (GString *) g_value_get_boxed(value);
 745             PyObject *ret = PYGLIB_PyUnicode_FromStringAndSize(string->str, string->len);
 746             return ret;
 747         }
 748         bm = pyg_type_lookup(G_VALUE_TYPE(value));
 749         if (bm) {
 750             return bm->fromvalue(value);
 751         } else {
 752             if (copy_boxed)
 753                 return pygi_gboxed_new(G_VALUE_TYPE(value),
 754                         g_value_get_boxed(value), TRUE, TRUE);
 755             else
 756                 return pygi_gboxed_new(G_VALUE_TYPE(value),
 757                         g_value_get_boxed(value),FALSE,FALSE);
 758         }
 759     }
 760     case G_TYPE_PARAM:
 761         return pyg_param_spec_new(g_value_get_param(value));
 762     case G_TYPE_OBJECT:
 763         return pygobject_new(g_value_get_object(value));
 764     case G_TYPE_VARIANT:
 765     {
 766         GVariant *v = g_value_get_variant(value);
 767         if (v == NULL) {
 768             Py_INCREF(Py_None);
 769             return Py_None;
 770         }
 771         return pygi_struct_new_from_g_type (G_TYPE_VARIANT, g_variant_ref(v), FALSE);
 772     }
 773     default:
 774     {
 775         PyGTypeMarshal *bm;
 776         if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))))
 777             return bm->fromvalue(value);
 778         break;
 779     }
 780     }
 781
 782     type_name = g_type_name (G_VALUE_TYPE (value));
 783     if (type_name == NULL) {
 784         type_name = "(null)";
 785     }
 786     PyErr_Format (PyExc_TypeError, "unknown type %s", type_name);
 787     return NULL;
 788 }
 789
 790
 791 /**
 792  * pyg_value_as_pyobject:
 793  * @value: the GValue object.
 794  * @copy_boxed: true if boxed values should be copied.
 795  *
 796  * This function creates/returns a Python wrapper object that
 797  * represents the GValue passed as an argument.
 798  *
 799  * Returns: a PyObject representing the value or %NULL and sets an exception.
 800  */
 801 PyObject *
 802 pyg_value_as_pyobject (const GValue *value, gboolean copy_boxed)
 803 {
 804     PyObject *pyobj;
 805     gboolean handled;
 806     GType fundamental = G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value));
 807
 808     /* HACK: special case char and uchar to return PyBytes intstead of integers
 809      * in the general case. Property access will skip this by calling
 810      * pygi_value_to_py_basic_type() directly.
 811      * See: https://bugzilla.gnome.org/show_bug.cgi?id=733893 */
 812     if (fundamental == G_TYPE_CHAR) {
 813         gint8 val = g_value_get_schar(value);
 814         return PYGLIB_PyUnicode_FromStringAndSize ((char *)&val, 1);
 815     } else if (fundamental == G_TYPE_UCHAR) {
 816         guint8 val = g_value_get_uchar(value);
 817         return PYGLIB_PyBytes_FromStringAndSize ((char *)&val, 1);
 818     }
 819
 820     pyobj = pygi_value_to_py_basic_type (value, fundamental, &handled);
 821     if (handled)
 822         return pyobj;
 823
 824     pyobj = value_to_py_structured_type (value, fundamental, copy_boxed);
 825     return pyobj;
 826 }
 827
 828
 829 int
 830 pyg_param_gvalue_from_pyobject(GValue* value,
 831                                PyObject* py_obj,
 832                                const GParamSpec* pspec)
 833 {
 834     if (G_IS_PARAM_SPEC_UNICHAR(pspec)) {
 835         gunichar u;
 836
 837         if (!pyg_pyobj_to_unichar_conv(py_obj, &u)) {
 838             PyErr_Clear();
 839             return -1;
 840         }
 841         g_value_set_uint(value, u);
 842         return 0;
 843     }
 844     else if (G_IS_PARAM_SPEC_VALUE_ARRAY(pspec))
 845         return pyg_value_array_from_pyobject(value, py_obj,
 846                                              G_PARAM_SPEC_VALUE_ARRAY(pspec));
 847     else {
 848         return pyg_value_from_pyobject(value, py_obj);
 849     }
 850 }
 851
 852 PyObject*
 853 pyg_param_gvalue_as_pyobject(const GValue* gvalue,
 854                              gboolean copy_boxed,
 855                              const GParamSpec* pspec)
 856 {
 857     if (G_IS_PARAM_SPEC_UNICHAR(pspec)) {
 858         gunichar u;
 859         gchar *encoded;
 860         PyObject *retval;
 861
 862         u = g_value_get_uint (gvalue);
 863         encoded = g_ucs4_to_utf8 (&u, 1, NULL, NULL, NULL);
 864         if (encoded == NULL) {
 865             PyErr_SetString (PyExc_ValueError, "Failed to decode");
 866             return NULL;
 867         }
 868         retval = PyUnicode_FromString (encoded);
 869         g_free (encoded);
 870         return retval;
 871     }
 872     else {
 873         return pyg_value_as_pyobject(gvalue, copy_boxed);
 874     }
 875 }
 876
 877 PyObject *
 878 pyg__gvalue_get(PyObject *module, PyObject *pygvalue)
 879 {
 880     if (!pyg_boxed_check (pygvalue, G_TYPE_VALUE)) {
 881         PyErr_SetString (PyExc_TypeError, "Expected GValue argument.");
 882         return NULL;
 883     }
 884
 885     return pyg_value_as_pyobject (pyg_boxed_get(pygvalue, GValue),
 886                                   /*copy_boxed=*/ TRUE);
 887 }
 888
 889 PyObject *
 890 pyg__gvalue_set(PyObject *module, PyObject *args)
 891 {
 892     PyObject *pygvalue;
 893     PyObject *pyobject;
 894
 895     if (!PyArg_ParseTuple (args, "OO:_gi._gvalue_set",
 896                            &pygvalue, &pyobject))
 897         return NULL;
 898
 899     if (!pyg_boxed_check (pygvalue, G_TYPE_VALUE)) {
 900         PyErr_SetString (PyExc_TypeError, "Expected GValue argument.");
 901         return NULL;
 902     }
 903
 904     if (pyg_value_from_pyobject_with_error (pyg_boxed_get (pygvalue, GValue),
 905                                             pyobject) == -1)
 906         return NULL;
 907
 908     Py_RETURN_NONE;
 909 }