← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily-proposed

« back to all changes in this revision

Viewing changes to Externals/LibXML/python/types.c

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Externals/LibXML/python/types.c
 
1
/*
 
2
 * types.c: converter functions between the internal representation
 
3
 *          and the Python objects
 
4
 *
 
5
 * See Copyright for the status of this software.
 
6
 *
 
7
 * daniel@veillard.com
 
8
 */
 
9
#include "libxml_wrap.h"
 
10
#include <libxml/xpathInternals.h>
 
11
 
 
12
PyObject *
 
13
libxml_intWrap(int val)
 
14
{
 
15
    PyObject *ret;
 
16
 
 
17
#ifdef DEBUG
 
18
    printf("libxml_intWrap: val = %d\n", val);
 
19
#endif
 
20
    ret = PyInt_FromLong((long) val);
 
21
    return (ret);
 
22
}
 
23
 
 
24
PyObject *
 
25
libxml_longWrap(long val)
 
26
{
 
27
    PyObject *ret;
 
28
 
 
29
#ifdef DEBUG
 
30
    printf("libxml_longWrap: val = %ld\n", val);
 
31
#endif
 
32
    ret = PyInt_FromLong(val);
 
33
    return (ret);
 
34
}
 
35
 
 
36
PyObject *
 
37
libxml_doubleWrap(double val)
 
38
{
 
39
    PyObject *ret;
 
40
 
 
41
#ifdef DEBUG
 
42
    printf("libxml_doubleWrap: val = %f\n", val);
 
43
#endif
 
44
    ret = PyFloat_FromDouble((double) val);
 
45
    return (ret);
 
46
}
 
47
 
 
48
PyObject *
 
49
libxml_charPtrWrap(char *str)
 
50
{
 
51
    PyObject *ret;
 
52
 
 
53
#ifdef DEBUG
 
54
    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
 
55
#endif
 
56
    if (str == NULL) {
 
57
        Py_INCREF(Py_None);
 
58
        return (Py_None);
 
59
    }
 
60
    /* TODO: look at deallocation */
 
61
    ret = PyString_FromString(str);
 
62
    xmlFree(str);
 
63
    return (ret);
 
64
}
 
65
 
 
66
PyObject *
 
67
libxml_charPtrConstWrap(const char *str)
 
68
{
 
69
    PyObject *ret;
 
70
 
 
71
#ifdef DEBUG
 
72
    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
 
73
#endif
 
74
    if (str == NULL) {
 
75
        Py_INCREF(Py_None);
 
76
        return (Py_None);
 
77
    }
 
78
    /* TODO: look at deallocation */
 
79
    ret = PyString_FromString(str);
 
80
    return (ret);
 
81
}
 
82
 
 
83
PyObject *
 
84
libxml_xmlCharPtrWrap(xmlChar * str)
 
85
{
 
86
    PyObject *ret;
 
87
 
 
88
#ifdef DEBUG
 
89
    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
 
90
#endif
 
91
    if (str == NULL) {
 
92
        Py_INCREF(Py_None);
 
93
        return (Py_None);
 
94
    }
 
95
    /* TODO: look at deallocation */
 
96
    ret = PyString_FromString((char *) str);
 
97
    xmlFree(str);
 
98
    return (ret);
 
99
}
 
100
 
 
101
PyObject *
 
102
libxml_xmlCharPtrConstWrap(const xmlChar * str)
 
103
{
 
104
    PyObject *ret;
 
105
 
 
106
#ifdef DEBUG
 
107
    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
 
108
#endif
 
109
    if (str == NULL) {
 
110
        Py_INCREF(Py_None);
 
111
        return (Py_None);
 
112
    }
 
113
    /* TODO: look at deallocation */
 
114
    ret = PyString_FromString((char *) str);
 
115
    return (ret);
 
116
}
 
117
 
 
118
PyObject *
 
119
libxml_constcharPtrWrap(const char *str)
 
120
{
 
121
    PyObject *ret;
 
122
 
 
123
#ifdef DEBUG
 
124
    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
 
125
#endif
 
126
    if (str == NULL) {
 
127
        Py_INCREF(Py_None);
 
128
        return (Py_None);
 
129
    }
 
130
    /* TODO: look at deallocation */
 
131
    ret = PyString_FromString(str);
 
132
    return (ret);
 
133
}
 
134
 
 
135
PyObject *
 
