VirtualBox

source: vbox/trunk/src/libs/libxslt-1.1.22/python/libxslt-py.c@ 15410

Last change on this file since 15410 was 7296, checked in by vboxsync, 17 years ago

Added libxslt-1.1.22 sources.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Date Revision Author Id
File size: 60.8 KB
Line 
1/* Generated */
2
3#include <libxslt/xsltconfig.h>
4#include "libxslt_wrap.h"
5#include "libxslt-py.h"
6
7PyObject *
8libxslt_xsltTransformGetInstruction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9 PyObject *py_retval;
10 xmlNodePtr c_retval;
11 xsltTransformContextPtr ctxt;
12 PyObject *pyobj_ctxt;
13
14 if (!PyArg_ParseTuple(args, (char *)"O:xsltTransformGetInstruction", &pyobj_ctxt))
15 return(NULL);
16 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
17
18 c_retval = ctxt->inst;
19 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
20 return(py_retval);
21}
22
23PyObject *
24libxslt_xsltParseStylesheetImportedDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
25 PyObject *py_retval;
26 xsltStylesheetPtr c_retval;
27 xmlDocPtr doc;
28 PyObject *pyobj_doc;
29 xsltStylesheetPtr parentStyle;
30 PyObject *pyobj_parentStyle;
31
32 if (!PyArg_ParseTuple(args, (char *)"OO:xsltParseStylesheetImportedDoc", &pyobj_doc, &pyobj_parentStyle))
33 return(NULL);
34 doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
35 parentStyle = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_parentStyle);
36
37 c_retval = xsltParseStylesheetImportedDoc(doc, parentStyle);
38 py_retval = libxslt_xsltStylesheetPtrWrap((xsltStylesheetPtr) c_retval);
39 return(py_retval);
40}
41
42PyObject *
43libxslt_xsltExtensionInstructionResultFinalize(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
44 PyObject *py_retval;
45 int c_retval;
46 xsltTransformContextPtr ctxt;
47 PyObject *pyobj_ctxt;
48
49 if (!PyArg_ParseTuple(args, (char *)"O:xsltExtensionInstructionResultFinalize", &pyobj_ctxt))
50 return(NULL);
51 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
52
53 c_retval = xsltExtensionInstructionResultFinalize(ctxt);
54 py_retval = libxml_intWrap((int) c_retval);
55 return(py_retval);
56}
57
58PyObject *
59libxslt_xsltGenerateIdFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
60 xmlXPathParserContextPtr ctxt;
61 PyObject *pyobj_ctxt;
62 int nargs;
63
64 if (!PyArg_ParseTuple(args, (char *)"Oi:xsltGenerateIdFunction", &pyobj_ctxt, &nargs))
65 return(NULL);
66 ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
67
68 xsltGenerateIdFunction(ctxt, nargs);
69 Py_INCREF(Py_None);
70 return(Py_None);
71}
72
73PyObject *
74libxslt_xsltApplyAttributeSet(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
75 xsltTransformContextPtr ctxt;
76 PyObject *pyobj_ctxt;
77 xmlNodePtr node;
78 PyObject *pyobj_node;
79 xmlNodePtr inst;
80 PyObject *pyobj_inst;
81 xmlChar * attrSets;
82
83 if (!PyArg_ParseTuple(args, (char *)"OOOz:xsltApplyAttributeSet", &pyobj_ctxt, &pyobj_node, &pyobj_inst, &attrSets))
84 return(NULL);
85 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
86 node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
87 inst = (xmlNodePtr) PyxmlNode_Get(pyobj_inst);
88
89 xsltApplyAttributeSet(ctxt, node, inst, attrSets);
90 Py_INCREF(Py_None);
91 return(Py_None);
92}
93
94PyObject *
95libxslt_xsltAttrListTemplateProcess(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
96 PyObject *py_retval;
97 xmlAttrPtr c_retval;
98 xsltTransformContextPtr ctxt;
99 PyObject *pyobj_ctxt;
100 xmlNodePtr target;
101 PyObject *pyobj_target;
102 xmlAttrPtr attrs;
103 PyObject *pyobj_attrs;
104
105 if (!PyArg_ParseTuple(args, (char *)"OOO:xsltAttrListTemplateProcess", &pyobj_ctxt, &pyobj_target, &pyobj_attrs))
106 return(NULL);
107 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
108 target = (xmlNodePtr) PyxmlNode_Get(pyobj_target);
109 attrs = (xmlAttrPtr) PyxmlNode_Get(pyobj_attrs);
110
111 c_retval = xsltAttrListTemplateProcess(ctxt, target, attrs);
112 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
113 return(py_retval);
114}
115
116PyObject *
117libxslt_xsltUninit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
118
119 xsltUninit();
120 Py_INCREF(Py_None);
121 return(Py_None);
122}
123
124PyObject *
125libxslt_xsltParseStylesheetAttributeSet(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
126 xsltStylesheetPtr style;
127 PyObject *pyobj_style;
128 xmlNodePtr cur;
129 PyObject *pyobj_cur;
130
131 if (!PyArg_ParseTuple(args, (char *)"OO:xsltParseStylesheetAttributeSet", &pyobj_style, &pyobj_cur))
132 return(NULL);
133 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
134 cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
135
136 xsltParseStylesheetAttributeSet(style, cur);
137 Py_INCREF(Py_None);
138 return(Py_None);
139}
140
141PyObject *
142libxslt_xsltUnparsedEntityURIFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
143 xmlXPathParserContextPtr ctxt;
144 PyObject *pyobj_ctxt;
145 int nargs;
146
147 if (!PyArg_ParseTuple(args, (char *)"Oi:xsltUnparsedEntityURIFunction", &pyobj_ctxt, &nargs))
148 return(NULL);
149 ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
150
151 xsltUnparsedEntityURIFunction(ctxt, nargs);
152 Py_INCREF(Py_None);
153 return(Py_None);
154}
155
156PyObject *
157libxslt_xsltMessage(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
158 xsltTransformContextPtr ctxt;
159 PyObject *pyobj_ctxt;
160 xmlNodePtr node;
161 PyObject *pyobj_node;
162 xmlNodePtr inst;
163 PyObject *pyobj_inst;
164
165 if (!PyArg_ParseTuple(args, (char *)"OOO:xsltMessage", &pyobj_ctxt, &pyobj_node, &pyobj_inst))
166 return(NULL);
167 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
168 node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
169 inst = (xmlNodePtr) PyxmlNode_Get(pyobj_inst);
170
171 xsltMessage(ctxt, node, inst);
172 Py_INCREF(Py_None);
173 return(Py_None);
174}
175
176PyObject *
177libxslt_xsltCreateRVT(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
178 PyObject *py_retval;
179 xmlDocPtr c_retval;
180 xsltTransformContextPtr ctxt;
181 PyObject *pyobj_ctxt;
182
183 if (!PyArg_ParseTuple(args, (char *)"O:xsltCreateRVT", &pyobj_ctxt))
184 return(NULL);
185 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
186
187 c_retval = xsltCreateRVT(ctxt);
188 py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
189 return(py_retval);
190}
191
192PyObject *
193libxslt_xsltParseStylesheetProcess(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
194 PyObject *py_retval;
195 xsltStylesheetPtr c_retval;
196 xsltStylesheetPtr ret;
197 PyObject *pyobj_ret;
198 xmlDocPtr doc;
199 PyObject *pyobj_doc;
200
201 if (!PyArg_ParseTuple(args, (char *)"OO:xsltParseStylesheetProcess", &pyobj_ret, &pyobj_doc))
202 return(NULL);
203 ret = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_ret);
204 doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
205
206 c_retval = xsltParseStylesheetProcess(ret, doc);
207 py_retval = libxslt_xsltStylesheetPtrWrap((xsltStylesheetPtr) c_retval);
208 return(py_retval);
209}
210
211PyObject *
212libxslt_xsltGetDebuggerStatus(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
213 PyObject *py_retval;
214 int c_retval;
215
216 c_retval = xsltGetDebuggerStatus();
217 py_retval = libxml_intWrap((int) c_retval);
218 return(py_retval);
219}
220
221PyObject *
222libxslt_xsltStylesheetGetVersion(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
223 PyObject *py_retval;
224 const xmlChar * c_retval;
225 xsltStylesheetPtr style;
226 PyObject *pyobj_style;
227
228 if (!PyArg_ParseTuple(args, (char *)"O:xsltStylesheetGetVersion", &pyobj_style))
229 return(NULL);
230 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
231
232 c_retval = style->version;
233 py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
234 return(py_retval);
235}
236
237PyObject *
238libxslt_xsltXPathGetTransformContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
239 PyObject *py_retval;
240 xsltTransformContextPtr c_retval;
241 xmlXPathContextPtr ctxt;
242 PyObject *pyobj_ctxt;
243
244 if (!PyArg_ParseTuple(args, (char *)"O:xsltXPathGetTransformContext", &pyobj_ctxt))
245 return(NULL);
246 ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
247
248 c_retval = ctxt->extra;
249 py_retval = libxslt_xsltTransformContextPtrWrap((xsltTransformContextPtr) c_retval);
250 return(py_retval);
251}
252
253PyObject *
254libxslt_xsltStylesheetGetImports(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
255 PyObject *py_retval;
256 xsltStylesheetPtr c_retval;
257 xsltStylesheetPtr style;
258 PyObject *pyobj_style;
259
260 if (!PyArg_ParseTuple(args, (char *)"O:xsltStylesheetGetImports", &pyobj_style))
261 return(NULL);
262 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
263
264 c_retval = style->imports;
265 py_retval = libxslt_xsltStylesheetPtrWrap((xsltStylesheetPtr) c_retval);
266 return(py_retval);
267}
268
269PyObject *
270libxslt_xsltAttrTemplateValueProcess(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
271 PyObject *py_retval;
272 xmlChar * c_retval;
273 xsltTransformContextPtr ctxt;
274 PyObject *pyobj_ctxt;
275 xmlChar * str;
276
277 if (!PyArg_ParseTuple(args, (char *)"Oz:xsltAttrTemplateValueProcess", &pyobj_ctxt, &str))
278 return(NULL);
279 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
280
281 c_retval = xsltAttrTemplateValueProcess(ctxt, str);
282 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
283 return(py_retval);
284}
285
286PyObject *
287libxslt_xsltNextImport(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
288 PyObject *py_retval;
289 xsltStylesheetPtr c_retval;
290 xsltStylesheetPtr cur;
291 PyObject *pyobj_cur;
292
293 if (!PyArg_ParseTuple(args, (char *)"O:xsltNextImport", &pyobj_cur))
294 return(NULL);
295 cur = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_cur);
296
297 c_retval = xsltNextImport(cur);
298 py_retval = libxslt_xsltStylesheetPtrWrap((xsltStylesheetPtr) c_retval);
299 return(py_retval);
300}
301
302PyObject *
303libxslt_xsltReleaseRVT(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
304 xsltTransformContextPtr ctxt;
305 PyObject *pyobj_ctxt;
306 xmlDocPtr RVT;
307 PyObject *pyobj_RVT;
308
309 if (!PyArg_ParseTuple(args, (char *)"OO:xsltReleaseRVT", &pyobj_ctxt, &pyobj_RVT))
310 return(NULL);
311 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
312 RVT = (xmlDocPtr) PyxmlNode_Get(pyobj_RVT);
313
314 xsltReleaseRVT(ctxt, RVT);
315 Py_INCREF(Py_None);
316 return(Py_None);
317}
318
319PyObject *
320libxslt_xsltFreeCtxtExts(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
321 xsltTransformContextPtr ctxt;
322 PyObject *pyobj_ctxt;
323
324 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeCtxtExts", &pyobj_ctxt))
325 return(NULL);
326 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
327
328 xsltFreeCtxtExts(ctxt);
329 Py_INCREF(Py_None);
330 return(Py_None);
331}
332
333PyObject *
334libxslt_xsltNamespaceAlias(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
335 xsltStylesheetPtr style;
336 PyObject *pyobj_style;
337 xmlNodePtr node;
338 PyObject *pyobj_node;
339
340 if (!PyArg_ParseTuple(args, (char *)"OO:xsltNamespaceAlias", &pyobj_style, &pyobj_node))
341 return(NULL);
342 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
343 node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
344
345 xsltNamespaceAlias(style, node);
346 Py_INCREF(Py_None);
347 return(Py_None);
348}
349
350PyObject *
351libxslt_xsltFreeDocuments(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
352 xsltTransformContextPtr ctxt;
353 PyObject *pyobj_ctxt;
354
355 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeDocuments", &pyobj_ctxt))
356 return(NULL);
357 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
358
359 xsltFreeDocuments(ctxt);
360 Py_INCREF(Py_None);
361 return(Py_None);
362}
363
364PyObject *
365libxslt_xsltDocumentFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
366 xmlXPathParserContextPtr ctxt;
367 PyObject *pyobj_ctxt;
368 int nargs;
369
370 if (!PyArg_ParseTuple(args, (char *)"Oi:xsltDocumentFunction", &pyobj_ctxt, &nargs))
371 return(NULL);
372 ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
373
374 xsltDocumentFunction(ctxt, nargs);
375 Py_INCREF(Py_None);
376 return(Py_None);
377}
378
379PyObject *
380libxslt_xsltNewStylesheet(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
381 PyObject *py_retval;
382 xsltStylesheetPtr c_retval;
383
384 c_retval = xsltNewStylesheet();
385 py_retval = libxslt_xsltStylesheetPtrWrap((xsltStylesheetPtr) c_retval);
386 return(py_retval);
387}
388
389PyObject *
390libxslt_xsltSetDebuggerStatus(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
391 int value;
392
393 if (!PyArg_ParseTuple(args, (char *)"i:xsltSetDebuggerStatus", &value))
394 return(NULL);
395
396 xsltSetDebuggerStatus(value);
397 Py_INCREF(Py_None);
398 return(Py_None);
399}
400
401PyObject *
402libxslt_xsltCopyNamespaceList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
403 PyObject *py_retval;
404 xmlNsPtr c_retval;
405 xsltTransformContextPtr ctxt;
406 PyObject *pyobj_ctxt;
407 xmlNodePtr node;
408 PyObject *pyobj_node;
409 xmlNsPtr cur;
410 PyObject *pyobj_cur;
411
412 if (!PyArg_ParseTuple(args, (char *)"OOO:xsltCopyNamespaceList", &pyobj_ctxt, &pyobj_node, &pyobj_cur))
413 return(NULL);
414 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
415 node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
416 cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
417
418 c_retval = xsltCopyNamespaceList(ctxt, node, cur);
419 py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
420 return(py_retval);
421}
422
423PyObject *
424libxslt_xsltEvalGlobalVariables(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
425 PyObject *py_retval;
426 int c_retval;
427 xsltTransformContextPtr ctxt;
428 PyObject *pyobj_ctxt;
429
430 if (!PyArg_ParseTuple(args, (char *)"O:xsltEvalGlobalVariables", &pyobj_ctxt))
431 return(NULL);
432 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
433
434 c_retval = xsltEvalGlobalVariables(ctxt);
435 py_retval = libxml_intWrap((int) c_retval);
436 return(py_retval);
437}
438
439PyObject *
440libxslt_xsltCleanupGlobals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
441
442 xsltCleanupGlobals();
443 Py_INCREF(Py_None);
444 return(Py_None);
445}
446
447PyObject *
448libxslt_xsltParseTemplateContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
449 xsltStylesheetPtr style;
450 PyObject *pyobj_style;
451 xmlNodePtr templ;
452 PyObject *pyobj_templ;
453
454 if (!PyArg_ParseTuple(args, (char *)"OO:xsltParseTemplateContent", &pyobj_style, &pyobj_templ))
455 return(NULL);
456 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
457 templ = (xmlNodePtr) PyxmlNode_Get(pyobj_templ);
458
459 xsltParseTemplateContent(style, templ);
460 Py_INCREF(Py_None);
461 return(Py_None);
462}
463
464PyObject *
465libxslt_xsltEvalOneUserParam(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
466 PyObject *py_retval;
467 int c_retval;
468 xsltTransformContextPtr ctxt;
469 PyObject *pyobj_ctxt;
470 xmlChar * name;
471 xmlChar * value;
472
473 if (!PyArg_ParseTuple(args, (char *)"Ozz:xsltEvalOneUserParam", &pyobj_ctxt, &name, &value))
474 return(NULL);
475 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
476
477 c_retval = xsltEvalOneUserParam(ctxt, name, value);
478 py_retval = libxml_intWrap((int) c_retval);
479 return(py_retval);
480}
481
482PyObject *
483libxslt_xsltUnregisterExtModuleFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
484 PyObject *py_retval;
485 int c_retval;
486 xmlChar * name;
487 xmlChar * URI;
488
489 if (!PyArg_ParseTuple(args, (char *)"zz:xsltUnregisterExtModuleFunction", &name, &URI))
490 return(NULL);
491
492 c_retval = xsltUnregisterExtModuleFunction(name, URI);
493 py_retval = libxml_intWrap((int) c_retval);
494 return(py_retval);
495}
496
497PyObject *
498libxslt_xsltFreeGlobalVariables(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
499 xsltTransformContextPtr ctxt;
500 PyObject *pyobj_ctxt;
501
502 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeGlobalVariables", &pyobj_ctxt))
503 return(NULL);
504 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
505
506 xsltFreeGlobalVariables(ctxt);
507 Py_INCREF(Py_None);
508 return(Py_None);
509}
510
511PyObject *
512libxslt_xsltSaveResultToFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
513 PyObject *py_retval;
514 int c_retval;
515 FILE * file;
516 PyObject *pyobj_file;
517 xmlDocPtr result;
518 PyObject *pyobj_result;
519 xsltStylesheetPtr style;
520 PyObject *pyobj_style;
521
522 if (!PyArg_ParseTuple(args, (char *)"OOO:xsltSaveResultToFile", &pyobj_file, &pyobj_result, &pyobj_style))
523 return(NULL);
524 file = (FILE *) PyFile_Get(pyobj_file);
525 result = (xmlDocPtr) PyxmlNode_Get(pyobj_result);
526 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
527
528 c_retval = xsltSaveResultToFile(file, result, style);
529 py_retval = libxml_intWrap((int) c_retval);
530 return(py_retval);
531}
532
533PyObject *
534libxslt_xsltParseGlobalVariable(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
535 xsltStylesheetPtr style;
536 PyObject *pyobj_style;
537 xmlNodePtr cur;
538 PyObject *pyobj_cur;
539
540 if (!PyArg_ParseTuple(args, (char *)"OO:xsltParseGlobalVariable", &pyobj_style, &pyobj_cur))
541 return(NULL);
542 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
543 cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
544
545 xsltParseGlobalVariable(style, cur);
546 Py_INCREF(Py_None);
547 return(Py_None);
548}
549
550PyObject *
551libxslt_xsltShutdownExts(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
552 xsltStylesheetPtr style;
553 PyObject *pyobj_style;
554
555 if (!PyArg_ParseTuple(args, (char *)"O:xsltShutdownExts", &pyobj_style))
556 return(NULL);
557 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
558
559 xsltShutdownExts(style);
560 Py_INCREF(Py_None);
561 return(Py_None);
562}
563
564PyObject *
565libxslt_xsltFindElemSpaceHandling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
566 PyObject *py_retval;
567 int c_retval;
568 xsltTransformContextPtr ctxt;
569 PyObject *pyobj_ctxt;
570 xmlNodePtr node;
571 PyObject *pyobj_node;
572
573 if (!PyArg_ParseTuple(args, (char *)"OO:xsltFindElemSpaceHandling", &pyobj_ctxt, &pyobj_node))
574 return(NULL);
575 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
576 node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
577
578 c_retval = xsltFindElemSpaceHandling(ctxt, node);
579 py_retval = libxml_intWrap((int) c_retval);
580 return(py_retval);
581}
582
583PyObject *
584libxslt_xsltStylesheetGetParent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
585 PyObject *py_retval;
586 xsltStylesheetPtr c_retval;
587 xsltStylesheetPtr style;
588 PyObject *pyobj_style;
589
590 if (!PyArg_ParseTuple(args, (char *)"O:xsltStylesheetGetParent", &pyobj_style))
591 return(NULL);
592 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
593
594 c_retval = style->parent;
595 py_retval = libxslt_xsltStylesheetPtrWrap((xsltStylesheetPtr) c_retval);
596 return(py_retval);
597}
598
599PyObject *
600libxslt_xsltSaveResultToFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
601 PyObject *py_retval;
602 int c_retval;
603 int fd;
604 xmlDocPtr result;
605 PyObject *pyobj_result;
606 xsltStylesheetPtr style;
607 PyObject *pyobj_style;
608
609 if (!PyArg_ParseTuple(args, (char *)"iOO:xsltSaveResultToFd", &fd, &pyobj_result, &pyobj_style))
610 return(NULL);
611 result = (xmlDocPtr) PyxmlNode_Get(pyobj_result);
612 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
613
614 c_retval = xsltSaveResultToFd(fd, result, style);
615 py_retval = libxml_intWrap((int) c_retval);
616 return(py_retval);
617}
618
619PyObject *
620libxslt_xsltCopyNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
621 PyObject *py_retval;
622 xmlNsPtr c_retval;
623 xsltTransformContextPtr ctxt;
624 PyObject *pyobj_ctxt;
625 xmlNodePtr elem;
626 PyObject *pyobj_elem;
627 xmlNsPtr ns;
628 PyObject *pyobj_ns;
629
630 if (!PyArg_ParseTuple(args, (char *)"OOO:xsltCopyNamespace", &pyobj_ctxt, &pyobj_elem, &pyobj_ns))
631 return(NULL);
632 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
633 elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
634 ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
635
636 c_retval = xsltCopyNamespace(ctxt, elem, ns);
637 py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
638 return(py_retval);
639}
640
641PyObject *
642libxslt_xsltCalibrateAdjust(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
643 long delta;
644
645 if (!PyArg_ParseTuple(args, (char *)"l:xsltCalibrateAdjust", &delta))
646 return(NULL);
647
648 xsltCalibrateAdjust(delta);
649 Py_INCREF(Py_None);
650 return(Py_None);
651}
652
653PyObject *
654libxslt_xsltSaveProfiling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
655 xsltTransformContextPtr ctxt;
656 PyObject *pyobj_ctxt;
657 FILE * output;
658 PyObject *pyobj_output;
659
660 if (!PyArg_ParseTuple(args, (char *)"OO:xsltSaveProfiling", &pyobj_ctxt, &pyobj_output))
661 return(NULL);
662 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
663 output = (FILE *) PyFile_Get(pyobj_output);
664
665 xsltSaveProfiling(ctxt, output);
666 Py_INCREF(Py_None);
667 return(Py_None);
668}
669
670PyObject *
671libxslt_xsltStylesheetGetMethod(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
672 PyObject *py_retval;
673 const xmlChar * c_retval;
674 xsltStylesheetPtr style;
675 PyObject *pyobj_style;
676
677 if (!PyArg_ParseTuple(args, (char *)"O:xsltStylesheetGetMethod", &pyobj_style))
678 return(NULL);
679 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
680
681 c_retval = style->method;
682 py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
683 return(py_retval);
684}
685
686PyObject *
687libxslt_xsltFunctionNodeSet(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
688 xmlXPathParserContextPtr ctxt;
689 PyObject *pyobj_ctxt;
690 int nargs;
691
692 if (!PyArg_ParseTuple(args, (char *)"Oi:xsltFunctionNodeSet", &pyobj_ctxt, &nargs))
693 return(NULL);
694 ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
695
696 xsltFunctionNodeSet(ctxt, nargs);
697 Py_INCREF(Py_None);
698 return(Py_None);
699}
700
701PyObject *
702libxslt_xsltCleanupTemplates(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
703 xsltStylesheetPtr style;
704 PyObject *pyobj_style;
705
706 if (!PyArg_ParseTuple(args, (char *)"O:xsltCleanupTemplates", &pyobj_style))
707 return(NULL);
708 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
709
710 xsltCleanupTemplates(style);
711 Py_INCREF(Py_None);
712 return(Py_None);
713}
714
715PyObject *
716libxslt_xsltCheckExtPrefix(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
717 PyObject *py_retval;
718 int c_retval;
719 xsltStylesheetPtr style;
720 PyObject *pyobj_style;
721 xmlChar * URI;
722
723 if (!PyArg_ParseTuple(args, (char *)"Oz:xsltCheckExtPrefix", &pyobj_style, &URI))
724 return(NULL);
725 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
726
727 c_retval = xsltCheckExtPrefix(style, URI);
728 py_retval = libxml_intWrap((int) c_retval);
729 return(py_retval);
730}
731
732PyObject *
733libxslt_xsltParseStylesheetFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
734 PyObject *py_retval;
735 xsltStylesheetPtr c_retval;
736 xmlChar * filename;
737
738 if (!PyArg_ParseTuple(args, (char *)"z:xsltParseStylesheetFile", &filename))
739 return(NULL);
740
741 c_retval = xsltParseStylesheetFile(filename);
742 py_retval = libxslt_xsltStylesheetPtrWrap((xsltStylesheetPtr) c_retval);
743 return(py_retval);
744}
745
746PyObject *
747libxslt_xsltElementAvailableFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
748 xmlXPathParserContextPtr ctxt;
749 PyObject *pyobj_ctxt;
750 int nargs;
751
752 if (!PyArg_ParseTuple(args, (char *)"Oi:xsltElementAvailableFunction", &pyobj_ctxt, &nargs))
753 return(NULL);
754 ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
755
756 xsltElementAvailableFunction(ctxt, nargs);
757 Py_INCREF(Py_None);
758 return(Py_None);
759}
760
761PyObject *
762libxslt_xsltRegisterExtras(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
763 xsltTransformContextPtr ctxt;
764 PyObject *pyobj_ctxt;
765
766 if (!PyArg_ParseTuple(args, (char *)"O:xsltRegisterExtras", &pyobj_ctxt))
767 return(NULL);
768 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
769
770 xsltRegisterExtras(ctxt);
771 Py_INCREF(Py_None);
772 return(Py_None);
773}
774
775PyObject *
776libxslt_xsltFunctionAvailableFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
777 xmlXPathParserContextPtr ctxt;
778 PyObject *pyobj_ctxt;
779 int nargs;
780
781 if (!PyArg_ParseTuple(args, (char *)"Oi:xsltFunctionAvailableFunction", &pyobj_ctxt, &nargs))
782 return(NULL);
783 ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
784
785 xsltFunctionAvailableFunction(ctxt, nargs);
786 Py_INCREF(Py_None);
787 return(Py_None);
788}
789
790PyObject *
791libxslt_xsltFormatNumberFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
792 xmlXPathParserContextPtr ctxt;
793 PyObject *pyobj_ctxt;
794 int nargs;
795
796 if (!PyArg_ParseTuple(args, (char *)"Oi:xsltFormatNumberFunction", &pyobj_ctxt, &nargs))
797 return(NULL);
798 ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
799
800 xsltFormatNumberFunction(ctxt, nargs);
801 Py_INCREF(Py_None);
802 return(Py_None);
803}
804
805PyObject *
806libxslt_xsltEvalTemplateString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
807 PyObject *py_retval;
808 xmlChar * c_retval;
809 xsltTransformContextPtr ctxt;
810 PyObject *pyobj_ctxt;
811 xmlNodePtr contextNode;
812 PyObject *pyobj_contextNode;
813 xmlNodePtr inst;
814 PyObject *pyobj_inst;
815
816 if (!PyArg_ParseTuple(args, (char *)"OOO:xsltEvalTemplateString", &pyobj_ctxt, &pyobj_contextNode, &pyobj_inst))
817 return(NULL);
818 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
819 contextNode = (xmlNodePtr) PyxmlNode_Get(pyobj_contextNode);
820 inst = (xmlNodePtr) PyxmlNode_Get(pyobj_inst);
821
822 c_retval = xsltEvalTemplateString(ctxt, contextNode, inst);
823 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
824 return(py_retval);
825}
826
827PyObject *
828libxslt_xsltGetNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
829 PyObject *py_retval;
830 xmlChar * c_retval;
831 xmlNodePtr node;
832 PyObject *pyobj_node;
833 xmlChar * name;
834 xmlChar * nameSpace;
835
836 if (!PyArg_ParseTuple(args, (char *)"Ozz:xsltGetNsProp", &pyobj_node, &name, &nameSpace))
837 return(NULL);
838 node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
839
840 c_retval = xsltGetNsProp(node, name, nameSpace);
841 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
842 return(py_retval);
843}
844
845PyObject *
846libxslt_xsltAddKey(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
847 PyObject *py_retval;
848 int c_retval;
849 xsltStylesheetPtr style;
850 PyObject *pyobj_style;
851 xmlChar * name;
852 xmlChar * nameURI;
853 xmlChar * match;
854 xmlChar * use;
855 xmlNodePtr inst;
856 PyObject *pyobj_inst;
857
858 if (!PyArg_ParseTuple(args, (char *)"OzzzzO:xsltAddKey", &pyobj_style, &name, &nameURI, &match, &use, &pyobj_inst))
859 return(NULL);
860 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
861 inst = (xmlNodePtr) PyxmlNode_Get(pyobj_inst);
862
863 c_retval = xsltAddKey(style, name, nameURI, match, use, inst);
864 py_retval = libxml_intWrap((int) c_retval);
865 return(py_retval);
866}
867
868PyObject *
869libxslt_xsltRegisterAllFunctions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
870 xmlXPathContextPtr ctxt;
871 PyObject *pyobj_ctxt;
872
873 if (!PyArg_ParseTuple(args, (char *)"O:xsltRegisterAllFunctions", &pyobj_ctxt))
874 return(NULL);
875 ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
876
877 xsltRegisterAllFunctions(ctxt);
878 Py_INCREF(Py_None);
879 return(Py_None);
880}
881
882PyObject *
883libxslt_xsltAttrTemplateValueProcessNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
884 PyObject *py_retval;
885 xmlChar * c_retval;
886 xsltTransformContextPtr ctxt;
887 PyObject *pyobj_ctxt;
888 xmlChar * str;
889 xmlNodePtr inst;
890 PyObject *pyobj_inst;
891
892 if (!PyArg_ParseTuple(args, (char *)"OzO:xsltAttrTemplateValueProcessNode", &pyobj_ctxt, &str, &pyobj_inst))
893 return(NULL);
894 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
895 inst = (xmlNodePtr) PyxmlNode_Get(pyobj_inst);
896
897 c_retval = xsltAttrTemplateValueProcessNode(ctxt, str, inst);
898 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
899 return(py_retval);
900}
901
902PyObject *
903libxslt_xsltUnregisterExtModuleTopLevel(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
904 PyObject *py_retval;
905 int c_retval;
906 xmlChar * name;
907 xmlChar * URI;
908
909 if (!PyArg_ParseTuple(args, (char *)"zz:xsltUnregisterExtModuleTopLevel", &name, &URI))
910 return(NULL);
911
912 c_retval = xsltUnregisterExtModuleTopLevel(name, URI);
913 py_retval = libxml_intWrap((int) c_retval);
914 return(py_retval);
915}
916
917PyObject *
918libxslt_xsltParseStylesheetImport(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
919 PyObject *py_retval;
920 int c_retval;
921 xsltStylesheetPtr style;
922 PyObject *pyobj_style;
923 xmlNodePtr cur;
924 PyObject *pyobj_cur;
925
926 if (!PyArg_ParseTuple(args, (char *)"OO:xsltParseStylesheetImport", &pyobj_style, &pyobj_cur))
927 return(NULL);
928 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
929 cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
930
931 c_retval = xsltParseStylesheetImport(style, cur);
932 py_retval = libxml_intWrap((int) c_retval);
933 return(py_retval);
934}
935
936PyObject *
937libxslt_xsltAllocateExtraCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
938 PyObject *py_retval;
939 int c_retval;
940 xsltTransformContextPtr ctxt;
941 PyObject *pyobj_ctxt;
942
943 if (!PyArg_ParseTuple(args, (char *)"O:xsltAllocateExtraCtxt", &pyobj_ctxt))
944 return(NULL);
945 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
946
947 c_retval = xsltAllocateExtraCtxt(ctxt);
948 py_retval = libxml_intWrap((int) c_retval);
949 return(py_retval);
950}
951
952PyObject *
953libxslt_xsltTransformGetContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
954 PyObject *py_retval;
955 xmlXPathContextPtr c_retval;
956 xsltTransformContextPtr ctxt;
957 PyObject *pyobj_ctxt;
958
959 if (!PyArg_ParseTuple(args, (char *)"O:xsltTransformGetContext", &pyobj_ctxt))
960 return(NULL);
961 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
962
963 c_retval = ctxt->xpathCtxt;
964 py_retval = libxml_xmlXPathContextPtrWrap((xmlXPathContextPtr) c_retval);
965 return(py_retval);
966}
967
968PyObject *
969libxslt_xsltRegisterTestModule(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
970
971 xsltRegisterTestModule();
972 Py_INCREF(Py_None);
973 return(Py_None);
974}
975
976PyObject *
977libxslt_xsltFreeKeys(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
978 xsltStylesheetPtr style;
979 PyObject *pyobj_style;
980
981 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeKeys", &pyobj_style))
982 return(NULL);
983 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
984
985 xsltFreeKeys(style);
986 Py_INCREF(Py_None);
987 return(Py_None);
988}
989
990PyObject *
991libxslt_xsltParseStylesheetVariable(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
992 xsltTransformContextPtr ctxt;
993 PyObject *pyobj_ctxt;
994 xmlNodePtr inst;
995 PyObject *pyobj_inst;
996
997 if (!PyArg_ParseTuple(args, (char *)"OO:xsltParseStylesheetVariable", &pyobj_ctxt, &pyobj_inst))
998 return(NULL);
999 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1000 inst = (xmlNodePtr) PyxmlNode_Get(pyobj_inst);
1001
1002 xsltParseStylesheetVariable(ctxt, inst);
1003 Py_INCREF(Py_None);
1004 return(Py_None);
1005}
1006
1007PyObject *
1008libxslt_xsltGetSpecialNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1009 PyObject *py_retval;
1010 xmlNsPtr c_retval;
1011 xsltTransformContextPtr ctxt;
1012 PyObject *pyobj_ctxt;
1013 xmlNodePtr invocNode;
1014 PyObject *pyobj_invocNode;
1015 xmlChar * nsName;
1016 xmlChar * nsPrefix;
1017 xmlNodePtr target;
1018 PyObject *pyobj_target;
1019
1020 if (!PyArg_ParseTuple(args, (char *)"OOzzO:xsltGetSpecialNamespace", &pyobj_ctxt, &pyobj_invocNode, &nsName, &nsPrefix, &pyobj_target))
1021 return(NULL);
1022 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1023 invocNode = (xmlNodePtr) PyxmlNode_Get(pyobj_invocNode);
1024 target = (xmlNodePtr) PyxmlNode_Get(pyobj_target);
1025
1026 c_retval = xsltGetSpecialNamespace(ctxt, invocNode, nsName, nsPrefix, target);
1027 py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
1028 return(py_retval);
1029}
1030
1031PyObject *
1032libxslt_xsltLoadStylesheetPI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1033 PyObject *py_retval;
1034 xsltStylesheetPtr c_retval;
1035 xmlDocPtr doc;
1036 PyObject *pyobj_doc;
1037
1038 if (!PyArg_ParseTuple(args, (char *)"O:xsltLoadStylesheetPI", &pyobj_doc))
1039 return(NULL);
1040 doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1041
1042 c_retval = xsltLoadStylesheetPI(doc);
1043 py_retval = libxslt_xsltStylesheetPtrWrap((xsltStylesheetPtr) c_retval);
1044 return(py_retval);
1045}
1046
1047PyObject *
1048libxslt_xsltStylesheetGetDoctypePublic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1049 PyObject *py_retval;
1050 const xmlChar * c_retval;
1051 xsltStylesheetPtr style;
1052 PyObject *pyobj_style;
1053
1054 if (!PyArg_ParseTuple(args, (char *)"O:xsltStylesheetGetDoctypePublic", &pyobj_style))
1055 return(NULL);
1056 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1057
1058 c_retval = style->doctypePublic;
1059 py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1060 return(py_retval);
1061}
1062
1063PyObject *
1064libxslt_xsltAllocateExtra(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1065 PyObject *py_retval;
1066 int c_retval;
1067 xsltStylesheetPtr style;
1068 PyObject *pyobj_style;
1069
1070 if (!PyArg_ParseTuple(args, (char *)"O:xsltAllocateExtra", &pyobj_style))
1071 return(NULL);
1072 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1073
1074 c_retval = xsltAllocateExtra(style);
1075 py_retval = libxml_intWrap((int) c_retval);
1076 return(py_retval);
1077}
1078
1079PyObject *
1080libxslt_xsltAttrTemplateProcess(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1081 PyObject *py_retval;
1082 xmlAttrPtr c_retval;
1083 xsltTransformContextPtr ctxt;
1084 PyObject *pyobj_ctxt;
1085 xmlNodePtr target;
1086 PyObject *pyobj_target;
1087 xmlAttrPtr attr;
1088 PyObject *pyobj_attr;
1089
1090 if (!PyArg_ParseTuple(args, (char *)"OOO:xsltAttrTemplateProcess", &pyobj_ctxt, &pyobj_target, &pyobj_attr))
1091 return(NULL);
1092 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1093 target = (xmlNodePtr) PyxmlNode_Get(pyobj_target);
1094 attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
1095
1096 c_retval = xsltAttrTemplateProcess(ctxt, target, attr);
1097 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1098 return(py_retval);
1099}
1100
1101PyObject *
1102libxslt_xsltNeedElemSpaceHandling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1103 PyObject *py_retval;
1104 int c_retval;
1105 xsltTransformContextPtr ctxt;
1106 PyObject *pyobj_ctxt;
1107
1108 if (!PyArg_ParseTuple(args, (char *)"O:xsltNeedElemSpaceHandling", &pyobj_ctxt))
1109 return(NULL);
1110 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1111
1112 c_retval = xsltNeedElemSpaceHandling(ctxt);
1113 py_retval = libxml_intWrap((int) c_retval);
1114 return(py_retval);
1115}
1116
1117PyObject *
1118libxslt_xsltTransformGetOutputDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1119 PyObject *py_retval;
1120 xmlDocPtr c_retval;
1121 xsltTransformContextPtr ctxt;
1122 PyObject *pyobj_ctxt;
1123
1124 if (!PyArg_ParseTuple(args, (char *)"O:xsltTransformGetOutputDoc", &pyobj_ctxt))
1125 return(NULL);
1126 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1127
1128 c_retval = ctxt->output;
1129 py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
1130 return(py_retval);
1131}
1132
1133PyObject *
1134libxslt_xsltInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1135
1136 xsltInit();
1137 Py_INCREF(Py_None);
1138 return(Py_None);
1139}
1140
1141PyObject *
1142libxslt_xsltInitCtxtExts(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1143 PyObject *py_retval;
1144 int c_retval;
1145 xsltTransformContextPtr ctxt;
1146 PyObject *pyobj_ctxt;
1147
1148 if (!PyArg_ParseTuple(args, (char *)"O:xsltInitCtxtExts", &pyobj_ctxt))
1149 return(NULL);
1150 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1151
1152 c_retval = xsltInitCtxtExts(ctxt);
1153 py_retval = libxml_intWrap((int) c_retval);
1154 return(py_retval);
1155}
1156
1157PyObject *
1158libxslt_xsltStylesheetGetEncoding(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1159 PyObject *py_retval;
1160 const xmlChar * c_retval;
1161 xsltStylesheetPtr style;
1162 PyObject *pyobj_style;
1163
1164 if (!PyArg_ParseTuple(args, (char *)"O:xsltStylesheetGetEncoding", &pyobj_style))
1165 return(NULL);
1166 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1167
1168 c_retval = style->encoding;
1169 py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1170 return(py_retval);
1171}
1172
1173PyObject *
1174libxslt_xsltTransformGetMode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1175 PyObject *py_retval;
1176 const xmlChar * c_retval;
1177 xsltTransformContextPtr ctxt;
1178 PyObject *pyobj_ctxt;
1179
1180 if (!PyArg_ParseTuple(args, (char *)"O:xsltTransformGetMode", &pyobj_ctxt))
1181 return(NULL);
1182 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1183
1184 c_retval = ctxt->mode;
1185 py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1186 return(py_retval);
1187}
1188
1189PyObject *
1190libxslt_xsltTransformGetOutputURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1191 PyObject *py_retval;
1192 const char * c_retval;
1193 xsltTransformContextPtr ctxt;
1194 PyObject *pyobj_ctxt;
1195
1196 if (!PyArg_ParseTuple(args, (char *)"O:xsltTransformGetOutputURI", &pyobj_ctxt))
1197 return(NULL);
1198 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1199
1200 c_retval = ctxt->outputFile;
1201 py_retval = libxml_charPtrConstWrap((const char *) c_retval);
1202 return(py_retval);
1203}
1204
1205PyObject *
1206libxslt_xsltFreeExts(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1207 xsltStylesheetPtr style;
1208 PyObject *pyobj_style;
1209
1210 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeExts", &pyobj_style))
1211 return(NULL);
1212 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1213
1214 xsltFreeExts(style);
1215 Py_INCREF(Py_None);
1216 return(Py_None);
1217}
1218
1219PyObject *
1220libxslt_xsltParseGlobalParam(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1221 xsltStylesheetPtr style;
1222 PyObject *pyobj_style;
1223 xmlNodePtr cur;
1224 PyObject *pyobj_cur;
1225
1226 if (!PyArg_ParseTuple(args, (char *)"OO:xsltParseGlobalParam", &pyobj_style, &pyobj_cur))
1227 return(NULL);
1228 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1229 cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1230
1231 xsltParseGlobalParam(style, cur);
1232 Py_INCREF(Py_None);
1233 return(Py_None);
1234}
1235
1236PyObject *
1237libxslt_xsltParseStylesheetParam(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1238 xsltTransformContextPtr ctxt;
1239 PyObject *pyobj_ctxt;
1240 xmlNodePtr cur;
1241 PyObject *pyobj_cur;
1242
1243 if (!PyArg_ParseTuple(args, (char *)"OO:xsltParseStylesheetParam", &pyobj_ctxt, &pyobj_cur))
1244 return(NULL);
1245 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1246 cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1247
1248 xsltParseStylesheetParam(ctxt, cur);
1249 Py_INCREF(Py_None);
1250 return(Py_None);
1251}
1252
1253PyObject *
1254libxslt_xsltParseStylesheetOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1255 xsltStylesheetPtr style;
1256 PyObject *pyobj_style;
1257 xmlNodePtr cur;
1258 PyObject *pyobj_cur;
1259
1260 if (!PyArg_ParseTuple(args, (char *)"OO:xsltParseStylesheetOutput", &pyobj_style, &pyobj_cur))
1261 return(NULL);
1262 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1263 cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1264
1265 xsltParseStylesheetOutput(style, cur);
1266 Py_INCREF(Py_None);
1267 return(Py_None);
1268}
1269
1270PyObject *
1271libxslt_xsltFreeStylePreComps(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1272 xsltStylesheetPtr style;
1273 PyObject *pyobj_style;
1274
1275 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeStylePreComps", &pyobj_style))
1276 return(NULL);
1277 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1278
1279 xsltFreeStylePreComps(style);
1280 Py_INCREF(Py_None);
1281 return(Py_None);
1282}
1283
1284PyObject *
1285libxslt_xsltFreeNamespaceAliasHashes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1286 xsltStylesheetPtr style;
1287 PyObject *pyobj_style;
1288
1289 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeNamespaceAliasHashes", &pyobj_style))
1290 return(NULL);
1291 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1292
1293 xsltFreeNamespaceAliasHashes(style);
1294 Py_INCREF(Py_None);
1295 return(Py_None);
1296}
1297
1298PyObject *
1299libxslt_xsltGetPlainNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1300 PyObject *py_retval;
1301 xmlNsPtr c_retval;
1302 xsltTransformContextPtr ctxt;
1303 PyObject *pyobj_ctxt;
1304 xmlNodePtr cur;
1305 PyObject *pyobj_cur;
1306 xmlNsPtr ns;
1307 PyObject *pyobj_ns;
1308 xmlNodePtr out;
1309 PyObject *pyobj_out;
1310
1311 if (!PyArg_ParseTuple(args, (char *)"OOOO:xsltGetPlainNamespace", &pyobj_ctxt, &pyobj_cur, &pyobj_ns, &pyobj_out))
1312 return(NULL);
1313 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1314 cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1315 ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
1316 out = (xmlNodePtr) PyxmlNode_Get(pyobj_out);
1317
1318 c_retval = xsltGetPlainNamespace(ctxt, cur, ns, out);
1319 py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
1320 return(py_retval);
1321}
1322
1323PyObject *
1324libxslt_xsltQuoteOneUserParam(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1325 PyObject *py_retval;
1326 int c_retval;
1327 xsltTransformContextPtr ctxt;
1328 PyObject *pyobj_ctxt;
1329 xmlChar * name;
1330 xmlChar * value;
1331
1332 if (!PyArg_ParseTuple(args, (char *)"Ozz:xsltQuoteOneUserParam", &pyobj_ctxt, &name, &value))
1333 return(NULL);
1334 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1335
1336 c_retval = xsltQuoteOneUserParam(ctxt, name, value);
1337 py_retval = libxml_intWrap((int) c_retval);
1338 return(py_retval);
1339}
1340
1341PyObject *
1342libxslt_xsltUnregisterExtModule(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1343 PyObject *py_retval;
1344 int c_retval;
1345 xmlChar * URI;
1346
1347 if (!PyArg_ParseTuple(args, (char *)"z:xsltUnregisterExtModule", &URI))
1348 return(NULL);
1349
1350 c_retval = xsltUnregisterExtModule(URI);
1351 py_retval = libxml_intWrap((int) c_retval);
1352 return(py_retval);
1353}
1354
1355PyObject *
1356libxslt_xsltTransformGetInsertNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1357 PyObject *py_retval;
1358 xmlNodePtr c_retval;
1359 xsltTransformContextPtr ctxt;
1360 PyObject *pyobj_ctxt;
1361
1362 if (!PyArg_ParseTuple(args, (char *)"O:xsltTransformGetInsertNode", &pyobj_ctxt))
1363 return(NULL);
1364 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1365
1366 c_retval = ctxt->insert;
1367 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1368 return(py_retval);
1369}
1370
1371PyObject *
1372libxslt_xsltStylesheetGetNext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1373 PyObject *py_retval;
1374 xsltStylesheetPtr c_retval;
1375 xsltStylesheetPtr style;
1376 PyObject *pyobj_style;
1377
1378 if (!PyArg_ParseTuple(args, (char *)"O:xsltStylesheetGetNext", &pyobj_style))
1379 return(NULL);
1380 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1381
1382 c_retval = style->next;
1383 py_retval = libxslt_xsltStylesheetPtrWrap((xsltStylesheetPtr) c_retval);
1384 return(py_retval);
1385}
1386
1387PyObject *
1388libxslt_xsltXPathParserGetContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1389 PyObject *py_retval;
1390 xmlXPathContextPtr c_retval;
1391 xmlXPathParserContextPtr ctxt;
1392 PyObject *pyobj_ctxt;
1393
1394 if (!PyArg_ParseTuple(args, (char *)"O:xsltXPathParserGetContext", &pyobj_ctxt))
1395 return(NULL);
1396 ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1397
1398 c_retval = ctxt->context;
1399 py_retval = libxml_xmlXPathContextPtrWrap((xmlXPathContextPtr) c_retval);
1400 return(py_retval);
1401}
1402
1403PyObject *
1404libxslt_xsltUnregisterExtModuleElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1405 PyObject *py_retval;
1406 int c_retval;
1407 xmlChar * name;
1408 xmlChar * URI;
1409
1410 if (!PyArg_ParseTuple(args, (char *)"zz:xsltUnregisterExtModuleElement", &name, &URI))
1411 return(NULL);
1412
1413 c_retval = xsltUnregisterExtModuleElement(name, URI);
1414 py_retval = libxml_intWrap((int) c_retval);
1415 return(py_retval);
1416}
1417
1418PyObject *
1419libxslt_xsltTimestamp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1420 PyObject *py_retval;
1421 long c_retval;
1422
1423 c_retval = xsltTimestamp();
1424 py_retval = libxml_longWrap((long) c_retval);
1425 return(py_retval);
1426}
1427
1428PyObject *
1429libxslt_xsltParseStylesheetInclude(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1430 PyObject *py_retval;
1431 int c_retval;
1432 xsltStylesheetPtr style;
1433 PyObject *pyobj_style;
1434 xmlNodePtr cur;
1435 PyObject *pyobj_cur;
1436
1437 if (!PyArg_ParseTuple(args, (char *)"OO:xsltParseStylesheetInclude", &pyobj_style, &pyobj_cur))
1438 return(NULL);
1439 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1440 cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1441
1442 c_retval = xsltParseStylesheetInclude(style, cur);
1443 py_retval = libxml_intWrap((int) c_retval);
1444 return(py_retval);
1445}
1446
1447PyObject *
1448libxslt_xsltFreeTemplateHashes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1449 xsltStylesheetPtr style;
1450 PyObject *pyobj_style;
1451
1452 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeTemplateHashes", &pyobj_style))
1453 return(NULL);
1454 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1455
1456 xsltFreeTemplateHashes(style);
1457 Py_INCREF(Py_None);
1458 return(Py_None);
1459}
1460
1461PyObject *
1462libxslt_xsltSaveResultToFilename(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1463 PyObject *py_retval;
1464 int c_retval;
1465 char * URL;
1466 xmlDocPtr result;
1467 PyObject *pyobj_result;
1468 xsltStylesheetPtr style;
1469 PyObject *pyobj_style;
1470 int compression;
1471
1472 if (!PyArg_ParseTuple(args, (char *)"zOOi:xsltSaveResultToFilename", &URL, &pyobj_result, &pyobj_style, &compression))
1473 return(NULL);
1474 result = (xmlDocPtr) PyxmlNode_Get(pyobj_result);
1475 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1476
1477 c_retval = xsltSaveResultToFilename(URL, result, style, compression);
1478 py_retval = libxml_intWrap((int) c_retval);
1479 return(py_retval);
1480}
1481
1482PyObject *
1483libxslt_xsltSetCtxtParseOptions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1484 PyObject *py_retval;
1485 int c_retval;
1486 xsltTransformContextPtr ctxt;
1487 PyObject *pyobj_ctxt;
1488 int options;
1489
1490 if (!PyArg_ParseTuple(args, (char *)"Oi:xsltSetCtxtParseOptions", &pyobj_ctxt, &options))
1491 return(NULL);
1492 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1493
1494 c_retval = xsltSetCtxtParseOptions(ctxt, options);
1495 py_retval = libxml_intWrap((int) c_retval);
1496 return(py_retval);
1497}
1498
1499PyObject *
1500libxslt_xsltGetProfileInformation(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1501 PyObject *py_retval;
1502 xmlDocPtr c_retval;
1503 xsltTransformContextPtr ctxt;
1504 PyObject *pyobj_ctxt;
1505
1506 if (!PyArg_ParseTuple(args, (char *)"O:xsltGetProfileInformation", &pyobj_ctxt))
1507 return(NULL);
1508 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1509
1510 c_retval = xsltGetProfileInformation(ctxt);
1511 py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
1512 return(py_retval);
1513}
1514
1515PyObject *
1516libxslt_xsltFreeStyleDocuments(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1517 xsltStylesheetPtr style;
1518 PyObject *pyobj_style;
1519
1520 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeStyleDocuments", &pyobj_style))
1521 return(NULL);
1522 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1523
1524 xsltFreeStyleDocuments(style);
1525 Py_INCREF(Py_None);
1526 return(Py_None);
1527}
1528
1529PyObject *
1530libxslt_xsltRegisterPersistRVT(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1531 PyObject *py_retval;
1532 int c_retval;
1533 xsltTransformContextPtr ctxt;
1534 PyObject *pyobj_ctxt;
1535 xmlDocPtr RVT;
1536 PyObject *pyobj_RVT;
1537
1538 if (!PyArg_ParseTuple(args, (char *)"OO:xsltRegisterPersistRVT", &pyobj_ctxt, &pyobj_RVT))
1539 return(NULL);
1540 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1541 RVT = (xmlDocPtr) PyxmlNode_Get(pyobj_RVT);
1542
1543 c_retval = xsltRegisterPersistRVT(ctxt, RVT);
1544 py_retval = libxml_intWrap((int) c_retval);
1545 return(py_retval);
1546}
1547
1548PyObject *
1549libxslt_xsltResolveStylesheetAttributeSet(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1550 xsltStylesheetPtr style;
1551 PyObject *pyobj_style;
1552
1553 if (!PyArg_ParseTuple(args, (char *)"O:xsltResolveStylesheetAttributeSet", &pyobj_style))
1554 return(NULL);
1555 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1556
1557 xsltResolveStylesheetAttributeSet(style);
1558 Py_INCREF(Py_None);
1559 return(Py_None);
1560}
1561
1562PyObject *
1563libxslt_xsltGetNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1564 PyObject *py_retval;
1565 xmlNsPtr c_retval;
1566 xsltTransformContextPtr ctxt;
1567 PyObject *pyobj_ctxt;
1568 xmlNodePtr cur;
1569 PyObject *pyobj_cur;
1570 xmlNsPtr ns;
1571 PyObject *pyobj_ns;
1572 xmlNodePtr out;
1573 PyObject *pyobj_out;
1574
1575 if (!PyArg_ParseTuple(args, (char *)"OOOO:xsltGetNamespace", &pyobj_ctxt, &pyobj_cur, &pyobj_ns, &pyobj_out))
1576 return(NULL);
1577 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1578 cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1579 ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
1580 out = (xmlNodePtr) PyxmlNode_Get(pyobj_out);
1581
1582 c_retval = xsltGetNamespace(ctxt, cur, ns, out);
1583 py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
1584 return(py_retval);
1585}
1586
1587PyObject *
1588libxslt_xsltEvalAttrValueTemplate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1589 PyObject *py_retval;
1590 xmlChar * c_retval;
1591 xsltTransformContextPtr ctxt;
1592 PyObject *pyobj_ctxt;
1593 xmlNodePtr inst;
1594 PyObject *pyobj_inst;
1595 xmlChar * name;
1596 xmlChar * ns;
1597
1598 if (!PyArg_ParseTuple(args, (char *)"OOzz:xsltEvalAttrValueTemplate", &pyobj_ctxt, &pyobj_inst, &name, &ns))
1599 return(NULL);
1600 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1601 inst = (xmlNodePtr) PyxmlNode_Get(pyobj_inst);
1602
1603 c_retval = xsltEvalAttrValueTemplate(ctxt, inst, name, ns);
1604 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1605 return(py_retval);
1606}
1607
1608PyObject *
1609libxslt_xsltShutdownCtxtExts(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1610 xsltTransformContextPtr ctxt;
1611 PyObject *pyobj_ctxt;
1612
1613 if (!PyArg_ParseTuple(args, (char *)"O:xsltShutdownCtxtExts", &pyobj_ctxt))
1614 return(NULL);
1615 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1616
1617 xsltShutdownCtxtExts(ctxt);
1618 Py_INCREF(Py_None);
1619 return(Py_None);
1620}
1621
1622PyObject *
1623libxslt_xsltTransformGetCurrent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1624 PyObject *py_retval;
1625 xmlNodePtr c_retval;
1626 xsltTransformContextPtr ctxt;
1627 PyObject *pyobj_ctxt;
1628
1629 if (!PyArg_ParseTuple(args, (char *)"O:xsltTransformGetCurrent", &pyobj_ctxt))
1630 return(NULL);
1631 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1632
1633 c_retval = ctxt->node;
1634 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1635 return(py_retval);
1636}
1637
1638PyObject *
1639libxslt_xsltRegisterTmpRVT(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1640 PyObject *py_retval;
1641 int c_retval;
1642 xsltTransformContextPtr ctxt;
1643 PyObject *pyobj_ctxt;
1644 xmlDocPtr RVT;
1645 PyObject *pyobj_RVT;
1646
1647 if (!PyArg_ParseTuple(args, (char *)"OO:xsltRegisterTmpRVT", &pyobj_ctxt, &pyobj_RVT))
1648 return(NULL);
1649 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1650 RVT = (xmlDocPtr) PyxmlNode_Get(pyobj_RVT);
1651
1652 c_retval = xsltRegisterTmpRVT(ctxt, RVT);
1653 py_retval = libxml_intWrap((int) c_retval);
1654 return(py_retval);
1655}
1656
1657PyObject *
1658libxslt_xsltPrintErrorContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1659 xsltTransformContextPtr ctxt;
1660 PyObject *pyobj_ctxt;
1661 xsltStylesheetPtr style;
1662 PyObject *pyobj_style;
1663 xmlNodePtr node;
1664 PyObject *pyobj_node;
1665
1666 if (!PyArg_ParseTuple(args, (char *)"OOO:xsltPrintErrorContext", &pyobj_ctxt, &pyobj_style, &pyobj_node))
1667 return(NULL);
1668 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1669 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1670 node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
1671
1672 xsltPrintErrorContext(ctxt, style, node);
1673 Py_INCREF(Py_None);
1674 return(Py_None);
1675}
1676
1677PyObject *
1678libxslt_xsltStylesheetGetDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1679 PyObject *py_retval;
1680 xmlDocPtr c_retval;
1681 xsltStylesheetPtr style;
1682 PyObject *pyobj_style;
1683
1684 if (!PyArg_ParseTuple(args, (char *)"O:xsltStylesheetGetDoc", &pyobj_style))
1685 return(NULL);
1686 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1687
1688 c_retval = style->doc;
1689 py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
1690 return(py_retval);
1691}
1692
1693PyObject *
1694libxslt_xsltGetCNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1695 PyObject *py_retval;
1696 const xmlChar * c_retval;
1697 xsltStylesheetPtr style;
1698 PyObject *pyobj_style;
1699 xmlNodePtr node;
1700 PyObject *pyobj_node;
1701 xmlChar * name;
1702 xmlChar * nameSpace;
1703
1704 if (!PyArg_ParseTuple(args, (char *)"OOzz:xsltGetCNsProp", &pyobj_style, &pyobj_node, &name, &nameSpace))
1705 return(NULL);
1706 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1707 node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
1708
1709 c_retval = xsltGetCNsProp(style, node, name, nameSpace);
1710 py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1711 return(py_retval);
1712}
1713
1714PyObject *
1715libxslt_xsltSystemPropertyFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1716 xmlXPathParserContextPtr ctxt;
1717 PyObject *pyobj_ctxt;
1718 int nargs;
1719
1720 if (!PyArg_ParseTuple(args, (char *)"Oi:xsltSystemPropertyFunction", &pyobj_ctxt, &nargs))
1721 return(NULL);
1722 ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1723
1724 xsltSystemPropertyFunction(ctxt, nargs);
1725 Py_INCREF(Py_None);
1726 return(Py_None);
1727}
1728
1729PyObject *
1730libxslt_xsltDebugDumpExtensions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1731 FILE * output;
1732 PyObject *pyobj_output;
1733
1734 if (!PyArg_ParseTuple(args, (char *)"O:xsltDebugDumpExtensions", &pyobj_output))
1735 return(NULL);
1736 output = (FILE *) PyFile_Get(pyobj_output);
1737
1738 xsltDebugDumpExtensions(output);
1739 Py_INCREF(Py_None);
1740 return(Py_None);
1741}
1742
1743PyObject *
1744libxslt_xsltStylePreCompute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1745 xsltStylesheetPtr style;
1746 PyObject *pyobj_style;
1747 xmlNodePtr inst;
1748 PyObject *pyobj_inst;
1749
1750 if (!PyArg_ParseTuple(args, (char *)"OO:xsltStylePreCompute", &pyobj_style, &pyobj_inst))
1751 return(NULL);
1752 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1753 inst = (xmlNodePtr) PyxmlNode_Get(pyobj_inst);
1754
1755 xsltStylePreCompute(style, inst);
1756 Py_INCREF(Py_None);
1757 return(Py_None);
1758}
1759
1760PyObject *
1761libxslt_xsltFreeStylesheet(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1762 xsltStylesheetPtr style;
1763 PyObject *pyobj_style;
1764
1765 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeStylesheet", &pyobj_style))
1766 return(NULL);
1767 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1768
1769 xsltFreeStylesheet(style);
1770 Py_INCREF(Py_None);
1771 return(Py_None);
1772}
1773
1774PyObject *
1775libxslt_xsltFreeAttributeSetsHashes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1776 xsltStylesheetPtr style;
1777 PyObject *pyobj_style;
1778
1779 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeAttributeSetsHashes", &pyobj_style))
1780 return(NULL);
1781 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1782
1783 xsltFreeAttributeSetsHashes(style);
1784 Py_INCREF(Py_None);
1785 return(Py_None);
1786}
1787
1788PyObject *
1789libxslt_xsltRegisterAllExtras(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1790
1791 xsltRegisterAllExtras();
1792 Py_INCREF(Py_None);
1793 return(Py_None);
1794}
1795
1796PyObject *
1797libxslt_xsltTransformGetStyle(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1798 PyObject *py_retval;
1799 xsltStylesheetPtr c_retval;
1800 xsltTransformContextPtr ctxt;
1801 PyObject *pyobj_ctxt;
1802
1803 if (!PyArg_ParseTuple(args, (char *)"O:xsltTransformGetStyle", &pyobj_ctxt))
1804 return(NULL);
1805 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1806
1807 c_retval = ctxt->style;
1808 py_retval = libxslt_xsltStylesheetPtrWrap((xsltStylesheetPtr) c_retval);
1809 return(py_retval);
1810}
1811
1812PyObject *
1813libxslt_xsltCompileAttr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1814 xsltStylesheetPtr style;
1815 PyObject *pyobj_style;
1816 xmlAttrPtr attr;
1817 PyObject *pyobj_attr;
1818
1819 if (!PyArg_ParseTuple(args, (char *)"OO:xsltCompileAttr", &pyobj_style, &pyobj_attr))
1820 return(NULL);
1821 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1822 attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
1823
1824 xsltCompileAttr(style, attr);
1825 Py_INCREF(Py_None);
1826 return(Py_None);
1827}
1828
1829PyObject *
1830libxslt_xsltFreeRVTs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1831 xsltTransformContextPtr ctxt;
1832 PyObject *pyobj_ctxt;
1833
1834 if (!PyArg_ParseTuple(args, (char *)"O:xsltFreeRVTs", &pyobj_ctxt))
1835 return(NULL);
1836 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1837
1838 xsltFreeRVTs(ctxt);
1839 Py_INCREF(Py_None);
1840 return(Py_None);
1841}
1842
1843PyObject *
1844libxslt_xsltIsBlank(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1845 PyObject *py_retval;
1846 int c_retval;
1847 xmlChar * str;
1848
1849 if (!PyArg_ParseTuple(args, (char *)"z:xsltIsBlank", &str))
1850 return(NULL);
1851
1852 c_retval = xsltIsBlank(str);
1853 py_retval = libxml_intWrap((int) c_retval);
1854 return(py_retval);
1855}
1856
1857PyObject *
1858libxslt_xsltStylesheetGetDoctypeSystem(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1859 PyObject *py_retval;
1860 const xmlChar * c_retval;
1861 xsltStylesheetPtr style;
1862 PyObject *pyobj_style;
1863
1864 if (!PyArg_ParseTuple(args, (char *)"O:xsltStylesheetGetDoctypeSystem", &pyobj_style))
1865 return(NULL);
1866 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1867
1868 c_retval = style->doctypeSystem;
1869 py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1870 return(py_retval);
1871}
1872
1873PyObject *
1874libxslt_xsltDebug(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1875 xsltTransformContextPtr ctxt;
1876 PyObject *pyobj_ctxt;
1877 xmlNodePtr node;
1878 PyObject *pyobj_node;
1879 xmlNodePtr inst;
1880 PyObject *pyobj_inst;
1881 xsltStylePreCompPtr comp;
1882 PyObject *pyobj_comp;
1883
1884 if (!PyArg_ParseTuple(args, (char *)"OOOO:xsltDebug", &pyobj_ctxt, &pyobj_node, &pyobj_inst, &pyobj_comp))
1885 return(NULL);
1886 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1887 node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
1888 inst = (xmlNodePtr) PyxmlNode_Get(pyobj_inst);
1889 comp = (xsltStylePreCompPtr) PycompiledStyle_Get(pyobj_comp);
1890
1891 xsltDebug(ctxt, node, inst, comp);
1892 Py_INCREF(Py_None);
1893 return(Py_None);
1894}
1895
1896PyObject *
1897libxslt_xsltStylesheetGetMethodURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1898 PyObject *py_retval;
1899 const xmlChar * c_retval;
1900 xsltStylesheetPtr style;
1901 PyObject *pyobj_style;
1902
1903 if (!PyArg_ParseTuple(args, (char *)"O:xsltStylesheetGetMethodURI", &pyobj_style))
1904 return(NULL);
1905 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1906
1907 c_retval = style->methodURI;
1908 py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1909 return(py_retval);
1910}
1911
1912PyObject *
1913libxslt_xsltRegisterLocalRVT(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1914 PyObject *py_retval;
1915 int c_retval;
1916 xsltTransformContextPtr ctxt;
1917 PyObject *pyobj_ctxt;
1918 xmlDocPtr RVT;
1919 PyObject *pyobj_RVT;
1920
1921 if (!PyArg_ParseTuple(args, (char *)"OO:xsltRegisterLocalRVT", &pyobj_ctxt, &pyobj_RVT))
1922 return(NULL);
1923 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1924 RVT = (xmlDocPtr) PyxmlNode_Get(pyobj_RVT);
1925
1926 c_retval = xsltRegisterLocalRVT(ctxt, RVT);
1927 py_retval = libxml_intWrap((int) c_retval);
1928 return(py_retval);
1929}
1930
1931PyObject *
1932libxslt_xsltParseStylesheetDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1933 PyObject *py_retval;
1934 xsltStylesheetPtr c_retval;
1935 xmlDocPtr doc;
1936 PyObject *pyobj_doc;
1937
1938 if (!PyArg_ParseTuple(args, (char *)"O:xsltParseStylesheetDoc", &pyobj_doc))
1939 return(NULL);
1940 doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1941
1942 c_retval = xsltParseStylesheetDoc(doc);
1943 py_retval = libxslt_xsltStylesheetPtrWrap((xsltStylesheetPtr) c_retval);
1944 return(py_retval);
1945}
1946
1947PyObject *
1948libxslt_xsltKeyFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1949 xmlXPathParserContextPtr ctxt;
1950 PyObject *pyobj_ctxt;
1951 int nargs;
1952
1953 if (!PyArg_ParseTuple(args, (char *)"Oi:xsltKeyFunction", &pyobj_ctxt, &nargs))
1954 return(NULL);
1955 ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1956
1957 xsltKeyFunction(ctxt, nargs);
1958 Py_INCREF(Py_None);
1959 return(Py_None);
1960}
1961
1962PyObject *
1963libxslt_xsltTransformGetModeURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1964 PyObject *py_retval;
1965 const xmlChar * c_retval;
1966 xsltTransformContextPtr ctxt;
1967 PyObject *pyobj_ctxt;
1968
1969 if (!PyArg_ParseTuple(args, (char *)"O:xsltTransformGetModeURI", &pyobj_ctxt))
1970 return(NULL);
1971 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
1972
1973 c_retval = ctxt->modeURI;
1974 py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1975 return(py_retval);
1976}
1977
1978PyObject *
1979libxslt_xsltRegisterExtPrefix(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1980 PyObject *py_retval;
1981 int c_retval;
1982 xsltStylesheetPtr style;
1983 PyObject *pyobj_style;
1984 xmlChar * prefix;
1985 xmlChar * URI;
1986
1987 if (!PyArg_ParseTuple(args, (char *)"Ozz:xsltRegisterExtPrefix", &pyobj_style, &prefix, &URI))
1988 return(NULL);
1989 style = (xsltStylesheetPtr) Pystylesheet_Get(pyobj_style);
1990
1991 c_retval = xsltRegisterExtPrefix(style, prefix, URI);
1992 py_retval = libxml_intWrap((int) c_retval);
1993 return(py_retval);
1994}
1995
1996PyObject *
1997libxslt_xslDropCall(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1998
1999 xslDropCall();
2000 Py_INCREF(Py_None);
2001 return(Py_None);
2002}
2003
2004PyObject *
2005libxslt_xsltVariableLookup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2006 PyObject *py_retval;
2007 xmlXPathObjectPtr c_retval;
2008 xsltTransformContextPtr ctxt;
2009 PyObject *pyobj_ctxt;
2010 xmlChar * name;
2011 xmlChar * ns_uri;
2012
2013 if (!PyArg_ParseTuple(args, (char *)"Ozz:xsltVariableLookup", &pyobj_ctxt, &name, &ns_uri))
2014 return(NULL);
2015 ctxt = (xsltTransformContextPtr) PytransformCtxt_Get(pyobj_ctxt);
2016
2017 c_retval = xsltVariableLookup(ctxt, name, ns_uri);
2018 py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
2019 return(py_retval);
2020}
2021
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette