pygi-marshal-from-py.c 66.1 KB
Newer Older
1
2
3
/* -*- Mode: C; c-basic-offset: 4 -*-
 * vim: tabstop=4 shiftwidth=4 expandtab
 *
4
 * Copyright (C) 2011 John (J5) Palmieri <johnp@redhat.com>,  Red Hat, Inc.
5
 *
6
 *   pygi-marshal-from-py.c: Functions to convert PyObjects to C types.
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
 * USA
 */

#include "pygi-private.h"

#include <string.h>
#include <time.h>
#include <pygobject.h>
#include <pyglib-python-compat.h>

#include "pygi-cache.h"
32
#include "pygi-marshal-cleanup.h"
33
#include "pygi-marshal-from-py.h"
34

35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#ifdef _WIN32
#ifdef _MSC_VER
#include <math.h>

#ifndef NAN
static const unsigned long __nan[2] = {0xffffffff, 0x7fffffff};
#define NAN (*(const float *) __nan)
#endif

#ifndef INFINITY
#define INFINITY HUGE_VAL
#endif

#endif
#endif

51
static gboolean
David Malcolm's avatar
David Malcolm committed
52
53
54
55
56
57
58
gi_argument_from_py_ssize_t (GIArgument   *arg_out,
                             Py_ssize_t    size_in,
                             GITypeTag     type_tag)                             
{
    switch (type_tag) {
    case GI_TYPE_TAG_VOID:
    case GI_TYPE_TAG_BOOLEAN:
59
60
        goto unhandled_type;

David Malcolm's avatar
David Malcolm committed
61
    case GI_TYPE_TAG_INT8:
62
63
64
65
66
67
68
        if (size_in >= G_MININT8 && size_in <= G_MAXINT8) {
            arg_out->v_int8 = size_in;
            return TRUE;
        } else {
            goto overflow;
        }

David Malcolm's avatar
David Malcolm committed
69
    case GI_TYPE_TAG_UINT8:
70
71
72
73
74
75
76
        if (size_in >= 0 && size_in <= G_MAXUINT8) {
            arg_out->v_uint8 = size_in;
            return TRUE;
        } else {
            goto overflow;
        }

David Malcolm's avatar
David Malcolm committed
77
    case GI_TYPE_TAG_INT16:
78
79
80
81
82
83
84
        if (size_in >= G_MININT16 && size_in <= G_MAXINT16) {
            arg_out->v_int16 = size_in;
            return TRUE;
        } else {
            goto overflow;
        }

David Malcolm's avatar
David Malcolm committed
85
    case GI_TYPE_TAG_UINT16:
86
87
88
89
90
91
        if (size_in >= 0 && size_in <= G_MAXUINT16) {
            arg_out->v_uint16 = size_in;
            return TRUE;
        } else {
            goto overflow;
        }
David Malcolm's avatar
David Malcolm committed
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

        /* Ranges assume two's complement */
    case GI_TYPE_TAG_INT32:
        if (size_in >= G_MININT32 && size_in <= G_MAXINT32) {
            arg_out->v_int32 = size_in;
            return TRUE;
        } else {
            goto overflow;
        }

    case GI_TYPE_TAG_UINT32:
        if (size_in >= 0 && size_in <= G_MAXUINT32) {
            arg_out->v_uint32 = size_in;
            return TRUE;
        } else {
            goto overflow;
        }

    case GI_TYPE_TAG_INT64:
        arg_out->v_int64 = size_in;
        return TRUE;

    case GI_TYPE_TAG_UINT64:
        if (size_in >= 0) {
            arg_out->v_uint64 = size_in;
            return TRUE;
        } else {
            goto overflow;
        }
            
    case GI_TYPE_TAG_FLOAT:
    case GI_TYPE_TAG_DOUBLE:
    case GI_TYPE_TAG_GTYPE:
    case GI_TYPE_TAG_UTF8:
    case GI_TYPE_TAG_FILENAME:
    case GI_TYPE_TAG_ARRAY:
    case GI_TYPE_TAG_INTERFACE:
    case GI_TYPE_TAG_GLIST:
    case GI_TYPE_TAG_GSLIST:
    case GI_TYPE_TAG_GHASH:
    case GI_TYPE_TAG_ERROR:
    case GI_TYPE_TAG_UNICHAR:
    default:
        goto unhandled_type;
    }

 overflow:
    PyErr_Format (PyExc_OverflowError,
                  "Unable to marshal C Py_ssize_t %zd to %s",
                  size_in,
                  g_type_tag_to_string (type_tag));
    return FALSE;

 unhandled_type:
    PyErr_Format (PyExc_TypeError,
                  "Unable to marshal C Py_ssize_t %zd to %s",
                  size_in,
                  g_type_tag_to_string (type_tag));
    return FALSE;
}

153
static gboolean
David Malcolm's avatar
David Malcolm committed
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
gi_argument_from_c_long (GIArgument *arg_out,
                         long        c_long_in,
                         GITypeTag   type_tag)
{
    switch (type_tag) {
      case GI_TYPE_TAG_INT8:
          arg_out->v_int8 = c_long_in;
          return TRUE;
      case GI_TYPE_TAG_UINT8:
          arg_out->v_uint8 = c_long_in;
          return TRUE;
      case GI_TYPE_TAG_INT16:
          arg_out->v_int16 = c_long_in;
          return TRUE;
      case GI_TYPE_TAG_UINT16:
          arg_out->v_uint16 = c_long_in;
          return TRUE;
      case GI_TYPE_TAG_INT32:
          arg_out->v_int32 = c_long_in;
          return TRUE;
      case GI_TYPE_TAG_UINT32:
          arg_out->v_uint32 = c_long_in;
          return TRUE;
      case GI_TYPE_TAG_INT64:
          arg_out->v_int64 = c_long_in;
          return TRUE;
      case GI_TYPE_TAG_UINT64:
          arg_out->v_uint64 = c_long_in;
          return TRUE;
      default:
          PyErr_Format (PyExc_TypeError,
                        "Unable to marshal C long %ld to %s",
                        c_long_in,
                        g_type_tag_to_string (type_tag));
          return FALSE;
    }
}

192
193
194
195
196
/*
 * _is_union_member - check to see if the py_arg is actually a member of the
 * expected C union
 */
static gboolean
197
_is_union_member (GIInterfaceInfo *interface_info, PyObject *py_arg) {
198
199
200
201
202
203
    gint i;
    gint n_fields;
    GIUnionInfo *union_info;
    GIInfoType info_type;
    gboolean is_member = FALSE;

204
    info_type = g_base_info_get_type (interface_info);
205
206
207
208

    if (info_type != GI_INFO_TYPE_UNION)
        return FALSE;

209
    union_info = (GIUnionInfo *) interface_info;
210
211
212
213
214
215
216
217
218
219
220
    n_fields = g_union_info_get_n_fields (union_info);

    for (i = 0; i < n_fields; i++) {
        GIFieldInfo *field_info;
        GITypeInfo *field_type_info;

        field_info = g_union_info_get_field (union_info, i);
        field_type_info = g_field_info_get_type (field_info);

        /* we can only check if the members are interfaces */
        if (g_type_info_get_tag (field_type_info) == GI_TYPE_TAG_INTERFACE) {
221
            GIInterfaceInfo *field_iface_info;
222
223
            PyObject *py_type;

224
225
            field_iface_info = g_type_info_get_interface (field_type_info);
            py_type = _pygi_type_import_by_gi_info ((GIBaseInfo *) field_iface_info);
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244

            if (py_type != NULL && PyObject_IsInstance (py_arg, py_type)) {
                is_member = TRUE;
            }

            Py_XDECREF (py_type);
            g_base_info_unref ( ( GIBaseInfo *) field_iface_info);
        }

        g_base_info_unref ( ( GIBaseInfo *) field_type_info);
        g_base_info_unref ( ( GIBaseInfo *) field_info);

        if (is_member)
            break;
    }

    return is_member;
}

245
gboolean
246
247
248
249
250
_pygi_marshal_from_py_void (PyGIInvokeState   *state,
                            PyGICallableCache *callable_cache,
                            PyGIArgCache      *arg_cache,
                            PyObject          *py_arg,
                            GIArgument        *arg)
251
252
253
{
    g_warn_if_fail (arg_cache->transfer == GI_TRANSFER_NOTHING);

254
255
256
    if (py_arg == Py_None) {
        arg->v_pointer = NULL;
    } else if (PYGLIB_CPointer_Check(py_arg)) {
257
258
        arg->v_pointer = PYGLIB_CPointer_GetPointer (py_arg, NULL);
    } else {
259
260
261
262
263
264
265
266
267
268
269
270
271
        /* NOTE: This will change to only allow integers and the deprecation
         * warning will become a runtime exception. Using the following:
         * arg->v_pointer = PyLong_AsVoidPtr (py_arg);
         * See: https://bugzilla.gnome.org/show_bug.cgi?id=688081
         */

        if (!PYGLIB_PyLong_Check(py_arg) && !PyLong_Check(py_arg)) {
            if (PyErr_WarnEx(PyGIDeprecationWarning,
                             "Pointer arguments will be restricted to integers, capsules, and None. "
                             "See: https://bugzilla.gnome.org/show_bug.cgi?id=683599",
                             1))
                return FALSE;
        }
272
273
        arg->v_pointer = py_arg;
    }
274
275
276
277
278

    return TRUE;
}

gboolean
279
280
281
282
283
_pygi_marshal_from_py_boolean (PyGIInvokeState   *state,
                               PyGICallableCache *callable_cache,
                               PyGIArgCache      *arg_cache,
                               PyObject          *py_arg,
                               GIArgument        *arg)
284
{
285
    arg->v_boolean = PyObject_IsTrue (py_arg);
286
287
288
289
290

    return TRUE;
}

gboolean
291
292
293
294
295
_pygi_marshal_from_py_int8 (PyGIInvokeState   *state,
                            PyGICallableCache *callable_cache,
                            PyGIArgCache      *arg_cache,
                            PyObject          *py_arg,
                            GIArgument        *arg)
296
297
298
299
{
    PyObject *py_long;
    long long_;

300
    if (PYGLIB_PyBytes_Check (py_arg)) {
301

302
303
304
305
        if (PYGLIB_PyBytes_Size (py_arg) != 1) {
            PyErr_Format (PyExc_TypeError, "Must be a single character");
            return FALSE;
        }
306

307
308
309
310
311
        long_ = (char)(PYGLIB_PyBytes_AsString (py_arg)[0]);
    } else if (PyNumber_Check (py_arg)) {
        py_long = PYGLIB_PyNumber_Long (py_arg);
        if (!py_long)
            return FALSE;
312

313
314
315
316
317
318
319
320
321
322
323
        long_ = PYGLIB_PyLong_AsLong (py_long);
        Py_DECREF (py_long);

        if (PyErr_Occurred ()) {
            PyErr_Clear ();
            PyErr_Format (PyExc_ValueError, "%ld not in range %d to %d", long_, -128, 127);
            return FALSE;
        }
    } else {
        PyErr_Format (PyExc_TypeError, "Must be number or single byte string, not %s",
                      py_arg->ob_type->tp_name);
324
        return FALSE;
325
    }
326
327
328
329
330
331

    if (long_ < -128 || long_ > 127) {
        PyErr_Format (PyExc_ValueError, "%ld not in range %d to %d", long_, -128, 127);
        return FALSE;
    }

332
    arg->v_int8 = long_;
333
334
335
336
337

    return TRUE;
}

gboolean
338
339
340
341
342
_pygi_marshal_from_py_uint8 (PyGIInvokeState   *state,
                             PyGICallableCache *callable_cache,
                             PyGIArgCache      *arg_cache,
                             PyObject          *py_arg,
                             GIArgument        *arg)