136
libxml_constxmlCharPtrWrap(const xmlChar * str)
 
137
{
 
138
    PyObject *ret;
 
139
 
 
140
#ifdef DEBUG
 
141
    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
 
142
#endif
 
143
    if (str == NULL) {
 
144
        Py_INCREF(Py_None);
 
145
        return (Py_None);
 
146
    }
 
147
    /* TODO: look at deallocation */
 
148
    ret = PyString_FromString((char *) str);
 
149
    return (ret);
 
150
}
 
151
 
 
152
PyObject *
 
153
libxml_xmlDocPtrWrap(xmlDocPtr doc)
 
154
{
 
155
    PyObject *ret;
 
156
 
 
157
#ifdef DEBUG
 
158
    printf("libxml_xmlDocPtrWrap: doc = %p\n", doc);
 
159
#endif
 
160
    if (doc == NULL) {
 
161
        Py_INCREF(Py_None);
 
162
        return (Py_None);
 
163
    }
 
164
    /* TODO: look at deallocation */
 
165
    ret =
 
166
        PyCObject_FromVoidPtrAndDesc((void *) doc, (char *) "xmlDocPtr",
 
167
                                     NULL);
 
168
    return (ret);
 
169
}
 
170
 
 
171
PyObject *
 
172
libxml_xmlNodePtrWrap(xmlNodePtr node)
 
173
{
 
174
    PyObject *ret;
 
175
 
 
176
#ifdef DEBUG
 
177
    printf("libxml_xmlNodePtrWrap: node = %p\n", node);
 
178
#endif
 
179
    if (node == NULL) {
 
180
        Py_INCREF(Py_None);
 
181
        return (Py_None);
 
182
    }
 
183
    ret =
 
184
        PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "xmlNodePtr",
 
185
                                     NULL);
 
186
    return (ret);
 
187
}
 
188
 
 
189
PyObject *
 
190
libxml_xmlURIPtrWrap(xmlURIPtr uri)
 
191
{
 
192
    PyObject *ret;
 
193
 
 
194
#ifdef DEBUG
 
195
    printf("libxml_xmlURIPtrWrap: uri = %p\n", uri);
 
196
#endif
 
197
    if (uri == NULL) {
 
198
        Py_INCREF(Py_None);
 
199
        return (Py_None);
 
200
    }
 
201
    ret =
 
202
        PyCObject_FromVoidPtrAndDesc((void *) uri, (char *) "xmlURIPtr",
 
203
                                     NULL);
 
204
    return (ret);
 
205
}
 
206
 
 
207
PyObject *
 
208
libxml_xmlNsPtrWrap(xmlNsPtr ns)
 
209
{
 
210
    PyObject *ret;
 
211
 
 
212
#ifdef DEBUG
 
213
    printf("libxml_xmlNsPtrWrap: node = %p\n", ns);
 
214
#endif
 
215
    if (ns == NULL) {
 
216
        Py_INCREF(Py_None);
 
217
        return (Py_None);
 
218
    }
 
219
    ret =
 
220
        PyCObject_FromVoidPtrAndDesc((void *) ns, (char *) "xmlNsPtr",
 
221
                                     NULL);
 
222
    return (ret);
 
223
}
 
224
 
 
225
PyObject *
 
226
libxml_xmlAttrPtrWrap(xmlAttrPtr attr)
 
227
{
 
228
    PyObject *ret;
 
229
 
 
230
#ifdef DEBUG
 
231
    printf("libxml_xmlAttrNodePtrWrap: attr = %p\n", attr);
 
232
#endif
 
233
    if (attr == NULL) {
 
234
        Py_INCREF(Py_None);
 
235
        return (Py_None);
 
236
    }
 
237
    ret =
 
238
        PyCObject_FromVoidPtrAndDesc((void *) attr, (char *) "xmlAttrPtr",
 
239
                                     NULL);
 
240
    return (ret);
 
241
}
 
242
 
 
243
PyObject *
 
244
libxml_xmlAttributePtrWrap(xmlAttributePtr attr)
 
245
{
 
246
    PyObject *ret;
 
247
 
 
248
#ifdef DEBUG
 
249
    printf("libxml_xmlAttributePtrWrap: attr = %p\n", attr);
 
250
#endif
 
251
    if (attr == NULL) {
 
252
        Py_INCREF(Py_None);
 
253
        return (Py_None);
 
254
    }
 
255
    ret =
 
256
        PyCObject_FromVoidPtrAndDesc((void *) attr,
 
257
                                     (char *) "xmlAttributePtr", NULL);
 
258
    return (ret);
 
259
}
 
260
 
 
261
PyObject *
 
262
libxml_xmlElementPtrWrap(xmlElementPtr elem)
 
263
{
 
264
    PyObject *ret;
 
265
 
 
266
#ifdef DEBUG
 
267
    printf("libxml_xmlElementNodePtrWrap: elem = %p\n", elem);
 
268
#endif
 
269
    if (elem == NULL) {
 
270
        Py_INCREF(Py_None);
 
271
        return (Py_None);
 
272
    }
 
273
    ret =
 
274
        PyCObject_FromVoidPtrAndDesc((void *) elem,
 
275
                                     (char *) "xmlElementPtr", NULL);
 
276
    return (ret);
 
277
}
 
278
 
 
279
PyObject *
 
280
libxml_xmlXPathContextPtrWrap(xmlXPathContextPtr ctxt)
 
281
{
 
282
    PyObject *ret;
 
283
 
 
284
#ifdef DEBUG
 
285
    printf("libxml_xmlXPathContextPtrWrap: ctxt = %p\n", ctxt);
 
286
#endif
 
287
    if (ctxt == NULL) {
 
288
        Py_INCREF(Py_None);
 
289
        return (Py_None);
 
290
    }
 
291
    ret =
 
292
        PyCObject_FromVoidPtrAndDesc((void *) ctxt,
 
293
                                     (char *) "xmlXPathContextPtr", NULL);
 
294
    return (ret);
 
295
}
 
296
 
 
297
PyObject *
 
298
libxml_xmlXPathParserContextPtrWrap(xmlXPathParserContextPtr ctxt)
 
299
{
 
300
    PyObject *ret;
 
301
 
 
302
#ifdef DEBUG
 
303
    printf("libxml_xmlXPathParserContextPtrWrap: ctxt = %p\n", ctxt);
 
304
#endif
 
305
    if (ctxt == NULL) {
 
306
        Py_INCREF(Py_None);
 
307
        return (Py_None);
 
308
    }
 
309
    ret = PyCObject_FromVoidPtrAndDesc((void *) ctxt,
 
310
                                       (char *) "xmlXPathParserContextPtr",
 
311
                                       NULL);
 
312
    return (ret);
 
313
}
 
314
 
 
315
PyObject *
 
316
libxml_xmlParserCtxtPtrWrap(xmlParserCtxtPtr ctxt)
 
317
{
 
318
    PyObject *ret;
 
319
 
 
320
#ifdef DEBUG
 
321
    printf("libxml_xmlParserCtxtPtrWrap: ctxt = %p\n", ctxt);
 
322
#endif
 
323
    if (ctxt == NULL) {
 
324
        Py_INCREF(Py_None);
 
325
        return (Py_None);
 
326
    }
 
327
 
 
328
    ret =
 
329
        PyCObject_FromVoidPtrAndDesc((void *) ctxt,
 
330
                                     (char *) "xmlParserCtxtPtr", NULL);
 
331
    return (ret);
 
332
}
 
333
 
 
334
/**
 
335
 * libxml_xmlXPathDestructNsNode:
 
336
 * cobj: xmlNsPtr namespace node
 
337
 * desc: ignored string
 
338
 *
 
339
 * This function is called if and when a namespace node returned in
 
340
 * an XPath node set is to be destroyed. That's the only kind of
 
341
 * object returned in node set not directly linked to the original
 
342
 * xmlDoc document, see xmlXPathNodeSetDupNs.
 
343
 */
 
344
static void
 
345
libxml_xmlXPathDestructNsNode(void *cobj, void *desc ATTRIBUTE_UNUSED) {
 
346
#ifdef DEBUG
 
347
    fprintf(stderr, "libxml_xmlXPathDestructNsNode called %p\n", cobj);
 
348
#endif
 
349
    xmlXPathNodeSetFreeNs((xmlNsPtr) cobj);
 
350
}
 
351
 
 
352
PyObject *
 
353
libxml_xmlXPathObjectPtrWrap(xmlXPathObjectPtr obj)
 