343
344
345
{
    unsigned long long_;

346
    if (PYGLIB_PyBytes_Check (py_arg)) {
347

348
        if (PYGLIB_PyBytes_Size (py_arg) != 1) {
349
350
351
352
            PyErr_Format (PyExc_TypeError, "Must be a single character");
            return FALSE;
        }

353
        long_ = (unsigned char)(PYGLIB_PyBytes_AsString (py_arg)[0]);
354

355
    } else if (PyNumber_Check (py_arg)) {
356
        PyObject *py_long;
357
        py_long = PYGLIB_PyNumber_Long (py_arg);
358
359
360
        if (!py_long)
            return FALSE;

361
362
        long_ = PYGLIB_PyLong_AsLong (py_long);
        Py_DECREF (py_long);
363

364
365
366
367
        if (PyErr_Occurred ()) {
            PyErr_Clear();

            PyErr_Format (PyExc_ValueError, "%ld not in range %d to %d", long_, 0, 255);
368
            return FALSE;
369
        }
370
371
372
373
374
375
376
377
378
379
380
    } else {
        PyErr_Format (PyExc_TypeError, "Must be number or single byte string, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

    if (long_ < 0 || long_ > 255) {
        PyErr_Format (PyExc_ValueError, "%ld not in range %d to %d", long_, 0, 255);
        return FALSE;
    }

381
    arg->v_uint8 = long_;
382
383
384
385
386

    return TRUE;
}

gboolean
387
388
389
390
391
_pygi_marshal_from_py_int16 (PyGIInvokeState   *state,
                             PyGICallableCache *callable_cache,
                             PyGIArgCache      *arg_cache,
                             PyObject          *py_arg,
                             GIArgument        *arg)
392
393
394
395
{
    PyObject *py_long;
    long long_;

396
    if (!PyNumber_Check (py_arg)) {
397
398
399
400
401
        PyErr_Format (PyExc_TypeError, "Must be number, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

402
    py_long = PYGLIB_PyNumber_Long (py_arg);
403
404
405
    if (!py_long)
        return FALSE;

406
407
    long_ = PYGLIB_PyLong_AsLong (py_long);
    Py_DECREF (py_long);
408

409
410
411
    if (PyErr_Occurred ()) {
        PyErr_Clear ();
        PyErr_Format (PyExc_ValueError, "%ld not in range %d to %d", long_, -32768, 32767);
412
        return FALSE;
413
    }
414
415
416
417
418
419

    if (long_ < -32768 || long_ > 32767) {
        PyErr_Format (PyExc_ValueError, "%ld not in range %d to %d", long_, -32768, 32767);
        return FALSE;
    }

420
    arg->v_int16 = long_;
421
422
423
424
425

    return TRUE;
}

gboolean
426
427
428
429
430
_pygi_marshal_from_py_uint16 (PyGIInvokeState   *state,
                              PyGICallableCache *callable_cache,
                              PyGIArgCache      *arg_cache,
                              PyObject          *py_arg,
                              GIArgument        *arg)
431
432
433
434
{
    PyObject *py_long;
    long long_;

435
    if (!PyNumber_Check (py_arg)) {
436
437
438
439
440
        PyErr_Format (PyExc_TypeError, "Must be number, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

441
    py_long = PYGLIB_PyNumber_Long (py_arg);
442
443
444
    if (!py_long)
        return FALSE;

445
446
    long_ = PYGLIB_PyLong_AsLong (py_long);
    Py_DECREF (py_long);
447

448
449
    if (PyErr_Occurred ()) {
        PyErr_Clear ();
450
        PyErr_Format (PyExc_ValueError, "%ld not in range %d to %d", long_, 0, 65535);
451
        return FALSE;
452
    }
453
454

    if (long_ < 0 || long_ > 65535) {
455
        PyErr_Format (PyExc_ValueError, "%ld not in range %d to %d", long_, 0, 65535);
456
457
458
        return FALSE;
    }

459
    arg->v_uint16 = long_;
460
461
462
463
464

    return TRUE;
}

gboolean
465
466
467
468
469
_pygi_marshal_from_py_int32 (PyGIInvokeState   *state,
                             PyGICallableCache *callable_cache,
                             PyGIArgCache      *arg_cache,
                             PyObject          *py_arg,
                             GIArgument        *arg)
470
471
472
473
{
    PyObject *py_long;
    long long_;

474
    if (!PyNumber_Check (py_arg)) {
475
476
477
478
479
        PyErr_Format (PyExc_TypeError, "Must be number, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

480
    py_long = PYGLIB_PyNumber_Long (py_arg);
481
482
483
    if (!py_long)
        return FALSE;

484
485
    long_ = PYGLIB_PyLong_AsLong (py_long);
    Py_DECREF (py_long);
486

487
488
489
    if (PyErr_Occurred ()) {
        PyErr_Clear();
        PyErr_Format (PyExc_ValueError, "%ld not in range %d to %d", long_, G_MININT32, G_MAXINT32);
490
        return FALSE;
491
    }
492
493
494
495
496
497

    if (long_ < G_MININT32 || long_ > G_MAXINT32) {
        PyErr_Format (PyExc_ValueError, "%ld not in range %d to %d", long_, G_MININT32, G_MAXINT32);
        return FALSE;
    }

498
    arg->v_int32 = long_;
499
500
501
502
503

    return TRUE;
}

gboolean
504
505
506
507
508
_pygi_marshal_from_py_uint32 (PyGIInvokeState   *state,
                              PyGICallableCache *callable_cache,
                              PyGIArgCache      *arg_cache,
                              PyObject          *py_arg,
                              GIArgument        *arg)
509
510
511
512
{
    PyObject *py_long;
    long long long_;

513
    if (!PyNumber_Check (py_arg)) {
514
515
516
517
518
        PyErr_Format (PyExc_TypeError, "Must be number, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

519
    py_long = PYGLIB_PyNumber_Long (py_arg);
520
521
522
523
524
525
526
527
    if (!py_long)
        return FALSE;

#if PY_VERSION_HEX < 0x03000000
    if (PyInt_Check (py_long))
        long_ = PyInt_AsLong (py_long);
    else
#endif
528
        long_ = PyLong_AsLongLong (py_long);
529

530
    Py_DECREF (py_long);
531

532
533
    if (PyErr_Occurred ()) {
        PyErr_Clear ();
534
        PyErr_Format (PyExc_ValueError, "%lld not in range %i to %u", long_, 0, G_MAXUINT32);
535
        return FALSE;
536
    }
537
538

    if (long_ < 0 || long_ > G_MAXUINT32) {
539
        PyErr_Format (PyExc_ValueError, "%lld not in range %i to %u", long_, 0, G_MAXUINT32);
540
541
542
        return FALSE;
    }

543
    arg->v_uint32 = long_;
544
545
546
547
548

    return TRUE;
}

gboolean
549
550
551
552
553
_pygi_marshal_from_py_int64 (PyGIInvokeState   *state,
                             PyGICallableCache *callable_cache,
                             PyGIArgCache      *arg_cache,
                             PyObject          *py_arg,
                             GIArgument        *arg)
554
555
{
    PyObject *py_long;
556
    gint64 long_;
557

558
    if (!PyNumber_Check (py_arg)) {
559
560
561
562
563
        PyErr_Format (PyExc_TypeError, "Must be number, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

564
    py_long = PYGLIB_PyNumber_Long (py_arg);
565
566
567
568
569
    if (!py_long)
        return FALSE;

#if PY_VERSION_HEX < 0x03000000
    if (PyInt_Check (py_long))
570
        long_ = (gint64) PyInt_AS_LONG (py_long);
571
572
    else
#endif
573
        long_ = (gint64) PyLong_AsLongLong (py_long);
574

575
    Py_DECREF (py_long);
576

577
    if (PyErr_Occurred ()) {
578
579
        /* OverflowError occured but range errors should be returned as ValueError */
        char *long_str;
580
581
582
583
584
        PyObject *py_str;

        PyErr_Clear ();

        py_str = PyObject_Str (py_long);
585

586
587
        if (PyUnicode_Check (py_str)) {
            PyObject *py_bytes = PyUnicode_AsUTF8String (py_str);
588
589
            Py_DECREF (py_str);

590
591
592
            if (py_bytes == NULL)
                return FALSE;

593
            long_str = g_strdup (PYGLIB_PyBytes_AsString (py_bytes));
594
            if (long_str == NULL) {
595
                PyErr_NoMemory ();
596
597
598
                return FALSE;
            }

599
            Py_DECREF (py_bytes);
600
        } else {
601
            long_str = g_strdup (PYGLIB_PyBytes_AsString(py_str));
602
            Py_DECREF (py_str);
603
604
        }

605
606
        PyErr_Format (PyExc_ValueError, "%s not in range %lld to %lld",
                      long_str, (long long) G_MININT64, (long long) G_MAXINT64);
607

608
        g_free (long_str);
609
610
611
612
613
614
615
616
617
        return FALSE;
    }

    arg->v_int64 = long_;

    return TRUE;
}

gboolean
618
619
620
621
622
_pygi_marshal_from_py_uint64 (PyGIInvokeState   *state,
                              PyGICallableCache *callable_cache,
                              PyGIArgCache      *arg_cache,
                              PyObject          *py_arg,
                              GIArgument        *arg)
623
624
625
626
{
    PyObject *py_long;
    guint64 ulong_;

627
    if (!PyNumber_Check (py_arg)) {
628
629
630
631
632
        PyErr_Format (PyExc_TypeError, "Must be number, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

633
    py_long = PYGLIB_PyNumber_Long (py_arg);
634
635
636
637
638
    if (!py_long)
        return FALSE;

#if PY_VERSION_HEX < 0x03000000
    if (PyInt_Check (py_long)) {
639
640
        long long_ =  PyInt_AsLong (py_long);
        if (long_ < 0 || long_ > G_MAXUINT64) {
641
642
            PyErr_Format (PyExc_ValueError, "%" G_GUINT64_FORMAT " not in range %d to %" G_GUINT64_FORMAT,
                          (gint64) long_, 0, G_MAXUINT64);
643
644
            return FALSE;
        }
645
        ulong_ = (guint64) long_;
646
647
    } else
#endif
648
        ulong_ = PyLong_AsUnsignedLongLong (py_long);
649

650
    Py_DECREF (py_long);
651

652
    if (PyErr_Occurred ()) {
653
654
        /* OverflowError occured but range errors should be returned as ValueError */
        char *long_str;
655
656
657
658
659
        PyObject *py_str;

        PyErr_Clear ();

        py_str = PyObject_Str (py_long);
660

661
662
        if (PyUnicode_Check (py_str)) {
            PyObject *py_bytes = PyUnicode_AsUTF8String (py_str);
663
664
            Py_DECREF (py_str);

665
666
667
            if (py_bytes == NULL)
                return FALSE;

668
            long_str = g_strdup (PYGLIB_PyBytes_AsString (py_bytes));
669
            if (long_str == NULL) {
670
                PyErr_NoMemory ();
671
672
673
                return FALSE;
            }

674
            Py_DECREF (py_bytes);
675
        } else {
676
            long_str = g_strdup (PYGLIB_PyBytes_AsString (py_str));
677
            Py_DECREF (py_str);
678
679
        }

680
        PyErr_Format (PyExc_ValueError, "%s not in range %d to %" G_GUINT64_FORMAT,
681
                      long_str, 0, G_MAXUINT64);
682

683
        g_free (long_str);
684
685
686
687
        return FALSE;
    }

    if (ulong_ > G_MAXUINT64) {
688
        PyErr_Format (PyExc_ValueError, "%" G_GUINT64_FORMAT " not in range %d to %" G_GUINT64_FORMAT, ulong_, 0, G_MAXUINT64);
689
690
691
692
693
694
695
696
        return FALSE;
    }

    arg->v_uint64 = ulong_;

    return TRUE;
}

697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
static gboolean
check_valid_double (double x, double min, double max)
{
    char buf[100];

    if ((x < min || x > max) && x != INFINITY && x != -INFINITY && x != NAN) {
        if (PyErr_Occurred())
            PyErr_Clear ();

        /* we need this as PyErr_Format() does not support float types */
        snprintf (buf, sizeof (buf), "%g not in range %g to %g", x, min, max);
        PyErr_SetString (PyExc_ValueError, buf);
        return FALSE;
    }
    return TRUE;
}

714
715
static gboolean
_pygi_py_arg_to_double (PyObject *py_arg, double *double_)
716
717
718
{
    PyObject *py_float;

719
    if (!PyNumber_Check (py_arg)) {
720
721
722
723
724
        PyErr_Format (PyExc_TypeError, "Must be number, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

725
    py_float = PyNumber_Float (py_arg);
726
727
728
    if (!py_float)
        return FALSE;

729
    *double_ = PyFloat_AsDouble (py_float);
730
    Py_DECREF (py_float);
731

732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747

    return TRUE;
}

gboolean
_pygi_marshal_from_py_float (PyGIInvokeState   *state,
                             PyGICallableCache *callable_cache,
                             PyGIArgCache      *arg_cache,
                             PyObject          *py_arg,
                             GIArgument        *arg)
{
    double double_;

    if (!_pygi_py_arg_to_double (py_arg, &double_))
        return FALSE;

748
    if (PyErr_Occurred () || !check_valid_double (double_, -G_MAXFLOAT, G_MAXFLOAT))
749
750
751
752
753
754
755
        return FALSE;

    arg->v_float = double_;
    return TRUE;
}

gboolean
756
757
758
759
760
_pygi_marshal_from_py_double (PyGIInvokeState   *state,
                              PyGICallableCache *callable_cache,
                              PyGIArgCache      *arg_cache,
                              PyObject          *py_arg,
                              GIArgument        *arg)
761
762
763
{
    double double_;

764
    if (!_pygi_py_arg_to_double (py_arg, &double_))
765
766
        return FALSE;

767
    if (PyErr_Occurred () || !check_valid_double (double_, -G_MAXDOUBLE, G_MAXDOUBLE))
768
769
770
771
772
773
774
        return FALSE;

    arg->v_double = double_;
    return TRUE;
}

gboolean
775
776
777
778
779
_pygi_marshal_from_py_unichar (PyGIInvokeState   *state,
                               PyGICallableCache *callable_cache,
                               PyGIArgCache      *arg_cache,
                               PyObject          *py_arg,
                               GIArgument        *arg)
780
781
782
783
{
    Py_ssize_t size;
    gchar *string_;

784
785
786
787
788
    if (py_arg == Py_None) {
        arg->v_uint32 = 0;
        return FALSE;
    }

789
790
791
792
    if (PyUnicode_Check (py_arg)) {
       PyObject *py_bytes;

       size = PyUnicode_GET_SIZE (py_arg);
793
       py_bytes = PyUnicode_AsUTF8String (py_arg);
794
795
796
       if (!py_bytes)
           return FALSE;

Martin Pitt's avatar
Martin Pitt committed
797
       string_ = g_strdup(PYGLIB_PyBytes_AsString (py_bytes));
798
       Py_DECREF (py_bytes);
799
800
801
802
803
804
805
806

#if PY_VERSION_HEX < 0x03000000
    } else if (PyString_Check (py_arg)) {
       PyObject *pyuni = PyUnicode_FromEncodedObject (py_arg, "UTF-8", "strict");
       if (!pyuni)
           return FALSE;

       size = PyUnicode_GET_SIZE (pyuni);
807
808
       string_ = g_strdup (PyString_AsString(py_arg));
       Py_DECREF (pyuni);
809
810
811
812
813
814
815
816
#endif
    } else {
       PyErr_Format (PyExc_TypeError, "Must be string, not %s",
                     py_arg->ob_type->tp_name);
       return FALSE;
    }

    if (size != 1) {
817
818
       PyErr_Format (PyExc_TypeError, "Must be a one character string, not %lld characters",
                     (long long) size);
819
       g_free (string_);
820
821
822
       return FALSE;
    }

823
824
    arg->v_uint32 = g_utf8_get_char (string_);
    g_free (string_);
825
826
827

    return TRUE;
}
828

829
gboolean
830
831
832
833
834
_pygi_marshal_from_py_gtype (PyGIInvokeState   *state,
                             PyGICallableCache *callable_cache,
                             PyGIArgCache      *arg_cache,
                             PyObject          *py_arg,
                             GIArgument        *arg)
835
836
837
838
839
840
841
842
843
844
845
846
847
{
    long type_ = pyg_type_from_object (py_arg);

    if (type_ == 0) {
        PyErr_Format (PyExc_TypeError, "Must be gobject.GType, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

    arg->v_long = type_;
    return TRUE;
}
gboolean
848
849
850
851
852
_pygi_marshal_from_py_utf8 (PyGIInvokeState   *state,
                            PyGICallableCache *callable_cache,
                            PyGIArgCache      *arg_cache,
                            PyObject          *py_arg,
                            GIArgument        *arg)
853
854
855
856
857
858
859
860
{
    gchar *string_;

    if (py_arg == Py_None) {
        arg->v_pointer = NULL;
        return TRUE;
    }

861
    if (PyUnicode_Check (py_arg)) {
862
863
864
865
        PyObject *pystr_obj = PyUnicode_AsUTF8String (py_arg);
        if (!pystr_obj)
            return FALSE;

866
867
        string_ = g_strdup (PYGLIB_PyBytes_AsString (pystr_obj));
        Py_DECREF (pystr_obj);
868
869
    }
#if PY_VERSION_HEX < 0x03000000
870
871
    else if (PyString_Check (py_arg)) {
        string_ = g_strdup (PyString_AsString (py_arg));
872
873
874
875
876
877
878
879
880
881
882
883
884
    }
#endif
    else {
        PyErr_Format (PyExc_TypeError, "Must be string, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

    arg->v_string = string_;
    return TRUE;
}

gboolean
885
886
887
888
889
_pygi_marshal_from_py_filename (PyGIInvokeState   *state,
                                PyGICallableCache *callable_cache,
                                PyGIArgCache      *arg_cache,
                                PyObject          *py_arg,
                                GIArgument        *arg)
890
891
892
893
{
    gchar *string_;
    GError *error = NULL;

894
    if (PyUnicode_Check (py_arg)) {
895
896
897
898
        PyObject *pystr_obj = PyUnicode_AsUTF8String (py_arg);
        if (!pystr_obj)
            return FALSE;

899
900
        string_ = g_strdup (PYGLIB_PyBytes_AsString (pystr_obj));
        Py_DECREF (pystr_obj);
901
902
    }
#if PY_VERSION_HEX < 0x03000000
903
904
    else if (PyString_Check (py_arg)) {
        string_ = g_strdup (PyString_AsString (py_arg));
905
906
907
908
909
910
911
912
913
    }
#endif
    else {
        PyErr_Format (PyExc_TypeError, "Must be string, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

    arg->v_string = g_filename_from_utf8 (string_, -1, NULL, NULL, &error);
914
    g_free (string_);
915
916
917

    if (arg->v_string == NULL) {
        PyErr_SetString (PyExc_Exception, error->message);
918
        g_error_free (error);
919
920
921
922
923
924
925
926
        /* TODO: Convert the error to an exception. */
        return FALSE;
    }

    return TRUE;
}

gboolean
927
928
929
930
931
_pygi_marshal_from_py_array (PyGIInvokeState   *state,
                             PyGICallableCache *callable_cache,
                             PyGIArgCache      *arg_cache,
                             PyObject          *py_arg,
                             GIArgument        *arg)
932
{
933
    PyGIMarshalFromPyFunc from_py_marshaller;
934
    int i = 0;
935
    Py_ssize_t length;
936
    gssize item_size;
937
    gboolean is_ptr_array;
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
    GArray *array_ = NULL;
    PyGISequenceCache *sequence_cache = (PyGISequenceCache *)arg_cache;


    if (py_arg == Py_None) {
        arg->v_pointer = NULL;
        return TRUE;
    }

    if (!PySequence_Check (py_arg)) {
        PyErr_Format (PyExc_TypeError, "Must be sequence, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

    length = PySequence_Length (py_arg);
    if (length < 0)
        return FALSE;

    if (sequence_cache->fixed_size >= 0 &&
        sequence_cache->fixed_size != length) {
        PyErr_Format (PyExc_ValueError, "Must contain %zd items, not %zd",
                      sequence_cache->fixed_size, length);

        return FALSE;
    }

965
    item_size = sequence_cache->item_size;
966
967
968
969
970
971
    is_ptr_array = (sequence_cache->array_type == GI_ARRAY_TYPE_PTR_ARRAY);
    if (is_ptr_array) {
        array_ = (GArray *)g_ptr_array_new ();
    } else {
        array_ = g_array_sized_new (sequence_cache->is_zero_terminated,
                                    FALSE,
972
                                    item_size,
973
974
                                    length);
    }
975
976

    if (array_ == NULL) {
977
        PyErr_NoMemory ();
978
979
980
981
        return FALSE;
    }

    if (sequence_cache->item_cache->type_tag == GI_TYPE_TAG_UINT8 &&
982
983
        PYGLIB_PyBytes_Check (py_arg)) {
        memcpy(array_->data, PYGLIB_PyBytes_AsString (py_arg), length);
Martin Pitt's avatar
Martin Pitt committed
984
        array_->len = length;
985
986
987
988
989
        if (sequence_cache->is_zero_terminated) {
            /* If array_ has been created with zero_termination, space for the
             * terminator is properly allocated, so we're not off-by-one here. */
            array_->data[length] = '\0';
        }
990
991
992
        goto array_success;
    }

993
    from_py_marshaller = sequence_cache->item_cache->from_py_marshaller;
994
995
996
997
998
999
    for (i = 0; i < length; i++) {
        GIArgument item;
        PyObject *py_item = PySequence_GetItem (py_arg, i);
        if (py_item == NULL)
            goto err;

1000
1001
1002
1003
1004
        if (!from_py_marshaller ( state,
                                  callable_cache,
                                  sequence_cache->item_cache,
                                  py_item,
                                 &item))
1005
1006
            goto err;

1007
1008
1009
1010
        /* FIXME: it is much more efficent to have seperate marshaller
         *        for ptr arrays than doing the evaluation
         *        and casting each loop iteration
         */
1011
        if (is_ptr_array) {
1012
            g_ptr_array_add((GPtrArray *)array_, item.v_pointer);
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
        } else if (sequence_cache->item_cache->type_tag == GI_TYPE_TAG_INTERFACE) {
            PyGIInterfaceCache *item_iface_cache = (PyGIInterfaceCache *) sequence_cache->item_cache;
            GIBaseInfo *base_info = (GIBaseInfo *) item_iface_cache->interface_info;
            GIInfoType info_type = g_base_info_get_type (base_info);

            switch (info_type) {
                case GI_INFO_TYPE_UNION:
                case GI_INFO_TYPE_STRUCT:
                {
                    PyGIArgCache *item_arg_cache = (PyGIArgCache *)item_iface_cache;
                    PyGIMarshalCleanupFunc from_py_cleanup = item_arg_cache->from_py_cleanup;
                    gboolean is_boxed = g_type_is_a (item_iface_cache->g_type, G_TYPE_BOXED);
                    gboolean is_gvalue = item_iface_cache->g_type == G_TYPE_VALUE;
1026
1027
1028
1029
1030
1031
1032
                    gboolean is_gvariant = item_iface_cache->g_type == G_TYPE_VARIANT;
                    
                    if (is_gvariant) {
                        /* Item size will always be that of a pointer,
                         * since GVariants are opaque hence always passed by ref */
                        g_assert (item_size == sizeof (item.v_pointer));
                        g_array_insert_val (array_, i, item.v_pointer);
1033
1034
1035
1036
1037
1038
1039
                    } else if (is_gvalue) {
                        GValue* dest = (GValue*) (array_->data + (i * item_size));
                        memset (dest, 0, item_size);
                        if (item.v_pointer != NULL) {
                            g_value_init (dest, G_VALUE_TYPE ((GValue*) item.v_pointer));
                            g_value_copy ((GValue*) item.v_pointer, dest);
                        }
Martin Pitt's avatar
Martin Pitt committed
1040
1041
1042
                        /* we free the original copy already, the new one is a plain struct
                         * in an array. _pygi_marshal_cleanup_from_py_array() does not free it again */
                        if (from_py_cleanup)
1043
1044
                            from_py_cleanup (state, item_arg_cache, item.v_pointer, TRUE);
                    } else if (!is_boxed) {
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
                        /* HACK: Gdk.Atom is merely an integer wrapped in a pointer,
                         * so we must not dereference it; just copy the pointer
                         * value, and don't attempt to free it. TODO: find out
                         * if there are other data types with similar behaviour
                         * and generalize. */
                        if (g_strcmp0 (item_iface_cache->type_name, "Gdk.Atom") == 0) {
                            g_assert (item_size == sizeof (item.v_pointer));
                            memcpy (array_->data + (i * item_size), &item.v_pointer, item_size);
                        } else {
                            memcpy (array_->data + (i * item_size), item.v_pointer, item_size);

                            if (from_py_cleanup)
                                from_py_cleanup (state, item_arg_cache, item.v_pointer, TRUE);
                        }
1059
1060
1061
1062
1063
1064
                    } else if (is_boxed && !item_iface_cache->arg_cache.is_pointer) {
                        /* The array elements are not expected to be pointers, but the
                         * elements obtained are boxed pointers themselves, so insert
                         * the pointed to data.
                         */
                        g_array_insert_vals (array_, i, item.v_pointer, 1);
1065
1066
1067
1068
1069
1070
1071
1072
1073
                    } else {
                        g_array_insert_val (array_, i, item);
                    }
                    break;
                }
                default:
                    g_array_insert_val (array_, i, item);
            }
        } else {
1074
            g_array_insert_val (array_, i, item);
1075
        }
1076
1077
        continue;
err:
1078
        if (sequence_cache->item_cache->from_py_cleanup != NULL) {
1079
1080
            gsize j;
            PyGIMarshalCleanupFunc cleanup_func =
1081
                sequence_cache->item_cache->from_py_cleanup;
1082
1083
1084
1085
1086
1087
1088

            for(j = 0; j < i; j++) {
                cleanup_func (state,
                              sequence_cache->item_cache,
                              g_array_index (array_, gpointer, j),
                              TRUE);
            }
1089
1090
        }

1091
        if (is_ptr_array)
1092
            g_ptr_array_free ( ( GPtrArray *)array_, TRUE);
1093
1094
        else
            g_array_free (array_, TRUE);
1095
1096
1097
1098
1099
1100
        _PyGI_ERROR_PREFIX ("Item %i: ", i);
        return FALSE;
    }

array_success:
    if (sequence_cache->len_arg_index >= 0) {
1101
1102
        /* we have an child arg to handle */
        PyGIArgCache *child_cache =
1103
            callable_cache->args_cache[sequence_cache->len_arg_index];
1104

1105
        if (child_cache->direction == PYGI_DIRECTION_BIDIRECTIONAL) {
1106
            gint *len_arg = (gint *)state->in_args[child_cache->c_arg_index].v_pointer;
1107
            /* if we are not setup yet just set the in arg */
David Malcolm's avatar
David Malcolm committed
1108
1109
1110
1111
1112
1113
1114
            if (len_arg == NULL) {
                if (!gi_argument_from_py_ssize_t (&state->in_args[child_cache->c_arg_index],
                                                  length,
                                                  child_cache->type_tag)) {
                    goto err;
                }
            } else {
1115
                *len_arg = length;
David Malcolm's avatar
David Malcolm committed
1116
            }
1117
        } else {
David Malcolm's avatar
David Malcolm committed
1118
1119
1120
1121
1122
            if (!gi_argument_from_py_ssize_t (&state->in_args[child_cache->c_arg_index],
                                              length,
                                              child_cache->type_tag)) {
                goto err;
            }
1123
1124
1125
1126
1127
        }
    }

    if (sequence_cache->array_type == GI_ARRAY_TYPE_C) {
        arg->v_pointer = array_->data;
1128
        g_array_free (array_, FALSE);
Martin Pitt's avatar
Martin Pitt committed
1129
1130
1131
1132
        /* remember the originally allocated array in args_data, as args and
         * in_args get changed for (inout) arguments */
        if (arg_cache->transfer == GI_TRANSFER_NOTHING)
            state->args_data[arg_cache->c_arg_index] = arg->v_pointer;
1133
1134
1135
1136
1137
1138
1139
1140
    } else {
        arg->v_pointer = array_;
    }

    return TRUE;
}

gboolean
1141
1142
1143
1144
1145
_pygi_marshal_from_py_glist (PyGIInvokeState   *state,
                             PyGICallableCache *callable_cache,
                             PyGIArgCache      *arg_cache,
                             PyObject          *py_arg,
                             GIArgument        *arg)
1146
{
1147
    PyGIMarshalFromPyFunc from_py_marshaller;
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
    int i;
    Py_ssize_t length;
    GList *list_ = NULL;
    PyGISequenceCache *sequence_cache = (PyGISequenceCache *)arg_cache;


    if (py_arg == Py_None) {
        arg->v_pointer = NULL;
        return TRUE;
    }

    if (!PySequence_Check (py_arg)) {
        PyErr_Format (PyExc_TypeError, "Must be sequence, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

1165
    length = PySequence_Length (py_arg);
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
    if (length < 0)
        return FALSE;

    if (sequence_cache->fixed_size >= 0 &&
        sequence_cache->fixed_size != length) {
        PyErr_Format (PyExc_ValueError, "Must contain %zd items, not %zd",
                      sequence_cache->fixed_size, length);

        return FALSE;
    }

1177
    from_py_marshaller = sequence_cache->item_cache->from_py_marshaller;
1178
1179
1180
1181
1182
1183
    for (i = 0; i < length; i++) {
        GIArgument item;
        PyObject *py_item = PySequence_GetItem (py_arg, i);
        if (py_item == NULL)
            goto err;

1184
1185
1186
1187
1188
        if (!from_py_marshaller ( state,
                                  callable_cache,
                                  sequence_cache->item_cache,
                                  py_item,
                                 &item))
1189
1190
            goto err;

1191
        list_ = g_list_prepend (list_, _pygi_arg_to_hash_pointer (&item, sequence_cache->item_cache->type_tag));
1192
1193
        continue;
err:
John (J5) Palmieri's avatar
John (J5) Palmieri committed
1194
        /* FIXME: clean up list
1195
1196
        if (sequence_cache->item_cache->from_py_cleanup != NULL) {
            PyGIMarshalCleanupFunc cleanup = sequence_cache->item_cache->from_py_cleanup;
1197
        }
John (J5) Palmieri's avatar
John (J5) Palmieri committed
1198
        */
1199
        g_list_free (list_);
1200
1201
1202
1203
        _PyGI_ERROR_PREFIX ("Item %i: ", i);
        return FALSE;
    }

1204
    arg->v_pointer = g_list_reverse (list_);
1205
1206
1207
1208
    return TRUE;
}

gboolean
1209
1210
1211
1212
1213
_pygi_marshal_from_py_gslist (PyGIInvokeState   *state,
                              PyGICallableCache *callable_cache,
                              PyGIArgCache      *arg_cache,
                              PyObject          *py_arg,
                              GIArgument        *arg)
1214
{
1215
    PyGIMarshalFromPyFunc from_py_marshaller;
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
    int i;
    Py_ssize_t length;
    GSList *list_ = NULL;
    PyGISequenceCache *sequence_cache = (PyGISequenceCache *)arg_cache;

    if (py_arg == Py_None) {
        arg->v_pointer = NULL;
        return TRUE;
    }

    if (!PySequence_Check (py_arg)) {
        PyErr_Format (PyExc_TypeError, "Must be sequence, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

1232
    length = PySequence_Length (py_arg);
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
    if (length < 0)
        return FALSE;

    if (sequence_cache->fixed_size >= 0 &&
        sequence_cache->fixed_size != length) {
        PyErr_Format (PyExc_ValueError, "Must contain %zd items, not %zd",
                      sequence_cache->fixed_size, length);

        return FALSE;
    }

1244
    from_py_marshaller = sequence_cache->item_cache->from_py_marshaller;
1245
1246
1247
1248
1249
1250
    for (i = 0; i < length; i++) {
        GIArgument item;
        PyObject *py_item = PySequence_GetItem (py_arg, i);
        if (py_item == NULL)
            goto err;

1251
        if (!from_py_marshaller ( state,
1252
1253
1254
1255
                             callable_cache,
                             sequence_cache->item_cache,
                             py_item,
                            &item))
1256
1257
            goto err;

1258
        list_ = g_slist_prepend (list_, _pygi_arg_to_hash_pointer (&item, sequence_cache->item_cache->type_tag));
1259
1260
        continue;
err:
John (J5) Palmieri's avatar
John (J5) Palmieri committed
1261
        /* FIXME: Clean up list
1262
1263
        if (sequence_cache->item_cache->from_py_cleanup != NULL) {
            PyGIMarshalCleanupFunc cleanup = sequence_cache->item_cache->from_py_cleanup;
1264
        }
John (J5) Palmieri's avatar
John (J5) Palmieri committed
1265
        */
1266

1267
        g_slist_free (list_);
1268
1269
1270
1271
        _PyGI_ERROR_PREFIX ("Item %i: ", i);
        return FALSE;
    }

1272
    arg->v_pointer = g_slist_reverse (list_);
1273
1274
1275
1276
    return TRUE;
}

gboolean
1277
1278
1279
1280
1281
_pygi_marshal_from_py_ghash (PyGIInvokeState   *state,
                             PyGICallableCache *callable_cache,
                             PyGIArgCache      *arg_cache,
                             PyObject          *py_arg,
                             GIArgument        *arg)
1282
{
1283
1284
    PyGIMarshalFromPyFunc key_from_py_marshaller;
    PyGIMarshalFromPyFunc value_from_py_marshaller;
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300

    int i;
    Py_ssize_t length;
    PyObject *py_keys, *py_values;

    GHashFunc hash_func;
    GEqualFunc equal_func;

    GHashTable *hash_ = NULL;
    PyGIHashCache *hash_cache = (PyGIHashCache *)arg_cache;

    if (py_arg == Py_None) {
        arg->v_pointer = NULL;
        return TRUE;
    }

1301
    py_keys = PyMapping_Keys (py_arg);
1302
1303
1304
1305
1306
1307
    if (py_keys == NULL) {
        PyErr_Format (PyExc_TypeError, "Must be mapping, not %s",
                      py_arg->ob_type->tp_name);
        return FALSE;
    }

1308
    length = PyMapping_Length (py_arg);
1309
    if (length < 0) {
1310
        Py_DECREF (py_keys);
1311
1312
1313
        return FALSE;
    }

1314
    py_values = PyMapping_Values (py_arg);
1315
    if (py_values == NULL) {
1316
        Py_DECREF