354
{
 
355
    PyObject *ret;
 
356
 
 
357
#ifdef DEBUG
 
358
    printf("libxml_xmlXPathObjectPtrWrap: ctxt = %p\n", obj);
 
359
#endif
 
360
    if (obj == NULL) {
 
361
        Py_INCREF(Py_None);
 
362
        return (Py_None);
 
363
    }
 
364
    switch (obj->type) {
 
365
        case XPATH_XSLT_TREE: {
 
366
            if ((obj->nodesetval == NULL) ||
 
367
                (obj->nodesetval->nodeNr == 0) ||
 
368
                (obj->nodesetval->nodeTab == NULL)) {
 
369
                ret = PyList_New(0);
 
370
            } else {
 
371
                int i, len = 0;
 
372
                xmlNodePtr node;
 
373
 
 
374
                node = obj->nodesetval->nodeTab[0]->children;
 
375
                while (node != NULL) {
 
376
                    len++;
 
377
                    node = node->next;
 
378
                }
 
379
                ret = PyList_New(len);
 
380
                node = obj->nodesetval->nodeTab[0]->children;
 
381
                for (i = 0;i < len;i++) {
 
382
                    PyList_SetItem(ret, i, libxml_xmlNodePtrWrap(node));
 
383
                    node = node->next;
 
384
                }
 
385
            }
 
386
            /*
 
387
             * Return now, do not free the object passed down
 
388
             */
 
389
            return (ret);
 
390
        }
 
391
        case XPATH_NODESET:
 
392
            if ((obj->nodesetval == NULL)
 
393
                || (obj->nodesetval->nodeNr == 0)) {
 
394
                ret = PyList_New(0);
 
395
            } else {
 
396
                int i;
 
397
                xmlNodePtr node;
 
398
 
 
399
                ret = PyList_New(obj->nodesetval->nodeNr);
 
400
                for (i = 0; i < obj->nodesetval->nodeNr; i++) {
 
401
                    node = obj->nodesetval->nodeTab[i];
 
402
                    if (node->type == XML_NAMESPACE_DECL) {
 
403
                        PyObject *ns = 
 
404
                            PyCObject_FromVoidPtrAndDesc((void *) node,
 
405
                                     (char *) "xmlNsPtr",
 
406
                                     libxml_xmlXPathDestructNsNode);
 
407
                        PyList_SetItem(ret, i, ns);
 
408
                        /* make sure the xmlNsPtr is not destroyed now */
 
409
                        obj->nodesetval->nodeTab[i] = NULL;
 
410
                    } else {
 
411
                        PyList_SetItem(ret, i, libxml_xmlNodePtrWrap(node));
 
412
                    }
 
413
                }
 
414
            }
 
415
            break;
 
416
        case XPATH_BOOLEAN:
 
417
            ret = PyInt_FromLong((long) obj->boolval);
 
418
            break;
 
419
        case XPATH_NUMBER:
 
420
            ret = PyFloat_FromDouble(obj->floatval);
 
421
            break;
 
422
        case XPATH_STRING:
 
423
            ret = PyString_FromString((char *) obj->stringval);
 
424
            break;
 
425
        case XPATH_POINT:
 
426
        {
 
427
            PyObject *node;
 
428
            PyObject *indexIntoNode;
 
429
            PyObject *tuple;
 
430
 
 
431
            node = libxml_xmlNodePtrWrap(obj->user);
 
432
            indexIntoNode = PyInt_FromLong((long) obj->index);
 
433
 
 
434
            tuple = PyTuple_New(2);
 
435
            PyTuple_SetItem(tuple, 0, node);
 
436
            PyTuple_SetItem(tuple, 1, indexIntoNode);
 
437
 
 
438
            ret = tuple;
 
439
            break;
 
440
        }
 
441
        case XPATH_RANGE:
 
442
        {
 
443
            unsigned short bCollapsedRange;
 
444
 
 
445
            bCollapsedRange = ( (obj->user2 == NULL) ||
 
446
                                ((obj->user2 == obj->user) && (obj->index == obj->index2)) );
 
447
            if ( bCollapsedRange ) {
 
448
                PyObject *node;
 
449
                PyObject *indexIntoNode;
 
450
                PyObject *tuple;
 
451
                PyObject *list;
 
452
 
 
453
                list = PyList_New(1);
 
454
 
 
455
                node = libxml_xmlNodePtrWrap(obj->user);
 
456
                indexIntoNode = PyInt_FromLong((long) obj->index);
 
457
 
 
458
                tuple = PyTuple_New(2);
 
459
                PyTuple_SetItem(tuple, 0, node);
 
460
                PyTuple_SetItem(tuple, 1, indexIntoNode);
 
461
 
 
462
                PyList_SetItem(list, 0, tuple);
 
463
 
 
464
                ret = list;
 
465
            } else {
 
466
                PyObject *node;
 
467
                PyObject *indexIntoNode;
 
468
                PyObject *tuple;
 
469
                PyObject *list;
 
470
 
 
471
                list = PyList_New(2);
 
472
 
 
473
                node = libxml_xmlNodePtrWrap(obj->user);
 
474
                indexIntoNode = PyInt_FromLong((long) obj->index);
 
475
 
 
476
                tuple = PyTuple_New(2);
 
477
                PyTuple_SetItem(tuple, 0, node);
 
478
                PyTuple_SetItem(tuple, 1, indexIntoNode);
 
479
 
 
480
                PyList_SetItem(list, 0, tuple);
 
481
 
 
482
                node = libxml_xmlNodePtrWrap(obj->user2);
 
483
                indexIntoNode = PyInt_FromLong((long) obj->index2);
 
484
 
 
485
                tuple = PyTuple_New(2);
 
486
                PyTuple_SetItem(tuple, 0, node);
 
487
                PyTuple_SetItem(tuple, 1, indexIntoNode);
 
488
 
 
489
                PyList_SetItem(list, 1, tuple);
 
490
 
 
491
                ret = list;
 
492
            }
 
493
            break;
 
494
        }
 
495
        case XPATH_LOCATIONSET:
 
496
        {
 
497
            xmlLocationSetPtr set;
 
498
 
 
499
            set = obj->user;
 
500
            if ( set && set->locNr > 0 ) {
 
501
                int i;
 
502
                PyObject *list;
 
503
 
 
504
                list = PyList_New(set->locNr);
 
505
 
 
506
                for (i=0; i<set->locNr; i++) {
 
507
                    xmlXPathObjectPtr setobj;
 
508
                    PyObject *pyobj;
 
509
 
 
510
                    setobj = set->locTab[i]; /*xmlXPathObjectPtr setobj*/
 
511
 
 
512
                    pyobj = libxml_xmlXPathObjectPtrWrap(setobj);
 
513
                    /* xmlXPathFreeObject(setobj) is called */
 
514
                    set->locTab[i] = NULL;
 
515
 
 
516
                    PyList_SetItem(list, i, pyobj);
 
517
                }
 
518
                set->locNr = 0;
 
519
                ret = list;
 
520
            } else {
 
521
                Py_INCREF(Py_None);
 
522
                ret = Py_None;
 
523
            }
 
524
            break;
 
525
        }
 
526
        default:
 
527
#ifdef DEBUG
 
528
            printf("Unable to convert XPath object type %d\n", obj->type);
 
529
#endif
 
530
            Py_INCREF(Py_None);
 
531
            ret = Py_None;
 
532
    }
 
533
    xmlXPathFreeObject(obj);
 
534
    return (ret);
 
535
}
 
536
 
 
537
xmlXPathObjectPtr
 
538
libxml_xmlXPathObjectPtrConvert(PyObject * obj)
 
539
{
 
540
    xmlXPathObjectPtr ret = NULL;
 
541
 
 
542
#ifdef DEBUG
 
543
    printf("libxml_xmlXPathObjectPtrConvert: obj = %p\n", obj);
 
544
#endif
 
545
    if (obj == NULL) {
 
546
        return (NULL);
 
547
    }
 
548
    if PyFloat_Check
 
549
        (obj) {
 
550
        ret = xmlXPathNewFloat((double) PyFloat_AS_DOUBLE(obj));
 
551
 
 
552
    } else if PyInt_Check(obj) {
 
553
 
 
554
        ret = xmlXPathNewFloat((double) PyInt_AS_LONG(obj));
 
555
 
 
556
#ifdef PyBool_Check
 
557
    } else if PyBool_Check (obj) {
 
558
 
 
559
        if (obj == Py_True) {
 
560
          ret = xmlXPathNewBoolean(1);
 
561
        }
 
562
        else {
 
563
          ret = xmlXPathNewBoolean(0);
 
564
        }
 
565
#endif
 
566
    } else if PyString_Check
 
567
        (obj) {
 
568
        xmlChar *str;
 
569
 
 
570
        str = xmlStrndup((const xmlChar *) PyString_AS_STRING(obj),
 
571
                         PyString_GET_SIZE(obj));
 
572
        ret = xmlXPathWrapString(str);
 
573
    } else if PyList_Check
 
574
        (obj) {
 
575
        int i;
 
576
        PyObject *node;
 
577
        xmlNodePtr cur;
 
578
        xmlNodeSetPtr set;
 
579
 
 
580
        set = xmlXPathNodeSetCreate(NULL);
 
581
 
 
582
        for (i = 0; i < PyList_Size(obj); i++) {
 
583
            node = PyList_GetItem(obj, i);
 
584
            if ((node == NULL) || (node->ob_type == NULL))
 
585
                continue;
 
586
 
 
587
            cur = NULL;
 
588
            if (PyCObject_Check(node)) {
 
589
#ifdef DEBUG
 
590
                printf("Got a CObject\n");
 
591
#endif
 
592
                cur = PyxmlNode_Get(node);
 
593
            } else if (PyInstance_Check(node)) {
 
594
                PyInstanceObject *inst = (PyInstanceObject *) node;
 
595
                PyObject *name = inst->in_class->cl_name;
 
596
 
 
597
                if PyString_Check
 
598
                    (name) {
 
599
                    char *type = PyString_AS_STRING(name);
 
600
                    PyObject *wrapper;
 
601
 
 
602
                    if (!strcmp(type, "xmlNode")) {
 
603
                        wrapper =
 
604
                            PyObject_GetAttrString(node, (char *) "_o");
 
605
                        if (wrapper != NULL) {
 
606
                            cur = PyxmlNode_Get(wrapper);
 
607
                        }
 
608
                    }
 
609
                    }
 
610
            } else {
 
611
#ifdef DEBUG
 
612
                printf("Unknown object in Python return list\n");
 
613
#endif
 
614
            }
 
615
            if (cur != NULL) {
 
616
                xmlXPathNodeSetAdd(set, cur);
 
617
            }
 
618
        }
 
619
        ret = xmlXPathWrapNodeSet(set);
 
620
    } else {
 
621
#ifdef DEBUG
 
622
        printf("Unable to convert Python Object to XPath");
 
623
#endif
 
624
    }
 
625
    Py_DECREF(obj);
 
626
    return (ret);
 
627
}
 
628
 
 
629
PyObject *
 
630
libxml_xmlValidCtxtPtrWrap(xmlValidCtxtPtr valid)
 
631
{
 
632
        PyObject *ret;
 
633
        
 
634
#ifdef DEBUG
 
635
        printf("libxml_xmlValidCtxtPtrWrap: valid = %p\n", valid);
 
636
#endif
 
637
        if (valid == NULL) {
 
638
                Py_INCREF(Py_None);
 
639
                return (Py_None);
 
640
        }
 
641
 
 
642
        ret = 
 
643
                PyCObject_FromVoidPtrAndDesc((void *) valid,
 
644
                                                                         (char *) "xmlValidCtxtPtr", NULL);
 
645
 
 
646
        return (ret);
 
647
}
 
648
 
 
649
PyObject *
 
650
libxml_xmlCatalogPtrWrap(xmlCatalogPtr catal)
 
651
{
 
652
    PyObject *ret;
 
653
 
 
654
#ifdef DEBUG
 
655
    printf("libxml_xmlNodePtrWrap: catal = %p\n", catal);
 
656
#endif
 
657
    if (catal == NULL) {
 
658
        Py_INCREF(Py_None);
 
659
        return (Py_None);
 
660
    }
 
661
    ret =
 
662
        PyCObject_FromVoidPtrAndDesc((void *) catal,
 
663
                                     (char *) "xmlCatalogPtr", NULL);
 
664
    return (ret);
 
665
}
 
666
 
 
667
PyObject *
 
668
libxml_xmlOutputBufferPtrWrap(xmlOutputBufferPtr buffer)
 
669
{
 
670
    PyObject *ret;
 
671
 
 
672
#ifdef DEBUG
 
673
    printf("libxml_xmlOutputBufferPtrWrap: buffer = %p\n", buffer);
 
674
#endif
 
675
    if (buffer == NULL) {
 
676
        Py_INCREF(Py_None);
 
677
        return (Py_None);
 
678
    }
 
679
    ret =
 
680
        PyCObject_FromVoidPtrAndDesc((void *) buffer,
 
681
                                     (char *) "xmlOutputBufferPtr", NULL);
 
682
    return (ret);
 
683
}
 
684
 
 
685
PyObject *
 
686
libxml_xmlParserInputBufferPtrWrap(xmlParserInputBufferPtr buffer)
 
687
{
 
688
    PyObject *ret;
 
689
 
 
690
#ifdef DEBUG
 
691
    printf("libxml_xmlParserInputBufferPtrWrap: buffer = %p\n", buffer);
 
692
#endif
 
693
    if (buffer == NULL) {
 
694
        Py_INCREF(Py_None);
 
695
        return (Py_None);
 
696
    }
 
697
    ret =
 
698
        PyCObject_FromVoidPtrAndDesc((void *) buffer,
 
699
                                     (char *) "xmlParserInputBufferPtr", NULL);
 
700
    return (ret);
 
701
}
 
702
 
 
703
#ifdef LIBXML_REGEXP_ENABLED
 
704
PyObject *
 
705
libxml_xmlRegexpPtrWrap(xmlRegexpPtr regexp)
 
706
{
 
707
    PyObject *ret;
 
708
 
 
709
#ifdef DEBUG
 
710
    printf("libxml_xmlRegexpPtrWrap: regexp = %p\n", regexp);
 
711
#endif
 
712
    if (regexp == NULL) {
 
713
        Py_INCREF(Py_None);
 
714
        return (Py_None);
 
715
    }
 
716
    ret =
 
717
        PyCObject_FromVoidPtrAndDesc((void *) regexp,
 
718
                                     (char *) "xmlRegexpPtr", NULL);
 
719
    return (ret);
 
720
}
 
721
#endif /* LIBXML_REGEXP_ENABLED */
 
722
 
 
723
PyObject *
 
724
libxml_xmlTextReaderPtrWrap(xmlTextReaderPtr reader)
 
725
{
 
726
    PyObject *ret;
 
727
 
 
728
#ifdef DEBUG
 
729
    printf("libxml_xmlTextReaderPtrWrap: reader = %p\n", reader);
 
730
#endif
 
731
    if (reader == NULL) {
 
732
        Py_INCREF(Py_None);
 
733
        return (Py_None);
 
734
    }
 
735
    ret =
 
736
        PyCObject_FromVoidPtrAndDesc((void *) reader,
 
737
                                     (char *) "xmlTextReaderPtr", NULL);
 
738
    return (ret);
 
739
}
 
740
 
 
741
PyObject *
 
742
libxml_xmlTextReaderLocatorPtrWrap(xmlTextReaderLocatorPtr locator)
 
743
{
 
744
    PyObject *ret;
 
745
 
 
746
#ifdef DEBUG
 
747
    printf("libxml_xmlTextReaderLocatorPtrWrap: locator = %p\n", locator);
 
748
#endif
 
749
    if (locator == NULL) {
 
750
        Py_INCREF(Py_None);
 
751
        return (Py_None);
 
752
    }
 
753
    ret =
 
754
        PyCObject_FromVoidPtrAndDesc((void *) locator,
 
755
                                     (char *) "xmlTextReaderLocatorPtr", NULL);
 
756
    return (ret);
 
757
}
 
758
 
 
759
#ifdef LIBXML_SCHEMAS_ENABLED
 
760
PyObject *
 
761
libxml_xmlRelaxNGPtrWrap(xmlRelaxNGPtr ctxt)
 
762
{
 
763
    PyObject *ret;
 
764
 
 
765
#ifdef DEBUG
 
766
    printf("libxml_xmlRelaxNGPtrWrap: ctxt = %p\n", ctxt);
 
767
#endif
 
768
    if (ctxt == NULL) {
 
769
        Py_INCREF(Py_None);
 
770
        return (Py_None);
 
771
    }
 
772
    ret =
 
773
        PyCObject_FromVoidPtrAndDesc((void *) ctxt,
 
774
                                     (char *) "xmlRelaxNGPtr", NULL);
 
775
    return (ret);
 
776
}
 
777
 
 
778
PyObject *
 
779
libxml_xmlRelaxNGParserCtxtPtrWrap(xmlRelaxNGParserCtxtPtr ctxt)
 
780
{
 
781
    PyObject *ret;
 
782
 
 
783
#ifdef DEBUG
 
784
    printf("libxml_xmlRelaxNGParserCtxtPtrWrap: ctxt = %p\n", ctxt);
 
785
#endif
 
786
    if (ctxt == NULL) {
 
787
        Py_INCREF(Py_None);
 
788
        return (Py_None);
 
789
    }
 
790
    ret =
 
791
        PyCObject_FromVoidPtrAndDesc((void *) ctxt,
 
792
                                     (char *) "xmlRelaxNGParserCtxtPtr", NULL);
 
793
    return (ret);
 
794
}
 
795
PyObject *
 
796
libxml_xmlRelaxNGValidCtxtPtrWrap(xmlRelaxNGValidCtxtPtr valid)
 
797
{
 
798
    PyObject *ret;
 
799
 
 
800
#ifdef DEBUG
 
801
    printf("libxml_xmlRelaxNGValidCtxtPtrWrap: valid = %p\n", valid);
 
802
#endif
 
803
    if (valid == NULL) {
 
804
        Py_INCREF(Py_None);
 
805
        return (Py_None);
 
806
    }
 
807
    ret =
 
808
        PyCObject_FromVoidPtrAndDesc((void *) valid,
 
809
                                     (char *) "xmlRelaxNGValidCtxtPtr", NULL);
 
810
    return (ret);
 
811
}
 
812
 
 
813
PyObject *
 
814
libxml_xmlSchemaPtrWrap(xmlSchemaPtr ctxt)
 
815
{
 
816
        PyObject *ret;
 
817
 
 
818
#ifdef DEBUG
 
819
        printf("libxml_xmlSchemaPtrWrap: ctxt = %p\n", ctxt);
 
820
#endif
 
821
        if (ctxt == NULL) {
 
822
                Py_INCREF(Py_None);
 
823
                return (Py_None);
 
824
        }
 
825
        ret =
 
826
                PyCObject_FromVoidPtrAndDesc((void *) ctxt,
 
827
                                                                         (char *) "xmlSchemaPtr", NULL);
 
828
        return (ret);
 
829
}
 
830
 
 
831
PyObject *
 
832
libxml_xmlSchemaParserCtxtPtrWrap(xmlSchemaParserCtxtPtr ctxt)
 
833
{
 
834
        PyObject *ret;
 
835
 
 
836
#ifdef DEBUG
 
837
        printf("libxml_xmlSchemaParserCtxtPtrWrap: ctxt = %p\n", ctxt);
 
838
#endif
 
839
        if (ctxt == NULL) {
 
840
                Py_INCREF(Py_None);
 
841
                return (Py_None);
 
842
        }
 
843
        ret = 
 
844
                PyCObject_FromVoidPtrAndDesc((void *) ctxt,
 
845
                                                                         (char *) "xmlSchemaParserCtxtPtr", NULL);
 
846
 
 
847
        return (ret);
 
848
}
 
849
 
 
850
PyObject *
 
851
libxml_xmlSchemaValidCtxtPtrWrap(xmlSchemaValidCtxtPtr valid)
 
852
{
 
853
        PyObject *ret;
 
854
        
 
855
#ifdef DEBUG
 
856
        printf("libxml_xmlSchemaValidCtxtPtrWrap: valid = %p\n", valid);
 
857
#endif
 
858
        if (valid == NULL) {
 
859
                Py_INCREF(Py_None);
 
860
                return (Py_None);
 
861
        }
 
862
 
 
863
        ret = 
 
864
                PyCObject_FromVoidPtrAndDesc((void *) valid,
 
865
                                                                         (char *) "xmlSchemaValidCtxtPtr", NULL);
 
866
 
 
867
        return (ret);
 
868
}
 
869
#endif /* LIBXML_SCHEMAS_ENABLED */
 
870
 
 
871
PyObject *
 
872
libxml_xmlErrorPtrWrap(xmlErrorPtr error)
 
873
{
 
874
    PyObject *ret;
 
875
 
 
876
#ifdef DEBUG
 
877
    printf("libxml_xmlErrorPtrWrap: error = %p\n", error);
 
878
#endif
 
879
    if (error == NULL) {
 
880
        Py_INCREF(Py_None);
 
881
        return (Py_None);
 
882
    }
 
883
    ret =
 
884
        PyCObject_FromVoidPtrAndDesc((void *) error,
 
885
                                     (char *) "xmlErrorPtr", NULL);
 
886
    return (ret);
 
887
}