Annotation of embedaddon/libxml2/python/libxml2class.py, revision 1.1.1.1
1.1 misho 1: #
2: # Functions from module HTMLparser
3: #
4:
5: def htmlCreateMemoryParserCtxt(buffer, size):
6: """Create a parser context for an HTML in-memory document. """
7: ret = libxml2mod.htmlCreateMemoryParserCtxt(buffer, size)
8: if ret is None:raise parserError('htmlCreateMemoryParserCtxt() failed')
9: return parserCtxt(_obj=ret)
10:
11: def htmlHandleOmittedElem(val):
12: """Set and return the previous value for handling HTML omitted
13: tags. """
14: ret = libxml2mod.htmlHandleOmittedElem(val)
15: return ret
16:
17: def htmlIsScriptAttribute(name):
18: """Check if an attribute is of content type Script """
19: ret = libxml2mod.htmlIsScriptAttribute(name)
20: return ret
21:
22: def htmlNewParserCtxt():
23: """Allocate and initialize a new parser context. """
24: ret = libxml2mod.htmlNewParserCtxt()
25: if ret is None:raise parserError('htmlNewParserCtxt() failed')
26: return parserCtxt(_obj=ret)
27:
28: def htmlParseDoc(cur, encoding):
29: """parse an HTML in-memory document and build a tree. """
30: ret = libxml2mod.htmlParseDoc(cur, encoding)
31: if ret is None:raise parserError('htmlParseDoc() failed')
32: return xmlDoc(_obj=ret)
33:
34: def htmlParseFile(filename, encoding):
35: """parse an HTML file and build a tree. Automatic support for
36: ZLIB/Compress compressed document is provided by default if
37: found at compile-time. """
38: ret = libxml2mod.htmlParseFile(filename, encoding)
39: if ret is None:raise parserError('htmlParseFile() failed')
40: return xmlDoc(_obj=ret)
41:
42: def htmlReadDoc(cur, URL, encoding, options):
43: """parse an XML in-memory document and build a tree. """
44: ret = libxml2mod.htmlReadDoc(cur, URL, encoding, options)
45: if ret is None:raise treeError('htmlReadDoc() failed')
46: return xmlDoc(_obj=ret)
47:
48: def htmlReadFd(fd, URL, encoding, options):
49: """parse an XML from a file descriptor and build a tree. """
50: ret = libxml2mod.htmlReadFd(fd, URL, encoding, options)
51: if ret is None:raise treeError('htmlReadFd() failed')
52: return xmlDoc(_obj=ret)
53:
54: def htmlReadFile(filename, encoding, options):
55: """parse an XML file from the filesystem or the network. """
56: ret = libxml2mod.htmlReadFile(filename, encoding, options)
57: if ret is None:raise treeError('htmlReadFile() failed')
58: return xmlDoc(_obj=ret)
59:
60: def htmlReadMemory(buffer, size, URL, encoding, options):
61: """parse an XML in-memory document and build a tree. """
62: ret = libxml2mod.htmlReadMemory(buffer, size, URL, encoding, options)
63: if ret is None:raise treeError('htmlReadMemory() failed')
64: return xmlDoc(_obj=ret)
65:
66: #
67: # Functions from module HTMLtree
68: #
69:
70: def htmlIsBooleanAttr(name):
71: """Determine if a given attribute is a boolean attribute. """
72: ret = libxml2mod.htmlIsBooleanAttr(name)
73: return ret
74:
75: def htmlNewDoc(URI, ExternalID):
76: """Creates a new HTML document """
77: ret = libxml2mod.htmlNewDoc(URI, ExternalID)
78: if ret is None:raise treeError('htmlNewDoc() failed')
79: return xmlDoc(_obj=ret)
80:
81: def htmlNewDocNoDtD(URI, ExternalID):
82: """Creates a new HTML document without a DTD node if @URI and
83: @ExternalID are None """
84: ret = libxml2mod.htmlNewDocNoDtD(URI, ExternalID)
85: if ret is None:raise treeError('htmlNewDocNoDtD() failed')
86: return xmlDoc(_obj=ret)
87:
88: #
89: # Functions from module SAX2
90: #
91:
92: def SAXDefaultVersion(version):
93: """Set the default version of SAX used globally by the
94: library. By default, during initialization the default is
95: set to 2. Note that it is generally a better coding style
96: to use xmlSAXVersion() to set up the version explicitly for
97: a given parsing context. """
98: ret = libxml2mod.xmlSAXDefaultVersion(version)
99: return ret
100:
101: def defaultSAXHandlerInit():
102: """Initialize the default SAX2 handler """
103: libxml2mod.xmlDefaultSAXHandlerInit()
104:
105: def docbDefaultSAXHandlerInit():
106: """Initialize the default SAX handler """
107: libxml2mod.docbDefaultSAXHandlerInit()
108:
109: def htmlDefaultSAXHandlerInit():
110: """Initialize the default SAX handler """
111: libxml2mod.htmlDefaultSAXHandlerInit()
112:
113: #
114: # Functions from module catalog
115: #
116:
117: def catalogAdd(type, orig, replace):
118: """Add an entry in the catalog, it may overwrite existing but
119: different entries. If called before any other catalog
120: routine, allows to override the default shared catalog put
121: in place by xmlInitializeCatalog(); """
122: ret = libxml2mod.xmlCatalogAdd(type, orig, replace)
123: return ret
124:
125: def catalogCleanup():
126: """Free up all the memory associated with catalogs """
127: libxml2mod.xmlCatalogCleanup()
128:
129: def catalogConvert():
130: """Convert all the SGML catalog entries as XML ones """
131: ret = libxml2mod.xmlCatalogConvert()
132: return ret
133:
134: def catalogDump(out):
135: """Dump all the global catalog content to the given file. """
136: if out is not None: out.flush()
137: libxml2mod.xmlCatalogDump(out)
138:
139: def catalogGetPublic(pubID):
140: """Try to lookup the catalog reference associated to a public
141: ID DEPRECATED, use xmlCatalogResolvePublic() """
142: ret = libxml2mod.xmlCatalogGetPublic(pubID)
143: return ret
144:
145: def catalogGetSystem(sysID):
146: """Try to lookup the catalog reference associated to a system
147: ID DEPRECATED, use xmlCatalogResolveSystem() """
148: ret = libxml2mod.xmlCatalogGetSystem(sysID)
149: return ret
150:
151: def catalogRemove(value):
152: """Remove an entry from the catalog """
153: ret = libxml2mod.xmlCatalogRemove(value)
154: return ret
155:
156: def catalogResolve(pubID, sysID):
157: """Do a complete resolution lookup of an External Identifier """
158: ret = libxml2mod.xmlCatalogResolve(pubID, sysID)
159: return ret
160:
161: def catalogResolvePublic(pubID):
162: """Try to lookup the catalog reference associated to a public
163: ID """
164: ret = libxml2mod.xmlCatalogResolvePublic(pubID)
165: return ret
166:
167: def catalogResolveSystem(sysID):
168: """Try to lookup the catalog resource for a system ID """
169: ret = libxml2mod.xmlCatalogResolveSystem(sysID)
170: return ret
171:
172: def catalogResolveURI(URI):
173: """Do a complete resolution lookup of an URI """
174: ret = libxml2mod.xmlCatalogResolveURI(URI)
175: return ret
176:
177: def catalogSetDebug(level):
178: """Used to set the debug level for catalog operation, 0
179: disable debugging, 1 enable it """
180: ret = libxml2mod.xmlCatalogSetDebug(level)
181: return ret
182:
183: def initializeCatalog():
184: """Do the catalog initialization. this function is not thread
185: safe, catalog initialization should preferably be done once
186: at startup """
187: libxml2mod.xmlInitializeCatalog()
188:
189: def loadACatalog(filename):
190: """Load the catalog and build the associated data structures.
191: This can be either an XML Catalog or an SGML Catalog It
192: will recurse in SGML CATALOG entries. On the other hand XML
193: Catalogs are not handled recursively. """
194: ret = libxml2mod.xmlLoadACatalog(filename)
195: if ret is None:raise treeError('xmlLoadACatalog() failed')
196: return catalog(_obj=ret)
197:
198: def loadCatalog(filename):
199: """Load the catalog and makes its definitions effective for
200: the default external entity loader. It will recurse in SGML
201: CATALOG entries. this function is not thread safe, catalog
202: initialization should preferably be done once at startup """
203: ret = libxml2mod.xmlLoadCatalog(filename)
204: return ret
205:
206: def loadCatalogs(pathss):
207: """Load the catalogs and makes their definitions effective for
208: the default external entity loader. this function is not
209: thread safe, catalog initialization should preferably be
210: done once at startup """
211: libxml2mod.xmlLoadCatalogs(pathss)
212:
213: def loadSGMLSuperCatalog(filename):
214: """Load an SGML super catalog. It won't expand CATALOG or
215: DELEGATE references. This is only needed for manipulating
216: SGML Super Catalogs like adding and removing CATALOG or
217: DELEGATE entries. """
218: ret = libxml2mod.xmlLoadSGMLSuperCatalog(filename)
219: if ret is None:raise treeError('xmlLoadSGMLSuperCatalog() failed')
220: return catalog(_obj=ret)
221:
222: def newCatalog(sgml):
223: """create a new Catalog. """
224: ret = libxml2mod.xmlNewCatalog(sgml)
225: if ret is None:raise treeError('xmlNewCatalog() failed')
226: return catalog(_obj=ret)
227:
228: def parseCatalogFile(filename):
229: """parse an XML file and build a tree. It's like
230: xmlParseFile() except it bypass all catalog lookups. """
231: ret = libxml2mod.xmlParseCatalogFile(filename)
232: if ret is None:raise parserError('xmlParseCatalogFile() failed')
233: return xmlDoc(_obj=ret)
234:
235: #
236: # Functions from module chvalid
237: #
238:
239: def isBaseChar(ch):
240: """This function is DEPRECATED. Use xmlIsBaseChar_ch or
241: xmlIsBaseCharQ instead """
242: ret = libxml2mod.xmlIsBaseChar(ch)
243: return ret
244:
245: def isBlank(ch):
246: """This function is DEPRECATED. Use xmlIsBlank_ch or
247: xmlIsBlankQ instead """
248: ret = libxml2mod.xmlIsBlank(ch)
249: return ret
250:
251: def isChar(ch):
252: """This function is DEPRECATED. Use xmlIsChar_ch or xmlIsCharQ
253: instead """
254: ret = libxml2mod.xmlIsChar(ch)
255: return ret
256:
257: def isCombining(ch):
258: """This function is DEPRECATED. Use xmlIsCombiningQ instead """
259: ret = libxml2mod.xmlIsCombining(ch)
260: return ret
261:
262: def isDigit(ch):
263: """This function is DEPRECATED. Use xmlIsDigit_ch or
264: xmlIsDigitQ instead """
265: ret = libxml2mod.xmlIsDigit(ch)
266: return ret
267:
268: def isExtender(ch):
269: """This function is DEPRECATED. Use xmlIsExtender_ch or
270: xmlIsExtenderQ instead """
271: ret = libxml2mod.xmlIsExtender(ch)
272: return ret
273:
274: def isIdeographic(ch):
275: """This function is DEPRECATED. Use xmlIsIdeographicQ instead """
276: ret = libxml2mod.xmlIsIdeographic(ch)
277: return ret
278:
279: def isPubidChar(ch):
280: """This function is DEPRECATED. Use xmlIsPubidChar_ch or
281: xmlIsPubidCharQ instead """
282: ret = libxml2mod.xmlIsPubidChar(ch)
283: return ret
284:
285: #
286: # Functions from module debugXML
287: #
288:
289: def boolToText(boolval):
290: """Convenient way to turn bool into text """
291: ret = libxml2mod.xmlBoolToText(boolval)
292: return ret
293:
294: def debugDumpString(output, str):
295: """Dumps informations about the string, shorten it if necessary """
296: if output is not None: output.flush()
297: libxml2mod.xmlDebugDumpString(output, str)
298:
299: def shellPrintXPathError(errorType, arg):
300: """Print the xpath error to libxml default error channel """
301: libxml2mod.xmlShellPrintXPathError(errorType, arg)
302:
303: #
304: # Functions from module dict
305: #
306:
307: def dictCleanup():
308: """Free the dictionary mutex. Do not call unless sure the
309: library is not in use anymore ! """
310: libxml2mod.xmlDictCleanup()
311:
312: def initializeDict():
313: """Do the dictionary mutex initialization. this function is
314: deprecated """
315: ret = libxml2mod.xmlInitializeDict()
316: return ret
317:
318: #
319: # Functions from module encoding
320: #
321:
322: def addEncodingAlias(name, alias):
323: """Registers an alias @alias for an encoding named @name.
324: Existing alias will be overwritten. """
325: ret = libxml2mod.xmlAddEncodingAlias(name, alias)
326: return ret
327:
328: def cleanupCharEncodingHandlers():
329: """Cleanup the memory allocated for the char encoding support,
330: it unregisters all the encoding handlers and the aliases. """
331: libxml2mod.xmlCleanupCharEncodingHandlers()
332:
333: def cleanupEncodingAliases():
334: """Unregisters all aliases """
335: libxml2mod.xmlCleanupEncodingAliases()
336:
337: def delEncodingAlias(alias):
338: """Unregisters an encoding alias @alias """
339: ret = libxml2mod.xmlDelEncodingAlias(alias)
340: return ret
341:
342: def encodingAlias(alias):
343: """Lookup an encoding name for the given alias. """
344: ret = libxml2mod.xmlGetEncodingAlias(alias)
345: return ret
346:
347: def initCharEncodingHandlers():
348: """Initialize the char encoding support, it registers the
349: default encoding supported. NOTE: while public, this
350: function usually doesn't need to be called in normal
351: processing. """
352: libxml2mod.xmlInitCharEncodingHandlers()
353:
354: #
355: # Functions from module entities
356: #
357:
358: def cleanupPredefinedEntities():
359: """Cleanup up the predefined entities table. Deprecated call """
360: libxml2mod.xmlCleanupPredefinedEntities()
361:
362: def initializePredefinedEntities():
363: """Set up the predefined entities. Deprecated call """
364: libxml2mod.xmlInitializePredefinedEntities()
365:
366: def predefinedEntity(name):
367: """Check whether this name is an predefined entity. """
368: ret = libxml2mod.xmlGetPredefinedEntity(name)
369: if ret is None:raise treeError('xmlGetPredefinedEntity() failed')
370: return xmlEntity(_obj=ret)
371:
372: #
373: # Functions from module globals
374: #
375:
376: def cleanupGlobals():
377: """Additional cleanup for multi-threading """
378: libxml2mod.xmlCleanupGlobals()
379:
380: def initGlobals():
381: """Additional initialisation for multi-threading """
382: libxml2mod.xmlInitGlobals()
383:
384: def thrDefDefaultBufferSize(v):
385: ret = libxml2mod.xmlThrDefDefaultBufferSize(v)
386: return ret
387:
388: def thrDefDoValidityCheckingDefaultValue(v):
389: ret = libxml2mod.xmlThrDefDoValidityCheckingDefaultValue(v)
390: return ret
391:
392: def thrDefGetWarningsDefaultValue(v):
393: ret = libxml2mod.xmlThrDefGetWarningsDefaultValue(v)
394: return ret
395:
396: def thrDefIndentTreeOutput(v):
397: ret = libxml2mod.xmlThrDefIndentTreeOutput(v)
398: return ret
399:
400: def thrDefKeepBlanksDefaultValue(v):
401: ret = libxml2mod.xmlThrDefKeepBlanksDefaultValue(v)
402: return ret
403:
404: def thrDefLineNumbersDefaultValue(v):
405: ret = libxml2mod.xmlThrDefLineNumbersDefaultValue(v)
406: return ret
407:
408: def thrDefLoadExtDtdDefaultValue(v):
409: ret = libxml2mod.xmlThrDefLoadExtDtdDefaultValue(v)
410: return ret
411:
412: def thrDefParserDebugEntities(v):
413: ret = libxml2mod.xmlThrDefParserDebugEntities(v)
414: return ret
415:
416: def thrDefPedanticParserDefaultValue(v):
417: ret = libxml2mod.xmlThrDefPedanticParserDefaultValue(v)
418: return ret
419:
420: def thrDefSaveNoEmptyTags(v):
421: ret = libxml2mod.xmlThrDefSaveNoEmptyTags(v)
422: return ret
423:
424: def thrDefSubstituteEntitiesDefaultValue(v):
425: ret = libxml2mod.xmlThrDefSubstituteEntitiesDefaultValue(v)
426: return ret
427:
428: def thrDefTreeIndentString(v):
429: ret = libxml2mod.xmlThrDefTreeIndentString(v)
430: return ret
431:
432: #
433: # Functions from module nanoftp
434: #
435:
436: def nanoFTPCleanup():
437: """Cleanup the FTP protocol layer. This cleanup proxy
438: informations. """
439: libxml2mod.xmlNanoFTPCleanup()
440:
441: def nanoFTPInit():
442: """Initialize the FTP protocol layer. Currently it just checks
443: for proxy informations, and get the hostname """
444: libxml2mod.xmlNanoFTPInit()
445:
446: def nanoFTPProxy(host, port, user, passwd, type):
447: """Setup the FTP proxy informations. This can also be done by
448: using ftp_proxy ftp_proxy_user and ftp_proxy_password
449: environment variables. """
450: libxml2mod.xmlNanoFTPProxy(host, port, user, passwd, type)
451:
452: def nanoFTPScanProxy(URL):
453: """(Re)Initialize the FTP Proxy context by parsing the URL and
454: finding the protocol host port it indicates. Should be like
455: ftp://myproxy/ or ftp://myproxy:3128/ A None URL cleans up
456: proxy informations. """
457: libxml2mod.xmlNanoFTPScanProxy(URL)
458:
459: #
460: # Functions from module nanohttp
461: #
462:
463: def nanoHTTPCleanup():
464: """Cleanup the HTTP protocol layer. """
465: libxml2mod.xmlNanoHTTPCleanup()
466:
467: def nanoHTTPInit():
468: """Initialize the HTTP protocol layer. Currently it just
469: checks for proxy informations """
470: libxml2mod.xmlNanoHTTPInit()
471:
472: def nanoHTTPScanProxy(URL):
473: """(Re)Initialize the HTTP Proxy context by parsing the URL
474: and finding the protocol host port it indicates. Should be
475: like http://myproxy/ or http://myproxy:3128/ A None URL
476: cleans up proxy informations. """
477: libxml2mod.xmlNanoHTTPScanProxy(URL)
478:
479: #
480: # Functions from module parser
481: #
482:
483: def createDocParserCtxt(cur):
484: """Creates a parser context for an XML in-memory document. """
485: ret = libxml2mod.xmlCreateDocParserCtxt(cur)
486: if ret is None:raise parserError('xmlCreateDocParserCtxt() failed')
487: return parserCtxt(_obj=ret)
488:
489: def initParser():
490: """Initialization function for the XML parser. This is not
491: reentrant. Call once before processing in case of use in
492: multithreaded programs. """
493: libxml2mod.xmlInitParser()
494:
495: def keepBlanksDefault(val):
496: """Set and return the previous value for default blanks text
497: nodes support. The 1.x version of the parser used an
498: heuristic to try to detect ignorable white spaces. As a
499: result the SAX callback was generating
500: xmlSAX2IgnorableWhitespace() callbacks instead of
501: characters() one, and when using the DOM output text nodes
502: containing those blanks were not generated. The 2.x and
503: later version will switch to the XML standard way and
504: ignorableWhitespace() are only generated when running the
505: parser in validating mode and when the current element
506: doesn't allow CDATA or mixed content. This function is
507: provided as a way to force the standard behavior on 1.X
508: libs and to switch back to the old mode for compatibility
509: when running 1.X client code on 2.X . Upgrade of 1.X code
510: should be done by using xmlIsBlankNode() commodity function
511: to detect the "empty" nodes generated. This value also
512: affect autogeneration of indentation when saving code if
513: blanks sections are kept, indentation is not generated. """
514: ret = libxml2mod.xmlKeepBlanksDefault(val)
515: return ret
516:
517: def lineNumbersDefault(val):
518: """Set and return the previous value for enabling line numbers
519: in elements contents. This may break on old application and
520: is turned off by default. """
521: ret = libxml2mod.xmlLineNumbersDefault(val)
522: return ret
523:
524: def newParserCtxt():
525: """Allocate and initialize a new parser context. """
526: ret = libxml2mod.xmlNewParserCtxt()
527: if ret is None:raise parserError('xmlNewParserCtxt() failed')
528: return parserCtxt(_obj=ret)
529:
530: def parseDTD(ExternalID, SystemID):
531: """Load and parse an external subset. """
532: ret = libxml2mod.xmlParseDTD(ExternalID, SystemID)
533: if ret is None:raise parserError('xmlParseDTD() failed')
534: return xmlDtd(_obj=ret)
535:
536: def parseDoc(cur):
537: """parse an XML in-memory document and build a tree. """
538: ret = libxml2mod.xmlParseDoc(cur)
539: if ret is None:raise parserError('xmlParseDoc() failed')
540: return xmlDoc(_obj=ret)
541:
542: def parseEntity(filename):
543: """parse an XML external entity out of context and build a
544: tree. [78] extParsedEnt ::= TextDecl? content This
545: correspond to a "Well Balanced" chunk """
546: ret = libxml2mod.xmlParseEntity(filename)
547: if ret is None:raise parserError('xmlParseEntity() failed')
548: return xmlDoc(_obj=ret)
549:
550: def parseFile(filename):
551: """parse an XML file and build a tree. Automatic support for
552: ZLIB/Compress compressed document is provided by default if
553: found at compile-time. """
554: ret = libxml2mod.xmlParseFile(filename)
555: if ret is None:raise parserError('xmlParseFile() failed')
556: return xmlDoc(_obj=ret)
557:
558: def parseMemory(buffer, size):
559: """parse an XML in-memory block and build a tree. """
560: ret = libxml2mod.xmlParseMemory(buffer, size)
561: if ret is None:raise parserError('xmlParseMemory() failed')
562: return xmlDoc(_obj=ret)
563:
564: def pedanticParserDefault(val):
565: """Set and return the previous value for enabling pedantic
566: warnings. """
567: ret = libxml2mod.xmlPedanticParserDefault(val)
568: return ret
569:
570: def readDoc(cur, URL, encoding, options):
571: """parse an XML in-memory document and build a tree. """
572: ret = libxml2mod.xmlReadDoc(cur, URL, encoding, options)
573: if ret is None:raise treeError('xmlReadDoc() failed')
574: return xmlDoc(_obj=ret)
575:
576: def readFd(fd, URL, encoding, options):
577: """parse an XML from a file descriptor and build a tree. NOTE
578: that the file descriptor will not be closed when the reader
579: is closed or reset. """
580: ret = libxml2mod.xmlReadFd(fd, URL, encoding, options)
581: if ret is None:raise treeError('xmlReadFd() failed')
582: return xmlDoc(_obj=ret)
583:
584: def readFile(filename, encoding, options):
585: """parse an XML file from the filesystem or the network. """
586: ret = libxml2mod.xmlReadFile(filename, encoding, options)
587: if ret is None:raise treeError('xmlReadFile() failed')
588: return xmlDoc(_obj=ret)
589:
590: def readMemory(buffer, size, URL, encoding, options):
591: """parse an XML in-memory document and build a tree. """
592: ret = libxml2mod.xmlReadMemory(buffer, size, URL, encoding, options)
593: if ret is None:raise treeError('xmlReadMemory() failed')
594: return xmlDoc(_obj=ret)
595:
596: def recoverDoc(cur):
597: """parse an XML in-memory document and build a tree. In the
598: case the document is not Well Formed, a attempt to build a
599: tree is tried anyway """
600: ret = libxml2mod.xmlRecoverDoc(cur)
601: if ret is None:raise treeError('xmlRecoverDoc() failed')
602: return xmlDoc(_obj=ret)
603:
604: def recoverFile(filename):
605: """parse an XML file and build a tree. Automatic support for
606: ZLIB/Compress compressed document is provided by default if
607: found at compile-time. In the case the document is not Well
608: Formed, it attempts to build a tree anyway """
609: ret = libxml2mod.xmlRecoverFile(filename)
610: if ret is None:raise treeError('xmlRecoverFile() failed')
611: return xmlDoc(_obj=ret)
612:
613: def recoverMemory(buffer, size):
614: """parse an XML in-memory block and build a tree. In the case
615: the document is not Well Formed, an attempt to build a tree
616: is tried anyway """
617: ret = libxml2mod.xmlRecoverMemory(buffer, size)
618: if ret is None:raise treeError('xmlRecoverMemory() failed')
619: return xmlDoc(_obj=ret)
620:
621: def substituteEntitiesDefault(val):
622: """Set and return the previous value for default entity
623: support. Initially the parser always keep entity references
624: instead of substituting entity values in the output. This
625: function has to be used to change the default parser
626: behavior SAX::substituteEntities() has to be used for
627: changing that on a file by file basis. """
628: ret = libxml2mod.xmlSubstituteEntitiesDefault(val)
629: return ret
630:
631: #
632: # Functions from module parserInternals
633: #
634:
635: def checkLanguageID(lang):
636: """Checks that the value conforms to the LanguageID
637: production: NOTE: this is somewhat deprecated, those
638: productions were removed from the XML Second edition. [33]
639: LanguageID ::= Langcode ('-' Subcode)* [34] Langcode ::=
640: ISO639Code | IanaCode | UserCode [35] ISO639Code ::=
641: ([a-z] | [A-Z]) ([a-z] | [A-Z]) [36] IanaCode ::= ('i' |
642: 'I') '-' ([a-z] | [A-Z])+ [37] UserCode ::= ('x' | 'X') '-'
643: ([a-z] | [A-Z])+ [38] Subcode ::= ([a-z] | [A-Z])+ The
644: current REC reference the sucessors of RFC 1766, currently
645: 5646 http://www.rfc-editor.org/rfc/rfc5646.txt langtag
646: = language ["-" script] ["-" region] *("-" variant) *("-"
647: extension) ["-" privateuse] language = 2*3ALPHA
648: ; shortest ISO 639 code ["-" extlang] ; sometimes
649: followed by ; extended language subtags / 4ALPHA
650: ; or reserved for future use / 5*8ALPHA ; or
651: registered language subtag extlang = 3ALPHA
652: ; selected ISO 639 codes *2("-" 3ALPHA) ; permanently
653: reserved script = 4ALPHA ; ISO 15924
654: code region = 2ALPHA ; ISO 3166-1 code
655: / 3DIGIT ; UN M.49 code variant =
656: 5*8alphanum ; registered variants / (DIGIT
657: 3alphanum) extension = singleton 1*("-" (2*8alphanum))
658: ; Single alphanumerics ; "x" reserved for private use
659: singleton = DIGIT ; 0 - 9 / %x41-57
660: ; A - W / %x59-5A ; Y - Z / %x61-77
661: ; a - w / %x79-7A ; y - z it sounds right to
662: still allow Irregular i-xxx IANA and user codes too The
663: parser below doesn't try to cope with extension or
664: privateuse that could be added but that's not interoperable
665: anyway """
666: ret = libxml2mod.xmlCheckLanguageID(lang)
667: return ret
668:
669: def copyChar(len, out, val):
670: """append the char value in the array """
671: ret = libxml2mod.xmlCopyChar(len, out, val)
672: return ret
673:
674: def copyCharMultiByte(out, val):
675: """append the char value in the array """
676: ret = libxml2mod.xmlCopyCharMultiByte(out, val)
677: return ret
678:
679: def createEntityParserCtxt(URL, ID, base):
680: """Create a parser context for an external entity Automatic
681: support for ZLIB/Compress compressed document is provided
682: by default if found at compile-time. """
683: ret = libxml2mod.xmlCreateEntityParserCtxt(URL, ID, base)
684: if ret is None:raise parserError('xmlCreateEntityParserCtxt() failed')
685: return parserCtxt(_obj=ret)
686:
687: def createFileParserCtxt(filename):
688: """Create a parser context for a file content. Automatic
689: support for ZLIB/Compress compressed document is provided
690: by default if found at compile-time. """
691: ret = libxml2mod.xmlCreateFileParserCtxt(filename)
692: if ret is None:raise parserError('xmlCreateFileParserCtxt() failed')
693: return parserCtxt(_obj=ret)
694:
695: def createMemoryParserCtxt(buffer, size):
696: """Create a parser context for an XML in-memory document. """
697: ret = libxml2mod.xmlCreateMemoryParserCtxt(buffer, size)
698: if ret is None:raise parserError('xmlCreateMemoryParserCtxt() failed')
699: return parserCtxt(_obj=ret)
700:
701: def createURLParserCtxt(filename, options):
702: """Create a parser context for a file or URL content.
703: Automatic support for ZLIB/Compress compressed document is
704: provided by default if found at compile-time and for file
705: accesses """
706: ret = libxml2mod.xmlCreateURLParserCtxt(filename, options)
707: if ret is None:raise parserError('xmlCreateURLParserCtxt() failed')
708: return parserCtxt(_obj=ret)
709:
710: def htmlCreateFileParserCtxt(filename, encoding):
711: """Create a parser context for a file content. Automatic
712: support for ZLIB/Compress compressed document is provided
713: by default if found at compile-time. """
714: ret = libxml2mod.htmlCreateFileParserCtxt(filename, encoding)
715: if ret is None:raise parserError('htmlCreateFileParserCtxt() failed')
716: return parserCtxt(_obj=ret)
717:
718: def htmlInitAutoClose():
719: """Initialize the htmlStartCloseIndex for fast lookup of
720: closing tags names. This is not reentrant. Call
721: xmlInitParser() once before processing in case of use in
722: multithreaded programs. """
723: libxml2mod.htmlInitAutoClose()
724:
725: def isLetter(c):
726: """Check whether the character is allowed by the production
727: [84] Letter ::= BaseChar | Ideographic """
728: ret = libxml2mod.xmlIsLetter(c)
729: return ret
730:
731: def namePop(ctxt):
732: """Pops the top element name from the name stack """
733: if ctxt is None: ctxt__o = None
734: else: ctxt__o = ctxt._o
735: ret = libxml2mod.namePop(ctxt__o)
736: return ret
737:
738: def namePush(ctxt, value):
739: """Pushes a new element name on top of the name stack """
740: if ctxt is None: ctxt__o = None
741: else: ctxt__o = ctxt._o
742: ret = libxml2mod.namePush(ctxt__o, value)
743: return ret
744:
745: def nodePop(ctxt):
746: """Pops the top element node from the node stack """
747: if ctxt is None: ctxt__o = None
748: else: ctxt__o = ctxt._o
749: ret = libxml2mod.nodePop(ctxt__o)
750: if ret is None:raise treeError('nodePop() failed')
751: return xmlNode(_obj=ret)
752:
753: def nodePush(ctxt, value):
754: """Pushes a new element node on top of the node stack """
755: if ctxt is None: ctxt__o = None
756: else: ctxt__o = ctxt._o
757: if value is None: value__o = None
758: else: value__o = value._o
759: ret = libxml2mod.nodePush(ctxt__o, value__o)
760: return ret
761:
762: #
763: # Functions from module python
764: #
765:
766: def SAXParseFile(SAX, URI, recover):
767: """Interface to parse an XML file or resource pointed by an
768: URI to build an event flow to the SAX object """
769: libxml2mod.xmlSAXParseFile(SAX, URI, recover)
770:
771: def createInputBuffer(file, encoding):
772: """Create a libxml2 input buffer from a Python file """
773: ret = libxml2mod.xmlCreateInputBuffer(file, encoding)
774: if ret is None:raise treeError('xmlCreateInputBuffer() failed')
775: return inputBuffer(_obj=ret)
776:
777: def createOutputBuffer(file, encoding):
778: """Create a libxml2 output buffer from a Python file """
779: ret = libxml2mod.xmlCreateOutputBuffer(file, encoding)
780: if ret is None:raise treeError('xmlCreateOutputBuffer() failed')
781: return outputBuffer(_obj=ret)
782:
783: def createPushParser(SAX, chunk, size, URI):
784: """Create a progressive XML parser context to build either an
785: event flow if the SAX object is not None, or a DOM tree
786: otherwise. """
787: ret = libxml2mod.xmlCreatePushParser(SAX, chunk, size, URI)
788: if ret is None:raise parserError('xmlCreatePushParser() failed')
789: return parserCtxt(_obj=ret)
790:
791: def debugMemory(activate):
792: """Switch on the generation of line number for elements nodes.
793: Also returns the number of bytes allocated and not freed by
794: libxml2 since memory debugging was switched on. """
795: ret = libxml2mod.xmlDebugMemory(activate)
796: return ret
797:
798: def dumpMemory():
799: """dump the memory allocated in the file .memdump """
800: libxml2mod.xmlDumpMemory()
801:
802: def htmlCreatePushParser(SAX, chunk, size, URI):
803: """Create a progressive HTML parser context to build either an
804: event flow if the SAX object is not None, or a DOM tree
805: otherwise. """
806: ret = libxml2mod.htmlCreatePushParser(SAX, chunk, size, URI)
807: if ret is None:raise parserError('htmlCreatePushParser() failed')
808: return parserCtxt(_obj=ret)
809:
810: def htmlSAXParseFile(SAX, URI, encoding):
811: """Interface to parse an HTML file or resource pointed by an
812: URI to build an event flow to the SAX object """
813: libxml2mod.htmlSAXParseFile(SAX, URI, encoding)
814:
815: def memoryUsed():
816: """Returns the total amount of memory allocated by libxml2 """
817: ret = libxml2mod.xmlMemoryUsed()
818: return ret
819:
820: def newNode(name):
821: """Create a new Node """
822: ret = libxml2mod.xmlNewNode(name)
823: if ret is None:raise treeError('xmlNewNode() failed')
824: return xmlNode(_obj=ret)
825:
826: def pythonCleanupParser():
827: """Cleanup function for the XML library. It tries to reclaim
828: all parsing related global memory allocated for the library
829: processing. It doesn't deallocate any document related
830: memory. Calling this function should not prevent reusing
831: the library but one should call xmlCleanupParser() only
832: when the process has finished using the library or XML
833: document built with it. """
834: libxml2mod.xmlPythonCleanupParser()
835:
836: def setEntityLoader(resolver):
837: """Set the entity resolver as a python function """
838: ret = libxml2mod.xmlSetEntityLoader(resolver)
839: return ret
840:
841: #
842: # Functions from module relaxng
843: #
844:
845: def relaxNGCleanupTypes():
846: """Cleanup the default Schemas type library associated to
847: RelaxNG """
848: libxml2mod.xmlRelaxNGCleanupTypes()
849:
850: def relaxNGInitTypes():
851: """Initilize the default type libraries. """
852: ret = libxml2mod.xmlRelaxNGInitTypes()
853: return ret
854:
855: def relaxNGNewMemParserCtxt(buffer, size):
856: """Create an XML RelaxNGs parse context for that memory buffer
857: expected to contain an XML RelaxNGs file. """
858: ret = libxml2mod.xmlRelaxNGNewMemParserCtxt(buffer, size)
859: if ret is None:raise parserError('xmlRelaxNGNewMemParserCtxt() failed')
860: return relaxNgParserCtxt(_obj=ret)
861:
862: def relaxNGNewParserCtxt(URL):
863: """Create an XML RelaxNGs parse context for that file/resource
864: expected to contain an XML RelaxNGs file. """
865: ret = libxml2mod.xmlRelaxNGNewParserCtxt(URL)
866: if ret is None:raise parserError('xmlRelaxNGNewParserCtxt() failed')
867: return relaxNgParserCtxt(_obj=ret)
868:
869: #
870: # Functions from module tree
871: #
872:
873: def buildQName(ncname, prefix, memory, len):
874: """Builds the QName @prefix:@ncname in @memory if there is
875: enough space and prefix is not None nor empty, otherwise
876: allocate a new string. If prefix is None or empty it
877: returns ncname. """
878: ret = libxml2mod.xmlBuildQName(ncname, prefix, memory, len)
879: return ret
880:
881: def compressMode():
882: """get the default compression mode used, ZLIB based. """
883: ret = libxml2mod.xmlGetCompressMode()
884: return ret
885:
886: def isXHTML(systemID, publicID):
887: """Try to find if the document correspond to an XHTML DTD """
888: ret = libxml2mod.xmlIsXHTML(systemID, publicID)
889: return ret
890:
891: def newComment(content):
892: """Creation of a new node containing a comment. """
893: ret = libxml2mod.xmlNewComment(content)
894: if ret is None:raise treeError('xmlNewComment() failed')
895: return xmlNode(_obj=ret)
896:
897: def newDoc(version):
898: """Creates a new XML document """
899: ret = libxml2mod.xmlNewDoc(version)
900: if ret is None:raise treeError('xmlNewDoc() failed')
901: return xmlDoc(_obj=ret)
902:
903: def newPI(name, content):
904: """Creation of a processing instruction element. Use
905: xmlDocNewPI preferably to get string interning """
906: ret = libxml2mod.xmlNewPI(name, content)
907: if ret is None:raise treeError('xmlNewPI() failed')
908: return xmlNode(_obj=ret)
909:
910: def newText(content):
911: """Creation of a new text node. """
912: ret = libxml2mod.xmlNewText(content)
913: if ret is None:raise treeError('xmlNewText() failed')
914: return xmlNode(_obj=ret)
915:
916: def newTextLen(content, len):
917: """Creation of a new text node with an extra parameter for the
918: content's length """
919: ret = libxml2mod.xmlNewTextLen(content, len)
920: if ret is None:raise treeError('xmlNewTextLen() failed')
921: return xmlNode(_obj=ret)
922:
923: def setCompressMode(mode):
924: """set the default compression mode used, ZLIB based Correct
925: values: 0 (uncompressed) to 9 (max compression) """
926: libxml2mod.xmlSetCompressMode(mode)
927:
928: def validateNCName(value, space):
929: """Check that a value conforms to the lexical space of NCName """
930: ret = libxml2mod.xmlValidateNCName(value, space)
931: return ret
932:
933: def validateNMToken(value, space):
934: """Check that a value conforms to the lexical space of NMToken """
935: ret = libxml2mod.xmlValidateNMToken(value, space)
936: return ret
937:
938: def validateName(value, space):
939: """Check that a value conforms to the lexical space of Name """
940: ret = libxml2mod.xmlValidateName(value, space)
941: return ret
942:
943: def validateQName(value, space):
944: """Check that a value conforms to the lexical space of QName """
945: ret = libxml2mod.xmlValidateQName(value, space)
946: return ret
947:
948: #
949: # Functions from module uri
950: #
951:
952: def URIEscape(str):
953: """Escaping routine, does not do validity checks ! It will try
954: to escape the chars needing this, but this is heuristic
955: based it's impossible to be sure. """
956: ret = libxml2mod.xmlURIEscape(str)
957: return ret
958:
959: def URIEscapeStr(str, list):
960: """This routine escapes a string to hex, ignoring reserved
961: characters (a-z) and the characters in the exception list. """
962: ret = libxml2mod.xmlURIEscapeStr(str, list)
963: return ret
964:
965: def URIUnescapeString(str, len, target):
966: """Unescaping routine, but does not check that the string is
967: an URI. The output is a direct unsigned char translation of
968: %XX values (no encoding) Note that the length of the result
969: can only be smaller or same size as the input string. """
970: ret = libxml2mod.xmlURIUnescapeString(str, len, target)
971: return ret
972:
973: def buildRelativeURI(URI, base):
974: """Expresses the URI of the reference in terms relative to the
975: base. Some examples of this operation include: base =
976: "http://site1.com/docs/book1.html" URI input
977: URI returned docs/pic1.gif pic1.gif
978: docs/img/pic1.gif img/pic1.gif img/pic1.gif
979: ../img/pic1.gif http://site1.com/docs/pic1.gif pic1.gif
980: http://site2.com/docs/pic1.gif
981: http://site2.com/docs/pic1.gif base = "docs/book1.html"
982: URI input URI returned docs/pic1.gif
983: pic1.gif docs/img/pic1.gif img/pic1.gif
984: img/pic1.gif ../img/pic1.gif
985: http://site1.com/docs/pic1.gif
986: http://site1.com/docs/pic1.gif Note: if the URI reference
987: is really wierd or complicated, it may be worthwhile to
988: first convert it into a "nice" one by calling xmlBuildURI
989: (using 'base') before calling this routine, since this
990: routine (for reasonable efficiency) assumes URI has already
991: been through some validation. """
992: ret = libxml2mod.xmlBuildRelativeURI(URI, base)
993: return ret
994:
995: def buildURI(URI, base):
996: """Computes he final URI of the reference done by checking
997: that the given URI is valid, and building the final URI
998: using the base URI. This is processed according to section
999: 5.2 of the RFC 2396 5.2. Resolving Relative References to
1000: Absolute Form """
1001: ret = libxml2mod.xmlBuildURI(URI, base)
1002: return ret
1003:
1004: def canonicPath(path):
1005: """Constructs a canonic path from the specified path. """
1006: ret = libxml2mod.xmlCanonicPath(path)
1007: return ret
1008:
1009: def createURI():
1010: """Simply creates an empty xmlURI """
1011: ret = libxml2mod.xmlCreateURI()
1012: if ret is None:raise uriError('xmlCreateURI() failed')
1013: return URI(_obj=ret)
1014:
1015: def normalizeURIPath(path):
1016: """Applies the 5 normalization steps to a path string--that
1017: is, RFC 2396 Section 5.2, steps 6.c through 6.g.
1018: Normalization occurs directly on the string, no new
1019: allocation is done """
1020: ret = libxml2mod.xmlNormalizeURIPath(path)
1021: return ret
1022:
1023: def parseURI(str):
1024: """Parse an URI based on RFC 3986 URI-reference = [
1025: absoluteURI | relativeURI ] [ "#" fragment ] """
1026: ret = libxml2mod.xmlParseURI(str)
1027: if ret is None:raise uriError('xmlParseURI() failed')
1028: return URI(_obj=ret)
1029:
1030: def parseURIRaw(str, raw):
1031: """Parse an URI but allows to keep intact the original
1032: fragments. URI-reference = URI / relative-ref """
1033: ret = libxml2mod.xmlParseURIRaw(str, raw)
1034: if ret is None:raise uriError('xmlParseURIRaw() failed')
1035: return URI(_obj=ret)
1036:
1037: def pathToURI(path):
1038: """Constructs an URI expressing the existing path """
1039: ret = libxml2mod.xmlPathToURI(path)
1040: return ret
1041:
1042: #
1043: # Functions from module valid
1044: #
1045:
1046: def newValidCtxt():
1047: """Allocate a validation context structure. """
1048: ret = libxml2mod.xmlNewValidCtxt()
1049: if ret is None:raise treeError('xmlNewValidCtxt() failed')
1050: return ValidCtxt(_obj=ret)
1051:
1052: def validateNameValue(value):
1053: """Validate that the given value match Name production """
1054: ret = libxml2mod.xmlValidateNameValue(value)
1055: return ret
1056:
1057: def validateNamesValue(value):
1058: """Validate that the given value match Names production """
1059: ret = libxml2mod.xmlValidateNamesValue(value)
1060: return ret
1061:
1062: def validateNmtokenValue(value):
1063: """Validate that the given value match Nmtoken production [
1064: VC: Name Token ] """
1065: ret = libxml2mod.xmlValidateNmtokenValue(value)
1066: return ret
1067:
1068: def validateNmtokensValue(value):
1069: """Validate that the given value match Nmtokens production [
1070: VC: Name Token ] """
1071: ret = libxml2mod.xmlValidateNmtokensValue(value)
1072: return ret
1073:
1074: #
1075: # Functions from module xmlIO
1076: #
1077:
1078: def checkFilename(path):
1079: """function checks to see if @path is a valid source (file,
1080: socket...) for XML. if stat is not available on the target
1081: machine, """
1082: ret = libxml2mod.xmlCheckFilename(path)
1083: return ret
1084:
1085: def cleanupInputCallbacks():
1086: """clears the entire input callback table. this includes the
1087: compiled-in I/O. """
1088: libxml2mod.xmlCleanupInputCallbacks()
1089:
1090: def cleanupOutputCallbacks():
1091: """clears the entire output callback table. this includes the
1092: compiled-in I/O callbacks. """
1093: libxml2mod.xmlCleanupOutputCallbacks()
1094:
1095: def fileMatch(filename):
1096: """input from FILE * """
1097: ret = libxml2mod.xmlFileMatch(filename)
1098: return ret
1099:
1100: def iOFTPMatch(filename):
1101: """check if the URI matches an FTP one """
1102: ret = libxml2mod.xmlIOFTPMatch(filename)
1103: return ret
1104:
1105: def iOHTTPMatch(filename):
1106: """check if the URI matches an HTTP one """
1107: ret = libxml2mod.xmlIOHTTPMatch(filename)
1108: return ret
1109:
1110: def normalizeWindowsPath(path):
1111: """This function is obsolete. Please see xmlURIFromPath in
1112: uri.c for a better solution. """
1113: ret = libxml2mod.xmlNormalizeWindowsPath(path)
1114: return ret
1115:
1116: def parserGetDirectory(filename):
1117: """lookup the directory for that file """
1118: ret = libxml2mod.xmlParserGetDirectory(filename)
1119: return ret
1120:
1121: def registerDefaultInputCallbacks():
1122: """Registers the default compiled-in I/O handlers. """
1123: libxml2mod.xmlRegisterDefaultInputCallbacks()
1124:
1125: def registerDefaultOutputCallbacks():
1126: """Registers the default compiled-in I/O handlers. """
1127: libxml2mod.xmlRegisterDefaultOutputCallbacks()
1128:
1129: def registerHTTPPostCallbacks():
1130: """By default, libxml submits HTTP output requests using the
1131: "PUT" method. Calling this method changes the HTTP output
1132: method to use the "POST" method instead. """
1133: libxml2mod.xmlRegisterHTTPPostCallbacks()
1134:
1135: #
1136: # Functions from module xmlerror
1137: #
1138:
1139: def lastError():
1140: """Get the last global error registered. This is per thread if
1141: compiled with thread support. """
1142: ret = libxml2mod.xmlGetLastError()
1143: if ret is None:raise treeError('xmlGetLastError() failed')
1144: return Error(_obj=ret)
1145:
1146: def resetLastError():
1147: """Cleanup the last global error registered. For parsing error
1148: this does not change the well-formedness result. """
1149: libxml2mod.xmlResetLastError()
1150:
1151: #
1152: # Functions from module xmlreader
1153: #
1154:
1155: def newTextReaderFilename(URI):
1156: """Create an xmlTextReader structure fed with the resource at
1157: @URI """
1158: ret = libxml2mod.xmlNewTextReaderFilename(URI)
1159: if ret is None:raise treeError('xmlNewTextReaderFilename() failed')
1160: return xmlTextReader(_obj=ret)
1161:
1162: def readerForDoc(cur, URL, encoding, options):
1163: """Create an xmltextReader for an XML in-memory document. The
1164: parsing flags @options are a combination of xmlParserOption. """
1165: ret = libxml2mod.xmlReaderForDoc(cur, URL, encoding, options)
1166: if ret is None:raise treeError('xmlReaderForDoc() failed')
1167: return xmlTextReader(_obj=ret)
1168:
1169: def readerForFd(fd, URL, encoding, options):
1170: """Create an xmltextReader for an XML from a file descriptor.
1171: The parsing flags @options are a combination of
1172: xmlParserOption. NOTE that the file descriptor will not be
1173: closed when the reader is closed or reset. """
1174: ret = libxml2mod.xmlReaderForFd(fd, URL, encoding, options)
1175: if ret is None:raise treeError('xmlReaderForFd() failed')
1176: return xmlTextReader(_obj=ret)
1177:
1178: def readerForFile(filename, encoding, options):
1179: """parse an XML file from the filesystem or the network. The
1180: parsing flags @options are a combination of xmlParserOption. """
1181: ret = libxml2mod.xmlReaderForFile(filename, encoding, options)
1182: if ret is None:raise treeError('xmlReaderForFile() failed')
1183: return xmlTextReader(_obj=ret)
1184:
1185: def readerForMemory(buffer, size, URL, encoding, options):
1186: """Create an xmltextReader for an XML in-memory document. The
1187: parsing flags @options are a combination of xmlParserOption. """
1188: ret = libxml2mod.xmlReaderForMemory(buffer, size, URL, encoding, options)
1189: if ret is None:raise treeError('xmlReaderForMemory() failed')
1190: return xmlTextReader(_obj=ret)
1191:
1192: #
1193: # Functions from module xmlregexp
1194: #
1195:
1196: def regexpCompile(regexp):
1197: """Parses a regular expression conforming to XML Schemas Part
1198: 2 Datatype Appendix F and builds an automata suitable for
1199: testing strings against that regular expression """
1200: ret = libxml2mod.xmlRegexpCompile(regexp)
1201: if ret is None:raise treeError('xmlRegexpCompile() failed')
1202: return xmlReg(_obj=ret)
1203:
1204: #
1205: # Functions from module xmlschemas
1206: #
1207:
1208: def schemaNewMemParserCtxt(buffer, size):
1209: """Create an XML Schemas parse context for that memory buffer
1210: expected to contain an XML Schemas file. """
1211: ret = libxml2mod.xmlSchemaNewMemParserCtxt(buffer, size)
1212: if ret is None:raise parserError('xmlSchemaNewMemParserCtxt() failed')
1213: return SchemaParserCtxt(_obj=ret)
1214:
1215: def schemaNewParserCtxt(URL):
1216: """Create an XML Schemas parse context for that file/resource
1217: expected to contain an XML Schemas file. """
1218: ret = libxml2mod.xmlSchemaNewParserCtxt(URL)
1219: if ret is None:raise parserError('xmlSchemaNewParserCtxt() failed')
1220: return SchemaParserCtxt(_obj=ret)
1221:
1222: #
1223: # Functions from module xmlschemastypes
1224: #
1225:
1226: def schemaCleanupTypes():
1227: """Cleanup the default XML Schemas type library """
1228: libxml2mod.xmlSchemaCleanupTypes()
1229:
1230: def schemaCollapseString(value):
1231: """Removes and normalize white spaces in the string """
1232: ret = libxml2mod.xmlSchemaCollapseString(value)
1233: return ret
1234:
1235: def schemaInitTypes():
1236: """Initialize the default XML Schemas type library """
1237: libxml2mod.xmlSchemaInitTypes()
1238:
1239: def schemaWhiteSpaceReplace(value):
1240: """Replaces 0xd, 0x9 and 0xa with a space. """
1241: ret = libxml2mod.xmlSchemaWhiteSpaceReplace(value)
1242: return ret
1243:
1244: #
1245: # Functions from module xmlstring
1246: #
1247:
1248: def UTF8Charcmp(utf1, utf2):
1249: """compares the two UCS4 values """
1250: ret = libxml2mod.xmlUTF8Charcmp(utf1, utf2)
1251: return ret
1252:
1253: def UTF8Size(utf):
1254: """calculates the internal size of a UTF8 character """
1255: ret = libxml2mod.xmlUTF8Size(utf)
1256: return ret
1257:
1258: def UTF8Strlen(utf):
1259: """compute the length of an UTF8 string, it doesn't do a full
1260: UTF8 checking of the content of the string. """
1261: ret = libxml2mod.xmlUTF8Strlen(utf)
1262: return ret
1263:
1264: def UTF8Strloc(utf, utfchar):
1265: """a function to provide the relative location of a UTF8 char """
1266: ret = libxml2mod.xmlUTF8Strloc(utf, utfchar)
1267: return ret
1268:
1269: def UTF8Strndup(utf, len):
1270: """a strndup for array of UTF8's """
1271: ret = libxml2mod.xmlUTF8Strndup(utf, len)
1272: return ret
1273:
1274: def UTF8Strpos(utf, pos):
1275: """a function to provide the equivalent of fetching a
1276: character from a string array """
1277: ret = libxml2mod.xmlUTF8Strpos(utf, pos)
1278: return ret
1279:
1280: def UTF8Strsize(utf, len):
1281: """storage size of an UTF8 string the behaviour is not
1282: garanteed if the input string is not UTF-8 """
1283: ret = libxml2mod.xmlUTF8Strsize(utf, len)
1284: return ret
1285:
1286: def UTF8Strsub(utf, start, len):
1287: """Create a substring from a given UTF-8 string Note:
1288: positions are given in units of UTF-8 chars """
1289: ret = libxml2mod.xmlUTF8Strsub(utf, start, len)
1290: return ret
1291:
1292: def checkUTF8(utf):
1293: """Checks @utf for being valid UTF-8. @utf is assumed to be
1294: null-terminated. This function is not super-strict, as it
1295: will allow longer UTF-8 sequences than necessary. Note that
1296: Java is capable of producing these sequences if provoked.
1297: Also note, this routine checks for the 4-byte maximum size,
1298: but does not check for 0x10ffff maximum value. """
1299: ret = libxml2mod.xmlCheckUTF8(utf)
1300: return ret
1301:
1302: #
1303: # Functions from module xmlunicode
1304: #
1305:
1306: def uCSIsAegeanNumbers(code):
1307: """Check whether the character is part of AegeanNumbers UCS
1308: Block """
1309: ret = libxml2mod.xmlUCSIsAegeanNumbers(code)
1310: return ret
1311:
1312: def uCSIsAlphabeticPresentationForms(code):
1313: """Check whether the character is part of
1314: AlphabeticPresentationForms UCS Block """
1315: ret = libxml2mod.xmlUCSIsAlphabeticPresentationForms(code)
1316: return ret
1317:
1318: def uCSIsArabic(code):
1319: """Check whether the character is part of Arabic UCS Block """
1320: ret = libxml2mod.xmlUCSIsArabic(code)
1321: return ret
1322:
1323: def uCSIsArabicPresentationFormsA(code):
1324: """Check whether the character is part of
1325: ArabicPresentationForms-A UCS Block """
1326: ret = libxml2mod.xmlUCSIsArabicPresentationFormsA(code)
1327: return ret
1328:
1329: def uCSIsArabicPresentationFormsB(code):
1330: """Check whether the character is part of
1331: ArabicPresentationForms-B UCS Block """
1332: ret = libxml2mod.xmlUCSIsArabicPresentationFormsB(code)
1333: return ret
1334:
1335: def uCSIsArmenian(code):
1336: """Check whether the character is part of Armenian UCS Block """
1337: ret = libxml2mod.xmlUCSIsArmenian(code)
1338: return ret
1339:
1340: def uCSIsArrows(code):
1341: """Check whether the character is part of Arrows UCS Block """
1342: ret = libxml2mod.xmlUCSIsArrows(code)
1343: return ret
1344:
1345: def uCSIsBasicLatin(code):
1346: """Check whether the character is part of BasicLatin UCS Block """
1347: ret = libxml2mod.xmlUCSIsBasicLatin(code)
1348: return ret
1349:
1350: def uCSIsBengali(code):
1351: """Check whether the character is part of Bengali UCS Block """
1352: ret = libxml2mod.xmlUCSIsBengali(code)
1353: return ret
1354:
1355: def uCSIsBlock(code, block):
1356: """Check whether the character is part of the UCS Block """
1357: ret = libxml2mod.xmlUCSIsBlock(code, block)
1358: return ret
1359:
1360: def uCSIsBlockElements(code):
1361: """Check whether the character is part of BlockElements UCS
1362: Block """
1363: ret = libxml2mod.xmlUCSIsBlockElements(code)
1364: return ret
1365:
1366: def uCSIsBopomofo(code):
1367: """Check whether the character is part of Bopomofo UCS Block """
1368: ret = libxml2mod.xmlUCSIsBopomofo(code)
1369: return ret
1370:
1371: def uCSIsBopomofoExtended(code):
1372: """Check whether the character is part of BopomofoExtended UCS
1373: Block """
1374: ret = libxml2mod.xmlUCSIsBopomofoExtended(code)
1375: return ret
1376:
1377: def uCSIsBoxDrawing(code):
1378: """Check whether the character is part of BoxDrawing UCS Block """
1379: ret = libxml2mod.xmlUCSIsBoxDrawing(code)
1380: return ret
1381:
1382: def uCSIsBraillePatterns(code):
1383: """Check whether the character is part of BraillePatterns UCS
1384: Block """
1385: ret = libxml2mod.xmlUCSIsBraillePatterns(code)
1386: return ret
1387:
1388: def uCSIsBuhid(code):
1389: """Check whether the character is part of Buhid UCS Block """
1390: ret = libxml2mod.xmlUCSIsBuhid(code)
1391: return ret
1392:
1393: def uCSIsByzantineMusicalSymbols(code):
1394: """Check whether the character is part of
1395: ByzantineMusicalSymbols UCS Block """
1396: ret = libxml2mod.xmlUCSIsByzantineMusicalSymbols(code)
1397: return ret
1398:
1399: def uCSIsCJKCompatibility(code):
1400: """Check whether the character is part of CJKCompatibility UCS
1401: Block """
1402: ret = libxml2mod.xmlUCSIsCJKCompatibility(code)
1403: return ret
1404:
1405: def uCSIsCJKCompatibilityForms(code):
1406: """Check whether the character is part of
1407: CJKCompatibilityForms UCS Block """
1408: ret = libxml2mod.xmlUCSIsCJKCompatibilityForms(code)
1409: return ret
1410:
1411: def uCSIsCJKCompatibilityIdeographs(code):
1412: """Check whether the character is part of
1413: CJKCompatibilityIdeographs UCS Block """
1414: ret = libxml2mod.xmlUCSIsCJKCompatibilityIdeographs(code)
1415: return ret
1416:
1417: def uCSIsCJKCompatibilityIdeographsSupplement(code):
1418: """Check whether the character is part of
1419: CJKCompatibilityIdeographsSupplement UCS Block """
1420: ret = libxml2mod.xmlUCSIsCJKCompatibilityIdeographsSupplement(code)
1421: return ret
1422:
1423: def uCSIsCJKRadicalsSupplement(code):
1424: """Check whether the character is part of
1425: CJKRadicalsSupplement UCS Block """
1426: ret = libxml2mod.xmlUCSIsCJKRadicalsSupplement(code)
1427: return ret
1428:
1429: def uCSIsCJKSymbolsandPunctuation(code):
1430: """Check whether the character is part of
1431: CJKSymbolsandPunctuation UCS Block """
1432: ret = libxml2mod.xmlUCSIsCJKSymbolsandPunctuation(code)
1433: return ret
1434:
1435: def uCSIsCJKUnifiedIdeographs(code):
1436: """Check whether the character is part of CJKUnifiedIdeographs
1437: UCS Block """
1438: ret = libxml2mod.xmlUCSIsCJKUnifiedIdeographs(code)
1439: return ret
1440:
1441: def uCSIsCJKUnifiedIdeographsExtensionA(code):
1442: """Check whether the character is part of
1443: CJKUnifiedIdeographsExtensionA UCS Block """
1444: ret = libxml2mod.xmlUCSIsCJKUnifiedIdeographsExtensionA(code)
1445: return ret
1446:
1447: def uCSIsCJKUnifiedIdeographsExtensionB(code):
1448: """Check whether the character is part of
1449: CJKUnifiedIdeographsExtensionB UCS Block """
1450: ret = libxml2mod.xmlUCSIsCJKUnifiedIdeographsExtensionB(code)
1451: return ret
1452:
1453: def uCSIsCat(code, cat):
1454: """Check whether the character is part of the UCS Category """
1455: ret = libxml2mod.xmlUCSIsCat(code, cat)
1456: return ret
1457:
1458: def uCSIsCatC(code):
1459: """Check whether the character is part of C UCS Category """
1460: ret = libxml2mod.xmlUCSIsCatC(code)
1461: return ret
1462:
1463: def uCSIsCatCc(code):
1464: """Check whether the character is part of Cc UCS Category """
1465: ret = libxml2mod.xmlUCSIsCatCc(code)
1466: return ret
1467:
1468: def uCSIsCatCf(code):
1469: """Check whether the character is part of Cf UCS Category """
1470: ret = libxml2mod.xmlUCSIsCatCf(code)
1471: return ret
1472:
1473: def uCSIsCatCo(code):
1474: """Check whether the character is part of Co UCS Category """
1475: ret = libxml2mod.xmlUCSIsCatCo(code)
1476: return ret
1477:
1478: def uCSIsCatCs(code):
1479: """Check whether the character is part of Cs UCS Category """
1480: ret = libxml2mod.xmlUCSIsCatCs(code)
1481: return ret
1482:
1483: def uCSIsCatL(code):
1484: """Check whether the character is part of L UCS Category """
1485: ret = libxml2mod.xmlUCSIsCatL(code)
1486: return ret
1487:
1488: def uCSIsCatLl(code):
1489: """Check whether the character is part of Ll UCS Category """
1490: ret = libxml2mod.xmlUCSIsCatLl(code)
1491: return ret
1492:
1493: def uCSIsCatLm(code):
1494: """Check whether the character is part of Lm UCS Category """
1495: ret = libxml2mod.xmlUCSIsCatLm(code)
1496: return ret
1497:
1498: def uCSIsCatLo(code):
1499: """Check whether the character is part of Lo UCS Category """
1500: ret = libxml2mod.xmlUCSIsCatLo(code)
1501: return ret
1502:
1503: def uCSIsCatLt(code):
1504: """Check whether the character is part of Lt UCS Category """
1505: ret = libxml2mod.xmlUCSIsCatLt(code)
1506: return ret
1507:
1508: def uCSIsCatLu(code):
1509: """Check whether the character is part of Lu UCS Category """
1510: ret = libxml2mod.xmlUCSIsCatLu(code)
1511: return ret
1512:
1513: def uCSIsCatM(code):
1514: """Check whether the character is part of M UCS Category """
1515: ret = libxml2mod.xmlUCSIsCatM(code)
1516: return ret
1517:
1518: def uCSIsCatMc(code):
1519: """Check whether the character is part of Mc UCS Category """
1520: ret = libxml2mod.xmlUCSIsCatMc(code)
1521: return ret
1522:
1523: def uCSIsCatMe(code):
1524: """Check whether the character is part of Me UCS Category """
1525: ret = libxml2mod.xmlUCSIsCatMe(code)
1526: return ret
1527:
1528: def uCSIsCatMn(code):
1529: """Check whether the character is part of Mn UCS Category """
1530: ret = libxml2mod.xmlUCSIsCatMn(code)
1531: return ret
1532:
1533: def uCSIsCatN(code):
1534: """Check whether the character is part of N UCS Category """
1535: ret = libxml2mod.xmlUCSIsCatN(code)
1536: return ret
1537:
1538: def uCSIsCatNd(code):
1539: """Check whether the character is part of Nd UCS Category """
1540: ret = libxml2mod.xmlUCSIsCatNd(code)
1541: return ret
1542:
1543: def uCSIsCatNl(code):
1544: """Check whether the character is part of Nl UCS Category """
1545: ret = libxml2mod.xmlUCSIsCatNl(code)
1546: return ret
1547:
1548: def uCSIsCatNo(code):
1549: """Check whether the character is part of No UCS Category """
1550: ret = libxml2mod.xmlUCSIsCatNo(code)
1551: return ret
1552:
1553: def uCSIsCatP(code):
1554: """Check whether the character is part of P UCS Category """
1555: ret = libxml2mod.xmlUCSIsCatP(code)
1556: return ret
1557:
1558: def uCSIsCatPc(code):
1559: """Check whether the character is part of Pc UCS Category """
1560: ret = libxml2mod.xmlUCSIsCatPc(code)
1561: return ret
1562:
1563: def uCSIsCatPd(code):
1564: """Check whether the character is part of Pd UCS Category """
1565: ret = libxml2mod.xmlUCSIsCatPd(code)
1566: return ret
1567:
1568: def uCSIsCatPe(code):
1569: """Check whether the character is part of Pe UCS Category """
1570: ret = libxml2mod.xmlUCSIsCatPe(code)
1571: return ret
1572:
1573: def uCSIsCatPf(code):
1574: """Check whether the character is part of Pf UCS Category """
1575: ret = libxml2mod.xmlUCSIsCatPf(code)
1576: return ret
1577:
1578: def uCSIsCatPi(code):
1579: """Check whether the character is part of Pi UCS Category """
1580: ret = libxml2mod.xmlUCSIsCatPi(code)
1581: return ret
1582:
1583: def uCSIsCatPo(code):
1584: """Check whether the character is part of Po UCS Category """
1585: ret = libxml2mod.xmlUCSIsCatPo(code)
1586: return ret
1587:
1588: def uCSIsCatPs(code):
1589: """Check whether the character is part of Ps UCS Category """
1590: ret = libxml2mod.xmlUCSIsCatPs(code)
1591: return ret
1592:
1593: def uCSIsCatS(code):
1594: """Check whether the character is part of S UCS Category """
1595: ret = libxml2mod.xmlUCSIsCatS(code)
1596: return ret
1597:
1598: def uCSIsCatSc(code):
1599: """Check whether the character is part of Sc UCS Category """
1600: ret = libxml2mod.xmlUCSIsCatSc(code)
1601: return ret
1602:
1603: def uCSIsCatSk(code):
1604: """Check whether the character is part of Sk UCS Category """
1605: ret = libxml2mod.xmlUCSIsCatSk(code)
1606: return ret
1607:
1608: def uCSIsCatSm(code):
1609: """Check whether the character is part of Sm UCS Category """
1610: ret = libxml2mod.xmlUCSIsCatSm(code)
1611: return ret
1612:
1613: def uCSIsCatSo(code):
1614: """Check whether the character is part of So UCS Category """
1615: ret = libxml2mod.xmlUCSIsCatSo(code)
1616: return ret
1617:
1618: def uCSIsCatZ(code):
1619: """Check whether the character is part of Z UCS Category """
1620: ret = libxml2mod.xmlUCSIsCatZ(code)
1621: return ret
1622:
1623: def uCSIsCatZl(code):
1624: """Check whether the character is part of Zl UCS Category """
1625: ret = libxml2mod.xmlUCSIsCatZl(code)
1626: return ret
1627:
1628: def uCSIsCatZp(code):
1629: """Check whether the character is part of Zp UCS Category """
1630: ret = libxml2mod.xmlUCSIsCatZp(code)
1631: return ret
1632:
1633: def uCSIsCatZs(code):
1634: """Check whether the character is part of Zs UCS Category """
1635: ret = libxml2mod.xmlUCSIsCatZs(code)
1636: return ret
1637:
1638: def uCSIsCherokee(code):
1639: """Check whether the character is part of Cherokee UCS Block """
1640: ret = libxml2mod.xmlUCSIsCherokee(code)
1641: return ret
1642:
1643: def uCSIsCombiningDiacriticalMarks(code):
1644: """Check whether the character is part of
1645: CombiningDiacriticalMarks UCS Block """
1646: ret = libxml2mod.xmlUCSIsCombiningDiacriticalMarks(code)
1647: return ret
1648:
1649: def uCSIsCombiningDiacriticalMarksforSymbols(code):
1650: """Check whether the character is part of
1651: CombiningDiacriticalMarksforSymbols UCS Block """
1652: ret = libxml2mod.xmlUCSIsCombiningDiacriticalMarksforSymbols(code)
1653: return ret
1654:
1655: def uCSIsCombiningHalfMarks(code):
1656: """Check whether the character is part of CombiningHalfMarks
1657: UCS Block """
1658: ret = libxml2mod.xmlUCSIsCombiningHalfMarks(code)
1659: return ret
1660:
1661: def uCSIsCombiningMarksforSymbols(code):
1662: """Check whether the character is part of
1663: CombiningMarksforSymbols UCS Block """
1664: ret = libxml2mod.xmlUCSIsCombiningMarksforSymbols(code)
1665: return ret
1666:
1667: def uCSIsControlPictures(code):
1668: """Check whether the character is part of ControlPictures UCS
1669: Block """
1670: ret = libxml2mod.xmlUCSIsControlPictures(code)
1671: return ret
1672:
1673: def uCSIsCurrencySymbols(code):
1674: """Check whether the character is part of CurrencySymbols UCS
1675: Block """
1676: ret = libxml2mod.xmlUCSIsCurrencySymbols(code)
1677: return ret
1678:
1679: def uCSIsCypriotSyllabary(code):
1680: """Check whether the character is part of CypriotSyllabary UCS
1681: Block """
1682: ret = libxml2mod.xmlUCSIsCypriotSyllabary(code)
1683: return ret
1684:
1685: def uCSIsCyrillic(code):
1686: """Check whether the character is part of Cyrillic UCS Block """
1687: ret = libxml2mod.xmlUCSIsCyrillic(code)
1688: return ret
1689:
1690: def uCSIsCyrillicSupplement(code):
1691: """Check whether the character is part of CyrillicSupplement
1692: UCS Block """
1693: ret = libxml2mod.xmlUCSIsCyrillicSupplement(code)
1694: return ret
1695:
1696: def uCSIsDeseret(code):
1697: """Check whether the character is part of Deseret UCS Block """
1698: ret = libxml2mod.xmlUCSIsDeseret(code)
1699: return ret
1700:
1701: def uCSIsDevanagari(code):
1702: """Check whether the character is part of Devanagari UCS Block """
1703: ret = libxml2mod.xmlUCSIsDevanagari(code)
1704: return ret
1705:
1706: def uCSIsDingbats(code):
1707: """Check whether the character is part of Dingbats UCS Block """
1708: ret = libxml2mod.xmlUCSIsDingbats(code)
1709: return ret
1710:
1711: def uCSIsEnclosedAlphanumerics(code):
1712: """Check whether the character is part of
1713: EnclosedAlphanumerics UCS Block """
1714: ret = libxml2mod.xmlUCSIsEnclosedAlphanumerics(code)
1715: return ret
1716:
1717: def uCSIsEnclosedCJKLettersandMonths(code):
1718: """Check whether the character is part of
1719: EnclosedCJKLettersandMonths UCS Block """
1720: ret = libxml2mod.xmlUCSIsEnclosedCJKLettersandMonths(code)
1721: return ret
1722:
1723: def uCSIsEthiopic(code):
1724: """Check whether the character is part of Ethiopic UCS Block """
1725: ret = libxml2mod.xmlUCSIsEthiopic(code)
1726: return ret
1727:
1728: def uCSIsGeneralPunctuation(code):
1729: """Check whether the character is part of GeneralPunctuation
1730: UCS Block """
1731: ret = libxml2mod.xmlUCSIsGeneralPunctuation(code)
1732: return ret
1733:
1734: def uCSIsGeometricShapes(code):
1735: """Check whether the character is part of GeometricShapes UCS
1736: Block """
1737: ret = libxml2mod.xmlUCSIsGeometricShapes(code)
1738: return ret
1739:
1740: def uCSIsGeorgian(code):
1741: """Check whether the character is part of Georgian UCS Block """
1742: ret = libxml2mod.xmlUCSIsGeorgian(code)
1743: return ret
1744:
1745: def uCSIsGothic(code):
1746: """Check whether the character is part of Gothic UCS Block """
1747: ret = libxml2mod.xmlUCSIsGothic(code)
1748: return ret
1749:
1750: def uCSIsGreek(code):
1751: """Check whether the character is part of Greek UCS Block """
1752: ret = libxml2mod.xmlUCSIsGreek(code)
1753: return ret
1754:
1755: def uCSIsGreekExtended(code):
1756: """Check whether the character is part of GreekExtended UCS
1757: Block """
1758: ret = libxml2mod.xmlUCSIsGreekExtended(code)
1759: return ret
1760:
1761: def uCSIsGreekandCoptic(code):
1762: """Check whether the character is part of GreekandCoptic UCS
1763: Block """
1764: ret = libxml2mod.xmlUCSIsGreekandCoptic(code)
1765: return ret
1766:
1767: def uCSIsGujarati(code):
1768: """Check whether the character is part of Gujarati UCS Block """
1769: ret = libxml2mod.xmlUCSIsGujarati(code)
1770: return ret
1771:
1772: def uCSIsGurmukhi(code):
1773: """Check whether the character is part of Gurmukhi UCS Block """
1774: ret = libxml2mod.xmlUCSIsGurmukhi(code)
1775: return ret
1776:
1777: def uCSIsHalfwidthandFullwidthForms(code):
1778: """Check whether the character is part of
1779: HalfwidthandFullwidthForms UCS Block """
1780: ret = libxml2mod.xmlUCSIsHalfwidthandFullwidthForms(code)
1781: return ret
1782:
1783: def uCSIsHangulCompatibilityJamo(code):
1784: """Check whether the character is part of
1785: HangulCompatibilityJamo UCS Block """
1786: ret = libxml2mod.xmlUCSIsHangulCompatibilityJamo(code)
1787: return ret
1788:
1789: def uCSIsHangulJamo(code):
1790: """Check whether the character is part of HangulJamo UCS Block """
1791: ret = libxml2mod.xmlUCSIsHangulJamo(code)
1792: return ret
1793:
1794: def uCSIsHangulSyllables(code):
1795: """Check whether the character is part of HangulSyllables UCS
1796: Block """
1797: ret = libxml2mod.xmlUCSIsHangulSyllables(code)
1798: return ret
1799:
1800: def uCSIsHanunoo(code):
1801: """Check whether the character is part of Hanunoo UCS Block """
1802: ret = libxml2mod.xmlUCSIsHanunoo(code)
1803: return ret
1804:
1805: def uCSIsHebrew(code):
1806: """Check whether the character is part of Hebrew UCS Block """
1807: ret = libxml2mod.xmlUCSIsHebrew(code)
1808: return ret
1809:
1810: def uCSIsHighPrivateUseSurrogates(code):
1811: """Check whether the character is part of
1812: HighPrivateUseSurrogates UCS Block """
1813: ret = libxml2mod.xmlUCSIsHighPrivateUseSurrogates(code)
1814: return ret
1815:
1816: def uCSIsHighSurrogates(code):
1817: """Check whether the character is part of HighSurrogates UCS
1818: Block """
1819: ret = libxml2mod.xmlUCSIsHighSurrogates(code)
1820: return ret
1821:
1822: def uCSIsHiragana(code):
1823: """Check whether the character is part of Hiragana UCS Block """
1824: ret = libxml2mod.xmlUCSIsHiragana(code)
1825: return ret
1826:
1827: def uCSIsIPAExtensions(code):
1828: """Check whether the character is part of IPAExtensions UCS
1829: Block """
1830: ret = libxml2mod.xmlUCSIsIPAExtensions(code)
1831: return ret
1832:
1833: def uCSIsIdeographicDescriptionCharacters(code):
1834: """Check whether the character is part of
1835: IdeographicDescriptionCharacters UCS Block """
1836: ret = libxml2mod.xmlUCSIsIdeographicDescriptionCharacters(code)
1837: return ret
1838:
1839: def uCSIsKanbun(code):
1840: """Check whether the character is part of Kanbun UCS Block """
1841: ret = libxml2mod.xmlUCSIsKanbun(code)
1842: return ret
1843:
1844: def uCSIsKangxiRadicals(code):
1845: """Check whether the character is part of KangxiRadicals UCS
1846: Block """
1847: ret = libxml2mod.xmlUCSIsKangxiRadicals(code)
1848: return ret
1849:
1850: def uCSIsKannada(code):
1851: """Check whether the character is part of Kannada UCS Block """
1852: ret = libxml2mod.xmlUCSIsKannada(code)
1853: return ret
1854:
1855: def uCSIsKatakana(code):
1856: """Check whether the character is part of Katakana UCS Block """
1857: ret = libxml2mod.xmlUCSIsKatakana(code)
1858: return ret
1859:
1860: def uCSIsKatakanaPhoneticExtensions(code):
1861: """Check whether the character is part of
1862: KatakanaPhoneticExtensions UCS Block """
1863: ret = libxml2mod.xmlUCSIsKatakanaPhoneticExtensions(code)
1864: return ret
1865:
1866: def uCSIsKhmer(code):
1867: """Check whether the character is part of Khmer UCS Block """
1868: ret = libxml2mod.xmlUCSIsKhmer(code)
1869: return ret
1870:
1871: def uCSIsKhmerSymbols(code):
1872: """Check whether the character is part of KhmerSymbols UCS
1873: Block """
1874: ret = libxml2mod.xmlUCSIsKhmerSymbols(code)
1875: return ret
1876:
1877: def uCSIsLao(code):
1878: """Check whether the character is part of Lao UCS Block """
1879: ret = libxml2mod.xmlUCSIsLao(code)
1880: return ret
1881:
1882: def uCSIsLatin1Supplement(code):
1883: """Check whether the character is part of Latin-1Supplement
1884: UCS Block """
1885: ret = libxml2mod.xmlUCSIsLatin1Supplement(code)
1886: return ret
1887:
1888: def uCSIsLatinExtendedA(code):
1889: """Check whether the character is part of LatinExtended-A UCS
1890: Block """
1891: ret = libxml2mod.xmlUCSIsLatinExtendedA(code)
1892: return ret
1893:
1894: def uCSIsLatinExtendedAdditional(code):
1895: """Check whether the character is part of
1896: LatinExtendedAdditional UCS Block """
1897: ret = libxml2mod.xmlUCSIsLatinExtendedAdditional(code)
1898: return ret
1899:
1900: def uCSIsLatinExtendedB(code):
1901: """Check whether the character is part of LatinExtended-B UCS
1902: Block """
1903: ret = libxml2mod.xmlUCSIsLatinExtendedB(code)
1904: return ret
1905:
1906: def uCSIsLetterlikeSymbols(code):
1907: """Check whether the character is part of LetterlikeSymbols
1908: UCS Block """
1909: ret = libxml2mod.xmlUCSIsLetterlikeSymbols(code)
1910: return ret
1911:
1912: def uCSIsLimbu(code):
1913: """Check whether the character is part of Limbu UCS Block """
1914: ret = libxml2mod.xmlUCSIsLimbu(code)
1915: return ret
1916:
1917: def uCSIsLinearBIdeograms(code):
1918: """Check whether the character is part of LinearBIdeograms UCS
1919: Block """
1920: ret = libxml2mod.xmlUCSIsLinearBIdeograms(code)
1921: return ret
1922:
1923: def uCSIsLinearBSyllabary(code):
1924: """Check whether the character is part of LinearBSyllabary UCS
1925: Block """
1926: ret = libxml2mod.xmlUCSIsLinearBSyllabary(code)
1927: return ret
1928:
1929: def uCSIsLowSurrogates(code):
1930: """Check whether the character is part of LowSurrogates UCS
1931: Block """
1932: ret = libxml2mod.xmlUCSIsLowSurrogates(code)
1933: return ret
1934:
1935: def uCSIsMalayalam(code):
1936: """Check whether the character is part of Malayalam UCS Block """
1937: ret = libxml2mod.xmlUCSIsMalayalam(code)
1938: return ret
1939:
1940: def uCSIsMathematicalAlphanumericSymbols(code):
1941: """Check whether the character is part of
1942: MathematicalAlphanumericSymbols UCS Block """
1943: ret = libxml2mod.xmlUCSIsMathematicalAlphanumericSymbols(code)
1944: return ret
1945:
1946: def uCSIsMathematicalOperators(code):
1947: """Check whether the character is part of
1948: MathematicalOperators UCS Block """
1949: ret = libxml2mod.xmlUCSIsMathematicalOperators(code)
1950: return ret
1951:
1952: def uCSIsMiscellaneousMathematicalSymbolsA(code):
1953: """Check whether the character is part of
1954: MiscellaneousMathematicalSymbols-A UCS Block """
1955: ret = libxml2mod.xmlUCSIsMiscellaneousMathematicalSymbolsA(code)
1956: return ret
1957:
1958: def uCSIsMiscellaneousMathematicalSymbolsB(code):
1959: """Check whether the character is part of
1960: MiscellaneousMathematicalSymbols-B UCS Block """
1961: ret = libxml2mod.xmlUCSIsMiscellaneousMathematicalSymbolsB(code)
1962: return ret
1963:
1964: def uCSIsMiscellaneousSymbols(code):
1965: """Check whether the character is part of MiscellaneousSymbols
1966: UCS Block """
1967: ret = libxml2mod.xmlUCSIsMiscellaneousSymbols(code)
1968: return ret
1969:
1970: def uCSIsMiscellaneousSymbolsandArrows(code):
1971: """Check whether the character is part of
1972: MiscellaneousSymbolsandArrows UCS Block """
1973: ret = libxml2mod.xmlUCSIsMiscellaneousSymbolsandArrows(code)
1974: return ret
1975:
1976: def uCSIsMiscellaneousTechnical(code):
1977: """Check whether the character is part of
1978: MiscellaneousTechnical UCS Block """
1979: ret = libxml2mod.xmlUCSIsMiscellaneousTechnical(code)
1980: return ret
1981:
1982: def uCSIsMongolian(code):
1983: """Check whether the character is part of Mongolian UCS Block """
1984: ret = libxml2mod.xmlUCSIsMongolian(code)
1985: return ret
1986:
1987: def uCSIsMusicalSymbols(code):
1988: """Check whether the character is part of MusicalSymbols UCS
1989: Block """
1990: ret = libxml2mod.xmlUCSIsMusicalSymbols(code)
1991: return ret
1992:
1993: def uCSIsMyanmar(code):
1994: """Check whether the character is part of Myanmar UCS Block """
1995: ret = libxml2mod.xmlUCSIsMyanmar(code)
1996: return ret
1997:
1998: def uCSIsNumberForms(code):
1999: """Check whether the character is part of NumberForms UCS Block """
2000: ret = libxml2mod.xmlUCSIsNumberForms(code)
2001: return ret
2002:
2003: def uCSIsOgham(code):
2004: """Check whether the character is part of Ogham UCS Block """
2005: ret = libxml2mod.xmlUCSIsOgham(code)
2006: return ret
2007:
2008: def uCSIsOldItalic(code):
2009: """Check whether the character is part of OldItalic UCS Block """
2010: ret = libxml2mod.xmlUCSIsOldItalic(code)
2011: return ret
2012:
2013: def uCSIsOpticalCharacterRecognition(code):
2014: """Check whether the character is part of
2015: OpticalCharacterRecognition UCS Block """
2016: ret = libxml2mod.xmlUCSIsOpticalCharacterRecognition(code)
2017: return ret
2018:
2019: def uCSIsOriya(code):
2020: """Check whether the character is part of Oriya UCS Block """
2021: ret = libxml2mod.xmlUCSIsOriya(code)
2022: return ret
2023:
2024: def uCSIsOsmanya(code):
2025: """Check whether the character is part of Osmanya UCS Block """
2026: ret = libxml2mod.xmlUCSIsOsmanya(code)
2027: return ret
2028:
2029: def uCSIsPhoneticExtensions(code):
2030: """Check whether the character is part of PhoneticExtensions
2031: UCS Block """
2032: ret = libxml2mod.xmlUCSIsPhoneticExtensions(code)
2033: return ret
2034:
2035: def uCSIsPrivateUse(code):
2036: """Check whether the character is part of PrivateUse UCS Block """
2037: ret = libxml2mod.xmlUCSIsPrivateUse(code)
2038: return ret
2039:
2040: def uCSIsPrivateUseArea(code):
2041: """Check whether the character is part of PrivateUseArea UCS
2042: Block """
2043: ret = libxml2mod.xmlUCSIsPrivateUseArea(code)
2044: return ret
2045:
2046: def uCSIsRunic(code):
2047: """Check whether the character is part of Runic UCS Block """
2048: ret = libxml2mod.xmlUCSIsRunic(code)
2049: return ret
2050:
2051: def uCSIsShavian(code):
2052: """Check whether the character is part of Shavian UCS Block """
2053: ret = libxml2mod.xmlUCSIsShavian(code)
2054: return ret
2055:
2056: def uCSIsSinhala(code):
2057: """Check whether the character is part of Sinhala UCS Block """
2058: ret = libxml2mod.xmlUCSIsSinhala(code)
2059: return ret
2060:
2061: def uCSIsSmallFormVariants(code):
2062: """Check whether the character is part of SmallFormVariants
2063: UCS Block """
2064: ret = libxml2mod.xmlUCSIsSmallFormVariants(code)
2065: return ret
2066:
2067: def uCSIsSpacingModifierLetters(code):
2068: """Check whether the character is part of
2069: SpacingModifierLetters UCS Block """
2070: ret = libxml2mod.xmlUCSIsSpacingModifierLetters(code)
2071: return ret
2072:
2073: def uCSIsSpecials(code):
2074: """Check whether the character is part of Specials UCS Block """
2075: ret = libxml2mod.xmlUCSIsSpecials(code)
2076: return ret
2077:
2078: def uCSIsSuperscriptsandSubscripts(code):
2079: """Check whether the character is part of
2080: SuperscriptsandSubscripts UCS Block """
2081: ret = libxml2mod.xmlUCSIsSuperscriptsandSubscripts(code)
2082: return ret
2083:
2084: def uCSIsSupplementalArrowsA(code):
2085: """Check whether the character is part of SupplementalArrows-A
2086: UCS Block """
2087: ret = libxml2mod.xmlUCSIsSupplementalArrowsA(code)
2088: return ret
2089:
2090: def uCSIsSupplementalArrowsB(code):
2091: """Check whether the character is part of SupplementalArrows-B
2092: UCS Block """
2093: ret = libxml2mod.xmlUCSIsSupplementalArrowsB(code)
2094: return ret
2095:
2096: def uCSIsSupplementalMathematicalOperators(code):
2097: """Check whether the character is part of
2098: SupplementalMathematicalOperators UCS Block """
2099: ret = libxml2mod.xmlUCSIsSupplementalMathematicalOperators(code)
2100: return ret
2101:
2102: def uCSIsSupplementaryPrivateUseAreaA(code):
2103: """Check whether the character is part of
2104: SupplementaryPrivateUseArea-A UCS Block """
2105: ret = libxml2mod.xmlUCSIsSupplementaryPrivateUseAreaA(code)
2106: return ret
2107:
2108: def uCSIsSupplementaryPrivateUseAreaB(code):
2109: """Check whether the character is part of
2110: SupplementaryPrivateUseArea-B UCS Block """
2111: ret = libxml2mod.xmlUCSIsSupplementaryPrivateUseAreaB(code)
2112: return ret
2113:
2114: def uCSIsSyriac(code):
2115: """Check whether the character is part of Syriac UCS Block """
2116: ret = libxml2mod.xmlUCSIsSyriac(code)
2117: return ret
2118:
2119: def uCSIsTagalog(code):
2120: """Check whether the character is part of Tagalog UCS Block """
2121: ret = libxml2mod.xmlUCSIsTagalog(code)
2122: return ret
2123:
2124: def uCSIsTagbanwa(code):
2125: """Check whether the character is part of Tagbanwa UCS Block """
2126: ret = libxml2mod.xmlUCSIsTagbanwa(code)
2127: return ret
2128:
2129: def uCSIsTags(code):
2130: """Check whether the character is part of Tags UCS Block """
2131: ret = libxml2mod.xmlUCSIsTags(code)
2132: return ret
2133:
2134: def uCSIsTaiLe(code):
2135: """Check whether the character is part of TaiLe UCS Block """
2136: ret = libxml2mod.xmlUCSIsTaiLe(code)
2137: return ret
2138:
2139: def uCSIsTaiXuanJingSymbols(code):
2140: """Check whether the character is part of TaiXuanJingSymbols
2141: UCS Block """
2142: ret = libxml2mod.xmlUCSIsTaiXuanJingSymbols(code)
2143: return ret
2144:
2145: def uCSIsTamil(code):
2146: """Check whether the character is part of Tamil UCS Block """
2147: ret = libxml2mod.xmlUCSIsTamil(code)
2148: return ret
2149:
2150: def uCSIsTelugu(code):
2151: """Check whether the character is part of Telugu UCS Block """
2152: ret = libxml2mod.xmlUCSIsTelugu(code)
2153: return ret
2154:
2155: def uCSIsThaana(code):
2156: """Check whether the character is part of Thaana UCS Block """
2157: ret = libxml2mod.xmlUCSIsThaana(code)
2158: return ret
2159:
2160: def uCSIsThai(code):
2161: """Check whether the character is part of Thai UCS Block """
2162: ret = libxml2mod.xmlUCSIsThai(code)
2163: return ret
2164:
2165: def uCSIsTibetan(code):
2166: """Check whether the character is part of Tibetan UCS Block """
2167: ret = libxml2mod.xmlUCSIsTibetan(code)
2168: return ret
2169:
2170: def uCSIsUgaritic(code):
2171: """Check whether the character is part of Ugaritic UCS Block """
2172: ret = libxml2mod.xmlUCSIsUgaritic(code)
2173: return ret
2174:
2175: def uCSIsUnifiedCanadianAboriginalSyllabics(code):
2176: """Check whether the character is part of
2177: UnifiedCanadianAboriginalSyllabics UCS Block """
2178: ret = libxml2mod.xmlUCSIsUnifiedCanadianAboriginalSyllabics(code)
2179: return ret
2180:
2181: def uCSIsVariationSelectors(code):
2182: """Check whether the character is part of VariationSelectors
2183: UCS Block """
2184: ret = libxml2mod.xmlUCSIsVariationSelectors(code)
2185: return ret
2186:
2187: def uCSIsVariationSelectorsSupplement(code):
2188: """Check whether the character is part of
2189: VariationSelectorsSupplement UCS Block """
2190: ret = libxml2mod.xmlUCSIsVariationSelectorsSupplement(code)
2191: return ret
2192:
2193: def uCSIsYiRadicals(code):
2194: """Check whether the character is part of YiRadicals UCS Block """
2195: ret = libxml2mod.xmlUCSIsYiRadicals(code)
2196: return ret
2197:
2198: def uCSIsYiSyllables(code):
2199: """Check whether the character is part of YiSyllables UCS Block """
2200: ret = libxml2mod.xmlUCSIsYiSyllables(code)
2201: return ret
2202:
2203: def uCSIsYijingHexagramSymbols(code):
2204: """Check whether the character is part of
2205: YijingHexagramSymbols UCS Block """
2206: ret = libxml2mod.xmlUCSIsYijingHexagramSymbols(code)
2207: return ret
2208:
2209: #
2210: # Functions from module xmlversion
2211: #
2212:
2213: def checkVersion(version):
2214: """check the compiled lib version against the include one.
2215: This can warn or immediately kill the application """
2216: libxml2mod.xmlCheckVersion(version)
2217:
2218: #
2219: # Functions from module xpathInternals
2220: #
2221:
2222: def valuePop(ctxt):
2223: """Pops the top XPath object from the value stack """
2224: if ctxt is None: ctxt__o = None
2225: else: ctxt__o = ctxt._o
2226: ret = libxml2mod.valuePop(ctxt__o)
2227: return ret
2228:
2229: class xmlNode(xmlCore):
2230: def __init__(self, _obj=None):
2231: if checkWrapper(_obj) != 0: raise TypeError('xmlNode got a wrong wrapper object type')
2232: self._o = _obj
2233: xmlCore.__init__(self, _obj=_obj)
2234:
2235: def __repr__(self):
2236: return "<xmlNode (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
2237:
2238: # accessors for xmlNode
2239: def ns(self):
2240: """Get the namespace of a node """
2241: ret = libxml2mod.xmlNodeGetNs(self._o)
2242: if ret is None:return None
2243: __tmp = xmlNs(_obj=ret)
2244: return __tmp
2245:
2246: def nsDefs(self):
2247: """Get the namespace of a node """
2248: ret = libxml2mod.xmlNodeGetNsDefs(self._o)
2249: if ret is None:return None
2250: __tmp = xmlNs(_obj=ret)
2251: return __tmp
2252:
2253: #
2254: # xmlNode functions from module debugXML
2255: #
2256:
2257: def debugDumpNode(self, output, depth):
2258: """Dumps debug information for the element node, it is
2259: recursive """
2260: libxml2mod.xmlDebugDumpNode(output, self._o, depth)
2261:
2262: def debugDumpNodeList(self, output, depth):
2263: """Dumps debug information for the list of element node, it is
2264: recursive """
2265: libxml2mod.xmlDebugDumpNodeList(output, self._o, depth)
2266:
2267: def debugDumpOneNode(self, output, depth):
2268: """Dumps debug information for the element node, it is not
2269: recursive """
2270: libxml2mod.xmlDebugDumpOneNode(output, self._o, depth)
2271:
2272: def lsCountNode(self):
2273: """Count the children of @node. """
2274: ret = libxml2mod.xmlLsCountNode(self._o)
2275: return ret
2276:
2277: def lsOneNode(self, output):
2278: """Dump to @output the type and name of @node. """
2279: libxml2mod.xmlLsOneNode(output, self._o)
2280:
2281: def shellPrintNode(self):
2282: """Print node to the output FILE """
2283: libxml2mod.xmlShellPrintNode(self._o)
2284:
2285: #
2286: # xmlNode functions from module tree
2287: #
2288:
2289: def addChild(self, cur):
2290: """Add a new node to @parent, at the end of the child (or
2291: property) list merging adjacent TEXT nodes (in which case
2292: @cur is freed) If the new node is ATTRIBUTE, it is added
2293: into properties instead of children. If there is an
2294: attribute with equal name, it is first destroyed. """
2295: if cur is None: cur__o = None
2296: else: cur__o = cur._o
2297: ret = libxml2mod.xmlAddChild(self._o, cur__o)
2298: if ret is None:raise treeError('xmlAddChild() failed')
2299: __tmp = xmlNode(_obj=ret)
2300: return __tmp
2301:
2302: def addChildList(self, cur):
2303: """Add a list of node at the end of the child list of the
2304: parent merging adjacent TEXT nodes (@cur may be freed) """
2305: if cur is None: cur__o = None
2306: else: cur__o = cur._o
2307: ret = libxml2mod.xmlAddChildList(self._o, cur__o)
2308: if ret is None:raise treeError('xmlAddChildList() failed')
2309: __tmp = xmlNode(_obj=ret)
2310: return __tmp
2311:
2312: def addContent(self, content):
2313: """Append the extra substring to the node content. NOTE: In
2314: contrast to xmlNodeSetContent(), @content is supposed to be
2315: raw text, so unescaped XML special chars are allowed,
2316: entity references are not supported. """
2317: libxml2mod.xmlNodeAddContent(self._o, content)
2318:
2319: def addContentLen(self, content, len):
2320: """Append the extra substring to the node content. NOTE: In
2321: contrast to xmlNodeSetContentLen(), @content is supposed to
2322: be raw text, so unescaped XML special chars are allowed,
2323: entity references are not supported. """
2324: libxml2mod.xmlNodeAddContentLen(self._o, content, len)
2325:
2326: def addNextSibling(self, elem):
2327: """Add a new node @elem as the next sibling of @cur If the new
2328: node was already inserted in a document it is first
2329: unlinked from its existing context. As a result of text
2330: merging @elem may be freed. If the new node is ATTRIBUTE,
2331: it is added into properties instead of children. If there
2332: is an attribute with equal name, it is first destroyed. """
2333: if elem is None: elem__o = None
2334: else: elem__o = elem._o
2335: ret = libxml2mod.xmlAddNextSibling(self._o, elem__o)
2336: if ret is None:raise treeError('xmlAddNextSibling() failed')
2337: __tmp = xmlNode(_obj=ret)
2338: return __tmp
2339:
2340: def addPrevSibling(self, elem):
2341: """Add a new node @elem as the previous sibling of @cur
2342: merging adjacent TEXT nodes (@elem may be freed) If the new
2343: node was already inserted in a document it is first
2344: unlinked from its existing context. If the new node is
2345: ATTRIBUTE, it is added into properties instead of children.
2346: If there is an attribute with equal name, it is first
2347: destroyed. """
2348: if elem is None: elem__o = None
2349: else: elem__o = elem._o
2350: ret = libxml2mod.xmlAddPrevSibling(self._o, elem__o)
2351: if ret is None:raise treeError('xmlAddPrevSibling() failed')
2352: __tmp = xmlNode(_obj=ret)
2353: return __tmp
2354:
2355: def addSibling(self, elem):
2356: """Add a new element @elem to the list of siblings of @cur
2357: merging adjacent TEXT nodes (@elem may be freed) If the new
2358: element was already inserted in a document it is first
2359: unlinked from its existing context. """
2360: if elem is None: elem__o = None
2361: else: elem__o = elem._o
2362: ret = libxml2mod.xmlAddSibling(self._o, elem__o)
2363: if ret is None:raise treeError('xmlAddSibling() failed')
2364: __tmp = xmlNode(_obj=ret)
2365: return __tmp
2366:
2367: def copyNode(self, extended):
2368: """Do a copy of the node. """
2369: ret = libxml2mod.xmlCopyNode(self._o, extended)
2370: if ret is None:raise treeError('xmlCopyNode() failed')
2371: __tmp = xmlNode(_obj=ret)
2372: return __tmp
2373:
2374: def copyNodeList(self):
2375: """Do a recursive copy of the node list. Use
2376: xmlDocCopyNodeList() if possible to ensure string interning. """
2377: ret = libxml2mod.xmlCopyNodeList(self._o)
2378: if ret is None:raise treeError('xmlCopyNodeList() failed')
2379: __tmp = xmlNode(_obj=ret)
2380: return __tmp
2381:
2382: def copyProp(self, cur):
2383: """Do a copy of the attribute. """
2384: if cur is None: cur__o = None
2385: else: cur__o = cur._o
2386: ret = libxml2mod.xmlCopyProp(self._o, cur__o)
2387: if ret is None:raise treeError('xmlCopyProp() failed')
2388: __tmp = xmlAttr(_obj=ret)
2389: return __tmp
2390:
2391: def copyPropList(self, cur):
2392: """Do a copy of an attribute list. """
2393: if cur is None: cur__o = None
2394: else: cur__o = cur._o
2395: ret = libxml2mod.xmlCopyPropList(self._o, cur__o)
2396: if ret is None:raise treeError('xmlCopyPropList() failed')
2397: __tmp = xmlAttr(_obj=ret)
2398: return __tmp
2399:
2400: def docCopyNode(self, doc, extended):
2401: """Do a copy of the node to a given document. """
2402: if doc is None: doc__o = None
2403: else: doc__o = doc._o
2404: ret = libxml2mod.xmlDocCopyNode(self._o, doc__o, extended)
2405: if ret is None:raise treeError('xmlDocCopyNode() failed')
2406: __tmp = xmlNode(_obj=ret)
2407: return __tmp
2408:
2409: def docCopyNodeList(self, doc):
2410: """Do a recursive copy of the node list. """
2411: if doc is None: doc__o = None
2412: else: doc__o = doc._o
2413: ret = libxml2mod.xmlDocCopyNodeList(doc__o, self._o)
2414: if ret is None:raise treeError('xmlDocCopyNodeList() failed')
2415: __tmp = xmlNode(_obj=ret)
2416: return __tmp
2417:
2418: def docSetRootElement(self, doc):
2419: """Set the root element of the document (doc->children is a
2420: list containing possibly comments, PIs, etc ...). """
2421: if doc is None: doc__o = None
2422: else: doc__o = doc._o
2423: ret = libxml2mod.xmlDocSetRootElement(doc__o, self._o)
2424: if ret is None:return None
2425: __tmp = xmlNode(_obj=ret)
2426: return __tmp
2427:
2428: def firstElementChild(self):
2429: """Finds the first child node of that element which is a
2430: Element node Note the handling of entities references is
2431: different than in the W3C DOM element traversal spec since
2432: we don't have back reference from entities content to
2433: entities references. """
2434: ret = libxml2mod.xmlFirstElementChild(self._o)
2435: if ret is None:return None
2436: __tmp = xmlNode(_obj=ret)
2437: return __tmp
2438:
2439: def freeNode(self):
2440: """Free a node, this is a recursive behaviour, all the
2441: children are freed too. This doesn't unlink the child from
2442: the list, use xmlUnlinkNode() first. """
2443: libxml2mod.xmlFreeNode(self._o)
2444:
2445: def freeNodeList(self):
2446: """Free a node and all its siblings, this is a recursive
2447: behaviour, all the children are freed too. """
2448: libxml2mod.xmlFreeNodeList(self._o)
2449:
2450: def getBase(self, doc):
2451: """Searches for the BASE URL. The code should work on both XML
2452: and HTML document even if base mechanisms are completely
2453: different. It returns the base as defined in RFC 2396
2454: sections 5.1.1. Base URI within Document Content and 5.1.2.
2455: Base URI from the Encapsulating Entity However it does not
2456: return the document base (5.1.3), use doc->URL in this case """
2457: if doc is None: doc__o = None
2458: else: doc__o = doc._o
2459: ret = libxml2mod.xmlNodeGetBase(doc__o, self._o)
2460: return ret
2461:
2462: def getContent(self):
2463: """Read the value of a node, this can be either the text
2464: carried directly by this node if it's a TEXT node or the
2465: aggregate string of the values carried by this node child's
2466: (TEXT and ENTITY_REF). Entity references are substituted. """
2467: ret = libxml2mod.xmlNodeGetContent(self._o)
2468: return ret
2469:
2470: def getLang(self):
2471: """Searches the language of a node, i.e. the values of the
2472: xml:lang attribute or the one carried by the nearest
2473: ancestor. """
2474: ret = libxml2mod.xmlNodeGetLang(self._o)
2475: return ret
2476:
2477: def getSpacePreserve(self):
2478: """Searches the space preserving behaviour of a node, i.e. the
2479: values of the xml:space attribute or the one carried by the
2480: nearest ancestor. """
2481: ret = libxml2mod.xmlNodeGetSpacePreserve(self._o)
2482: return ret
2483:
2484: def hasNsProp(self, name, nameSpace):
2485: """Search for an attribute associated to a node This attribute
2486: has to be anchored in the namespace specified. This does
2487: the entity substitution. This function looks in DTD
2488: attribute declaration for #FIXED or default declaration
2489: values unless DTD use has been turned off. Note that a
2490: namespace of None indicates to use the default namespace. """
2491: ret = libxml2mod.xmlHasNsProp(self._o, name, nameSpace)
2492: if ret is None:return None
2493: __tmp = xmlAttr(_obj=ret)
2494: return __tmp
2495:
2496: def hasProp(self, name):
2497: """Search an attribute associated to a node This function also
2498: looks in DTD attribute declaration for #FIXED or default
2499: declaration values unless DTD use has been turned off. """
2500: ret = libxml2mod.xmlHasProp(self._o, name)
2501: if ret is None:return None
2502: __tmp = xmlAttr(_obj=ret)
2503: return __tmp
2504:
2505: def isBlankNode(self):
2506: """Checks whether this node is an empty or whitespace only
2507: (and possibly ignorable) text-node. """
2508: ret = libxml2mod.xmlIsBlankNode(self._o)
2509: return ret
2510:
2511: def isText(self):
2512: """Is this node a Text node ? """
2513: ret = libxml2mod.xmlNodeIsText(self._o)
2514: return ret
2515:
2516: def lastChild(self):
2517: """Search the last child of a node. """
2518: ret = libxml2mod.xmlGetLastChild(self._o)
2519: if ret is None:raise treeError('xmlGetLastChild() failed')
2520: __tmp = xmlNode(_obj=ret)
2521: return __tmp
2522:
2523: def lastElementChild(self):
2524: """Finds the last child node of that element which is a
2525: Element node Note the handling of entities references is
2526: different than in the W3C DOM element traversal spec since
2527: we don't have back reference from entities content to
2528: entities references. """
2529: ret = libxml2mod.xmlLastElementChild(self._o)
2530: if ret is None:return None
2531: __tmp = xmlNode(_obj=ret)
2532: return __tmp
2533:
2534: def lineNo(self):
2535: """Get line number of @node. Try to override the limitation of
2536: lines being store in 16 bits ints if XML_PARSE_BIG_LINES
2537: parser option was used """
2538: ret = libxml2mod.xmlGetLineNo(self._o)
2539: return ret
2540:
2541: def listGetRawString(self, doc, inLine):
2542: """Builds the string equivalent to the text contained in the
2543: Node list made of TEXTs and ENTITY_REFs, contrary to
2544: xmlNodeListGetString() this function doesn't do any
2545: character encoding handling. """
2546: if doc is None: doc__o = None
2547: else: doc__o = doc._o
2548: ret = libxml2mod.xmlNodeListGetRawString(doc__o, self._o, inLine)
2549: return ret
2550:
2551: def listGetString(self, doc, inLine):
2552: """Build the string equivalent to the text contained in the
2553: Node list made of TEXTs and ENTITY_REFs """
2554: if doc is None: doc__o = None
2555: else: doc__o = doc._o
2556: ret = libxml2mod.xmlNodeListGetString(doc__o, self._o, inLine)
2557: return ret
2558:
2559: def newChild(self, ns, name, content):
2560: """Creation of a new child element, added at the end of
2561: @parent children list. @ns and @content parameters are
2562: optional (None). If @ns is None, the newly created element
2563: inherits the namespace of @parent. If @content is non None,
2564: a child list containing the TEXTs and ENTITY_REFs node will
2565: be created. NOTE: @content is supposed to be a piece of XML
2566: CDATA, so it allows entity references. XML special chars
2567: must be escaped first by using
2568: xmlEncodeEntitiesReentrant(), or xmlNewTextChild() should
2569: be used. """
2570: if ns is None: ns__o = None
2571: else: ns__o = ns._o
2572: ret = libxml2mod.xmlNewChild(self._o, ns__o, name, content)
2573: if ret is None:raise treeError('xmlNewChild() failed')
2574: __tmp = xmlNode(_obj=ret)
2575: return __tmp
2576:
2577: def newNs(self, href, prefix):
2578: """Creation of a new Namespace. This function will refuse to
2579: create a namespace with a similar prefix than an existing
2580: one present on this node. We use href==None in the case of
2581: an element creation where the namespace was not defined. """
2582: ret = libxml2mod.xmlNewNs(self._o, href, prefix)
2583: if ret is None:raise treeError('xmlNewNs() failed')
2584: __tmp = xmlNs(_obj=ret)
2585: return __tmp
2586:
2587: def newNsProp(self, ns, name, value):
2588: """Create a new property tagged with a namespace and carried
2589: by a node. """
2590: if ns is None: ns__o = None
2591: else: ns__o = ns._o
2592: ret = libxml2mod.xmlNewNsProp(self._o, ns__o, name, value)
2593: if ret is None:raise treeError('xmlNewNsProp() failed')
2594: __tmp = xmlAttr(_obj=ret)
2595: return __tmp
2596:
2597: def newNsPropEatName(self, ns, name, value):
2598: """Create a new property tagged with a namespace and carried
2599: by a node. """
2600: if ns is None: ns__o = None
2601: else: ns__o = ns._o
2602: ret = libxml2mod.xmlNewNsPropEatName(self._o, ns__o, name, value)
2603: if ret is None:raise treeError('xmlNewNsPropEatName() failed')
2604: __tmp = xmlAttr(_obj=ret)
2605: return __tmp
2606:
2607: def newProp(self, name, value):
2608: """Create a new property carried by a node. """
2609: ret = libxml2mod.xmlNewProp(self._o, name, value)
2610: if ret is None:raise treeError('xmlNewProp() failed')
2611: __tmp = xmlAttr(_obj=ret)
2612: return __tmp
2613:
2614: def newTextChild(self, ns, name, content):
2615: """Creation of a new child element, added at the end of
2616: @parent children list. @ns and @content parameters are
2617: optional (None). If @ns is None, the newly created element
2618: inherits the namespace of @parent. If @content is non None,
2619: a child TEXT node will be created containing the string
2620: @content. NOTE: Use xmlNewChild() if @content will contain
2621: entities that need to be preserved. Use this function,
2622: xmlNewTextChild(), if you need to ensure that reserved XML
2623: chars that might appear in @content, such as the ampersand,
2624: greater-than or less-than signs, are automatically replaced
2625: by their XML escaped entity representations. """
2626: if ns is None: ns__o = None
2627: else: ns__o = ns._o
2628: ret = libxml2mod.xmlNewTextChild(self._o, ns__o, name, content)
2629: if ret is None:raise treeError('xmlNewTextChild() failed')
2630: __tmp = xmlNode(_obj=ret)
2631: return __tmp
2632:
2633: def nextElementSibling(self):
2634: """Finds the first closest next sibling of the node which is
2635: an element node. Note the handling of entities references
2636: is different than in the W3C DOM element traversal spec
2637: since we don't have back reference from entities content to
2638: entities references. """
2639: ret = libxml2mod.xmlNextElementSibling(self._o)
2640: if ret is None:return None
2641: __tmp = xmlNode(_obj=ret)
2642: return __tmp
2643:
2644: def noNsProp(self, name):
2645: """Search and get the value of an attribute associated to a
2646: node This does the entity substitution. This function looks
2647: in DTD attribute declaration for #FIXED or default
2648: declaration values unless DTD use has been turned off. This
2649: function is similar to xmlGetProp except it will accept
2650: only an attribute in no namespace. """
2651: ret = libxml2mod.xmlGetNoNsProp(self._o, name)
2652: return ret
2653:
2654: def nodePath(self):
2655: """Build a structure based Path for the given node """
2656: ret = libxml2mod.xmlGetNodePath(self._o)
2657: return ret
2658:
2659: def nsProp(self, name, nameSpace):
2660: """Search and get the value of an attribute associated to a
2661: node This attribute has to be anchored in the namespace
2662: specified. This does the entity substitution. This function
2663: looks in DTD attribute declaration for #FIXED or default
2664: declaration values unless DTD use has been turned off. """
2665: ret = libxml2mod.xmlGetNsProp(self._o, name, nameSpace)
2666: return ret
2667:
2668: def previousElementSibling(self):
2669: """Finds the first closest previous sibling of the node which
2670: is an element node. Note the handling of entities
2671: references is different than in the W3C DOM element
2672: traversal spec since we don't have back reference from
2673: entities content to entities references. """
2674: ret = libxml2mod.xmlPreviousElementSibling(self._o)
2675: if ret is None:return None
2676: __tmp = xmlNode(_obj=ret)
2677: return __tmp
2678:
2679: def prop(self, name):
2680: """Search and get the value of an attribute associated to a
2681: node This does the entity substitution. This function looks
2682: in DTD attribute declaration for #FIXED or default
2683: declaration values unless DTD use has been turned off.
2684: NOTE: this function acts independently of namespaces
2685: associated to the attribute. Use xmlGetNsProp() or
2686: xmlGetNoNsProp() for namespace aware processing. """
2687: ret = libxml2mod.xmlGetProp(self._o, name)
2688: return ret
2689:
2690: def reconciliateNs(self, doc):
2691: """This function checks that all the namespaces declared
2692: within the given tree are properly declared. This is needed
2693: for example after Copy or Cut and then paste operations.
2694: The subtree may still hold pointers to namespace
2695: declarations outside the subtree or invalid/masked. As much
2696: as possible the function try to reuse the existing
2697: namespaces found in the new environment. If not possible
2698: the new namespaces are redeclared on @tree at the top of
2699: the given subtree. """
2700: if doc is None: doc__o = None
2701: else: doc__o = doc._o
2702: ret = libxml2mod.xmlReconciliateNs(doc__o, self._o)
2703: return ret
2704:
2705: def replaceNode(self, cur):
2706: """Unlink the old node from its current context, prune the new
2707: one at the same place. If @cur was already inserted in a
2708: document it is first unlinked from its existing context. """
2709: if cur is None: cur__o = None
2710: else: cur__o = cur._o
2711: ret = libxml2mod.xmlReplaceNode(self._o, cur__o)
2712: if ret is None:raise treeError('xmlReplaceNode() failed')
2713: __tmp = xmlNode(_obj=ret)
2714: return __tmp
2715:
2716: def searchNs(self, doc, nameSpace):
2717: """Search a Ns registered under a given name space for a
2718: document. recurse on the parents until it finds the defined
2719: namespace or return None otherwise. @nameSpace can be None,
2720: this is a search for the default namespace. We don't allow
2721: to cross entities boundaries. If you don't declare the
2722: namespace within those you will be in troubles !!! A
2723: warning is generated to cover this case. """
2724: if doc is None: doc__o = None
2725: else: doc__o = doc._o
2726: ret = libxml2mod.xmlSearchNs(doc__o, self._o, nameSpace)
2727: if ret is None:raise treeError('xmlSearchNs() failed')
2728: __tmp = xmlNs(_obj=ret)
2729: return __tmp
2730:
2731: def searchNsByHref(self, doc, href):
2732: """Search a Ns aliasing a given URI. Recurse on the parents
2733: until it finds the defined namespace or return None
2734: otherwise. """
2735: if doc is None: doc__o = None
2736: else: doc__o = doc._o
2737: ret = libxml2mod.xmlSearchNsByHref(doc__o, self._o, href)
2738: if ret is None:raise treeError('xmlSearchNsByHref() failed')
2739: __tmp = xmlNs(_obj=ret)
2740: return __tmp
2741:
2742: def setBase(self, uri):
2743: """Set (or reset) the base URI of a node, i.e. the value of
2744: the xml:base attribute. """
2745: libxml2mod.xmlNodeSetBase(self._o, uri)
2746:
2747: def setContent(self, content):
2748: """Replace the content of a node. NOTE: @content is supposed
2749: to be a piece of XML CDATA, so it allows entity references,
2750: but XML special chars need to be escaped first by using
2751: xmlEncodeEntitiesReentrant() resp. xmlEncodeSpecialChars(). """
2752: libxml2mod.xmlNodeSetContent(self._o, content)
2753:
2754: def setContentLen(self, content, len):
2755: """Replace the content of a node. NOTE: @content is supposed
2756: to be a piece of XML CDATA, so it allows entity references,
2757: but XML special chars need to be escaped first by using
2758: xmlEncodeEntitiesReentrant() resp. xmlEncodeSpecialChars(). """
2759: libxml2mod.xmlNodeSetContentLen(self._o, content, len)
2760:
2761: def setLang(self, lang):
2762: """Set the language of a node, i.e. the values of the xml:lang
2763: attribute. """
2764: libxml2mod.xmlNodeSetLang(self._o, lang)
2765:
2766: def setListDoc(self, doc):
2767: """update all nodes in the list to point to the right document """
2768: if doc is None: doc__o = None
2769: else: doc__o = doc._o
2770: libxml2mod.xmlSetListDoc(self._o, doc__o)
2771:
2772: def setName(self, name):
2773: """Set (or reset) the name of a node. """
2774: libxml2mod.xmlNodeSetName(self._o, name)
2775:
2776: def setNs(self, ns):
2777: """Associate a namespace to a node, a posteriori. """
2778: if ns is None: ns__o = None
2779: else: ns__o = ns._o
2780: libxml2mod.xmlSetNs(self._o, ns__o)
2781:
2782: def setNsProp(self, ns, name, value):
2783: """Set (or reset) an attribute carried by a node. The ns
2784: structure must be in scope, this is not checked """
2785: if ns is None: ns__o = None
2786: else: ns__o = ns._o
2787: ret = libxml2mod.xmlSetNsProp(self._o, ns__o, name, value)
2788: if ret is None:raise treeError('xmlSetNsProp() failed')
2789: __tmp = xmlAttr(_obj=ret)
2790: return __tmp
2791:
2792: def setProp(self, name, value):
2793: """Set (or reset) an attribute carried by a node. If @name has
2794: a prefix, then the corresponding namespace-binding will be
2795: used, if in scope; it is an error it there's no such
2796: ns-binding for the prefix in scope. """
2797: ret = libxml2mod.xmlSetProp(self._o, name, value)
2798: if ret is None:raise treeError('xmlSetProp() failed')
2799: __tmp = xmlAttr(_obj=ret)
2800: return __tmp
2801:
2802: def setSpacePreserve(self, val):
2803: """Set (or reset) the space preserving behaviour of a node,
2804: i.e. the value of the xml:space attribute. """
2805: libxml2mod.xmlNodeSetSpacePreserve(self._o, val)
2806:
2807: def setTreeDoc(self, doc):
2808: """update all nodes under the tree to point to the right
2809: document """
2810: if doc is None: doc__o = None
2811: else: doc__o = doc._o
2812: libxml2mod.xmlSetTreeDoc(self._o, doc__o)
2813:
2814: def textConcat(self, content, len):
2815: """Concat the given string at the end of the existing node
2816: content """
2817: ret = libxml2mod.xmlTextConcat(self._o, content, len)
2818: return ret
2819:
2820: def textMerge(self, second):
2821: """Merge two text nodes into one """
2822: if second is None: second__o = None
2823: else: second__o = second._o
2824: ret = libxml2mod.xmlTextMerge(self._o, second__o)
2825: if ret is None:raise treeError('xmlTextMerge() failed')
2826: __tmp = xmlNode(_obj=ret)
2827: return __tmp
2828:
2829: def unlinkNode(self):
2830: """Unlink a node from it's current context, the node is not
2831: freed If one need to free the node, use xmlFreeNode()
2832: routine after the unlink to discard it. Note that namespace
2833: nodes can't be unlinked as they do not have pointer to
2834: their parent. """
2835: libxml2mod.xmlUnlinkNode(self._o)
2836:
2837: def unsetNsProp(self, ns, name):
2838: """Remove an attribute carried by a node. """
2839: if ns is None: ns__o = None
2840: else: ns__o = ns._o
2841: ret = libxml2mod.xmlUnsetNsProp(self._o, ns__o, name)
2842: return ret
2843:
2844: def unsetProp(self, name):
2845: """Remove an attribute carried by a node. This handles only
2846: attributes in no namespace. """
2847: ret = libxml2mod.xmlUnsetProp(self._o, name)
2848: return ret
2849:
2850: #
2851: # xmlNode functions from module valid
2852: #
2853:
2854: def isID(self, doc, attr):
2855: """Determine whether an attribute is of type ID. In case we
2856: have DTD(s) then this is done if DTD loading has been
2857: requested. In the case of HTML documents parsed with the
2858: HTML parser, then ID detection is done systematically. """
2859: if doc is None: doc__o = None
2860: else: doc__o = doc._o
2861: if attr is None: attr__o = None
2862: else: attr__o = attr._o
2863: ret = libxml2mod.xmlIsID(doc__o, self._o, attr__o)
2864: return ret
2865:
2866: def isRef(self, doc, attr):
2867: """Determine whether an attribute is of type Ref. In case we
2868: have DTD(s) then this is simple, otherwise we use an
2869: heuristic: name Ref (upper or lowercase). """
2870: if doc is None: doc__o = None
2871: else: doc__o = doc._o
2872: if attr is None: attr__o = None
2873: else: attr__o = attr._o
2874: ret = libxml2mod.xmlIsRef(doc__o, self._o, attr__o)
2875: return ret
2876:
2877: def validNormalizeAttributeValue(self, doc, name, value):
2878: """Does the validation related extra step of the normalization
2879: of attribute values: If the declared value is not CDATA,
2880: then the XML processor must further process the normalized
2881: attribute value by discarding any leading and trailing
2882: space (#x20) characters, and by replacing sequences of
2883: space (#x20) characters by single space (#x20) character. """
2884: if doc is None: doc__o = None
2885: else: doc__o = doc._o
2886: ret = libxml2mod.xmlValidNormalizeAttributeValue(doc__o, self._o, name, value)
2887: return ret
2888:
2889: #
2890: # xmlNode functions from module xinclude
2891: #
2892:
2893: def xincludeProcessTree(self):
2894: """Implement the XInclude substitution for the given subtree """
2895: ret = libxml2mod.xmlXIncludeProcessTree(self._o)
2896: return ret
2897:
2898: def xincludeProcessTreeFlags(self, flags):
2899: """Implement the XInclude substitution for the given subtree """
2900: ret = libxml2mod.xmlXIncludeProcessTreeFlags(self._o, flags)
2901: return ret
2902:
2903: #
2904: # xmlNode functions from module xmlschemas
2905: #
2906:
2907: def schemaValidateOneElement(self, ctxt):
2908: """Validate a branch of a tree, starting with the given @elem. """
2909: if ctxt is None: ctxt__o = None
2910: else: ctxt__o = ctxt._o
2911: ret = libxml2mod.xmlSchemaValidateOneElement(ctxt__o, self._o)
2912: return ret
2913:
2914: #
2915: # xmlNode functions from module xpath
2916: #
2917:
2918: def xpathCastNodeToNumber(self):
2919: """Converts a node to its number value """
2920: ret = libxml2mod.xmlXPathCastNodeToNumber(self._o)
2921: return ret
2922:
2923: def xpathCastNodeToString(self):
2924: """Converts a node to its string value. """
2925: ret = libxml2mod.xmlXPathCastNodeToString(self._o)
2926: return ret
2927:
2928: def xpathCmpNodes(self, node2):
2929: """Compare two nodes w.r.t document order """
2930: if node2 is None: node2__o = None
2931: else: node2__o = node2._o
2932: ret = libxml2mod.xmlXPathCmpNodes(self._o, node2__o)
2933: return ret
2934:
2935: def xpathNodeEval(self, str, ctx):
2936: """Evaluate the XPath Location Path in the given context. The
2937: node 'node' is set as the context node. The context node is
2938: not restored. """
2939: if ctx is None: ctx__o = None
2940: else: ctx__o = ctx._o
2941: ret = libxml2mod.xmlXPathNodeEval(self._o, str, ctx__o)
2942: if ret is None:raise xpathError('xmlXPathNodeEval() failed')
2943: return xpathObjectRet(ret)
2944:
2945: #
2946: # xmlNode functions from module xpathInternals
2947: #
2948:
2949: def xpathNewNodeSet(self):
2950: """Create a new xmlXPathObjectPtr of type NodeSet and
2951: initialize it with the single Node @val """
2952: ret = libxml2mod.xmlXPathNewNodeSet(self._o)
2953: if ret is None:raise xpathError('xmlXPathNewNodeSet() failed')
2954: return xpathObjectRet(ret)
2955:
2956: def xpathNewValueTree(self):
2957: """Create a new xmlXPathObjectPtr of type Value Tree (XSLT)
2958: and initialize it with the tree root @val """
2959: ret = libxml2mod.xmlXPathNewValueTree(self._o)
2960: if ret is None:raise xpathError('xmlXPathNewValueTree() failed')
2961: return xpathObjectRet(ret)
2962:
2963: def xpathNextAncestor(self, ctxt):
2964: """Traversal function for the "ancestor" direction the
2965: ancestor axis contains the ancestors of the context node;
2966: the ancestors of the context node consist of the parent of
2967: context node and the parent's parent and so on; the nodes
2968: are ordered in reverse document order; thus the parent is
2969: the first node on the axis, and the parent's parent is the
2970: second node on the axis """
2971: if ctxt is None: ctxt__o = None
2972: else: ctxt__o = ctxt._o
2973: ret = libxml2mod.xmlXPathNextAncestor(ctxt__o, self._o)
2974: if ret is None:raise xpathError('xmlXPathNextAncestor() failed')
2975: __tmp = xmlNode(_obj=ret)
2976: return __tmp
2977:
2978: def xpathNextAncestorOrSelf(self, ctxt):
2979: """Traversal function for the "ancestor-or-self" direction he
2980: ancestor-or-self axis contains the context node and
2981: ancestors of the context node in reverse document order;
2982: thus the context node is the first node on the axis, and
2983: the context node's parent the second; parent here is
2984: defined the same as with the parent axis. """
2985: if ctxt is None: ctxt__o = None
2986: else: ctxt__o = ctxt._o
2987: ret = libxml2mod.xmlXPathNextAncestorOrSelf(ctxt__o, self._o)
2988: if ret is None:raise xpathError('xmlXPathNextAncestorOrSelf() failed')
2989: __tmp = xmlNode(_obj=ret)
2990: return __tmp
2991:
2992: def xpathNextAttribute(self, ctxt):
2993: """Traversal function for the "attribute" direction TODO:
2994: support DTD inherited default attributes """
2995: if ctxt is None: ctxt__o = None
2996: else: ctxt__o = ctxt._o
2997: ret = libxml2mod.xmlXPathNextAttribute(ctxt__o, self._o)
2998: if ret is None:raise xpathError('xmlXPathNextAttribute() failed')
2999: __tmp = xmlNode(_obj=ret)
3000: return __tmp
3001:
3002: def xpathNextChild(self, ctxt):
3003: """Traversal function for the "child" direction The child axis
3004: contains the children of the context node in document order. """
3005: if ctxt is None: ctxt__o = None
3006: else: ctxt__o = ctxt._o
3007: ret = libxml2mod.xmlXPathNextChild(ctxt__o, self._o)
3008: if ret is None:raise xpathError('xmlXPathNextChild() failed')
3009: __tmp = xmlNode(_obj=ret)
3010: return __tmp
3011:
3012: def xpathNextDescendant(self, ctxt):
3013: """Traversal function for the "descendant" direction the
3014: descendant axis contains the descendants of the context
3015: node in document order; a descendant is a child or a child
3016: of a child and so on. """
3017: if ctxt is None: ctxt__o = None
3018: else: ctxt__o = ctxt._o
3019: ret = libxml2mod.xmlXPathNextDescendant(ctxt__o, self._o)
3020: if ret is None:raise xpathError('xmlXPathNextDescendant() failed')
3021: __tmp = xmlNode(_obj=ret)
3022: return __tmp
3023:
3024: def xpathNextDescendantOrSelf(self, ctxt):
3025: """Traversal function for the "descendant-or-self" direction
3026: the descendant-or-self axis contains the context node and
3027: the descendants of the context node in document order; thus
3028: the context node is the first node on the axis, and the
3029: first child of the context node is the second node on the
3030: axis """
3031: if ctxt is None: ctxt__o = None
3032: else: ctxt__o = ctxt._o
3033: ret = libxml2mod.xmlXPathNextDescendantOrSelf(ctxt__o, self._o)
3034: if ret is None:raise xpathError('xmlXPathNextDescendantOrSelf() failed')
3035: __tmp = xmlNode(_obj=ret)
3036: return __tmp
3037:
3038: def xpathNextFollowing(self, ctxt):
3039: """Traversal function for the "following" direction The
3040: following axis contains all nodes in the same document as
3041: the context node that are after the context node in
3042: document order, excluding any descendants and excluding
3043: attribute nodes and namespace nodes; the nodes are ordered
3044: in document order """
3045: if ctxt is None: ctxt__o = None
3046: else: ctxt__o = ctxt._o
3047: ret = libxml2mod.xmlXPathNextFollowing(ctxt__o, self._o)
3048: if ret is None:raise xpathError('xmlXPathNextFollowing() failed')
3049: __tmp = xmlNode(_obj=ret)
3050: return __tmp
3051:
3052: def xpathNextFollowingSibling(self, ctxt):
3053: """Traversal function for the "following-sibling" direction
3054: The following-sibling axis contains the following siblings
3055: of the context node in document order. """
3056: if ctxt is None: ctxt__o = None
3057: else: ctxt__o = ctxt._o
3058: ret = libxml2mod.xmlXPathNextFollowingSibling(ctxt__o, self._o)
3059: if ret is None:raise xpathError('xmlXPathNextFollowingSibling() failed')
3060: __tmp = xmlNode(_obj=ret)
3061: return __tmp
3062:
3063: def xpathNextNamespace(self, ctxt):
3064: """Traversal function for the "namespace" direction the
3065: namespace axis contains the namespace nodes of the context
3066: node; the order of nodes on this axis is
3067: implementation-defined; the axis will be empty unless the
3068: context node is an element We keep the XML namespace node
3069: at the end of the list. """
3070: if ctxt is None: ctxt__o = None
3071: else: ctxt__o = ctxt._o
3072: ret = libxml2mod.xmlXPathNextNamespace(ctxt__o, self._o)
3073: if ret is None:raise xpathError('xmlXPathNextNamespace() failed')
3074: __tmp = xmlNode(_obj=ret)
3075: return __tmp
3076:
3077: def xpathNextParent(self, ctxt):
3078: """Traversal function for the "parent" direction The parent
3079: axis contains the parent of the context node, if there is
3080: one. """
3081: if ctxt is None: ctxt__o = None
3082: else: ctxt__o = ctxt._o
3083: ret = libxml2mod.xmlXPathNextParent(ctxt__o, self._o)
3084: if ret is None:raise xpathError('xmlXPathNextParent() failed')
3085: __tmp = xmlNode(_obj=ret)
3086: return __tmp
3087:
3088: def xpathNextPreceding(self, ctxt):
3089: """Traversal function for the "preceding" direction the
3090: preceding axis contains all nodes in the same document as
3091: the context node that are before the context node in
3092: document order, excluding any ancestors and excluding
3093: attribute nodes and namespace nodes; the nodes are ordered
3094: in reverse document order """
3095: if ctxt is None: ctxt__o = None
3096: else: ctxt__o = ctxt._o
3097: ret = libxml2mod.xmlXPathNextPreceding(ctxt__o, self._o)
3098: if ret is None:raise xpathError('xmlXPathNextPreceding() failed')
3099: __tmp = xmlNode(_obj=ret)
3100: return __tmp
3101:
3102: def xpathNextPrecedingSibling(self, ctxt):
3103: """Traversal function for the "preceding-sibling" direction
3104: The preceding-sibling axis contains the preceding siblings
3105: of the context node in reverse document order; the first
3106: preceding sibling is first on the axis; the sibling
3107: preceding that node is the second on the axis and so on. """
3108: if ctxt is None: ctxt__o = None
3109: else: ctxt__o = ctxt._o
3110: ret = libxml2mod.xmlXPathNextPrecedingSibling(ctxt__o, self._o)
3111: if ret is None:raise xpathError('xmlXPathNextPrecedingSibling() failed')
3112: __tmp = xmlNode(_obj=ret)
3113: return __tmp
3114:
3115: def xpathNextSelf(self, ctxt):
3116: """Traversal function for the "self" direction The self axis
3117: contains just the context node itself """
3118: if ctxt is None: ctxt__o = None
3119: else: ctxt__o = ctxt._o
3120: ret = libxml2mod.xmlXPathNextSelf(ctxt__o, self._o)
3121: if ret is None:raise xpathError('xmlXPathNextSelf() failed')
3122: __tmp = xmlNode(_obj=ret)
3123: return __tmp
3124:
3125: #
3126: # xmlNode functions from module xpointer
3127: #
3128:
3129: def xpointerNewCollapsedRange(self):
3130: """Create a new xmlXPathObjectPtr of type range using a single
3131: nodes """
3132: ret = libxml2mod.xmlXPtrNewCollapsedRange(self._o)
3133: if ret is None:raise treeError('xmlXPtrNewCollapsedRange() failed')
3134: return xpathObjectRet(ret)
3135:
3136: def xpointerNewContext(self, doc, origin):
3137: """Create a new XPointer context """
3138: if doc is None: doc__o = None
3139: else: doc__o = doc._o
3140: if origin is None: origin__o = None
3141: else: origin__o = origin._o
3142: ret = libxml2mod.xmlXPtrNewContext(doc__o, self._o, origin__o)
3143: if ret is None:raise treeError('xmlXPtrNewContext() failed')
3144: __tmp = xpathContext(_obj=ret)
3145: return __tmp
3146:
3147: def xpointerNewLocationSetNodes(self, end):
3148: """Create a new xmlXPathObjectPtr of type LocationSet and
3149: initialize it with the single range made of the two nodes
3150: @start and @end """
3151: if end is None: end__o = None
3152: else: end__o = end._o
3153: ret = libxml2mod.xmlXPtrNewLocationSetNodes(self._o, end__o)
3154: if ret is None:raise treeError('xmlXPtrNewLocationSetNodes() failed')
3155: return xpathObjectRet(ret)
3156:
3157: def xpointerNewRange(self, startindex, end, endindex):
3158: """Create a new xmlXPathObjectPtr of type range """
3159: if end is None: end__o = None
3160: else: end__o = end._o
3161: ret = libxml2mod.xmlXPtrNewRange(self._o, startindex, end__o, endindex)
3162: if ret is None:raise treeError('xmlXPtrNewRange() failed')
3163: return xpathObjectRet(ret)
3164:
3165: def xpointerNewRangeNodes(self, end):
3166: """Create a new xmlXPathObjectPtr of type range using 2 nodes """
3167: if end is None: end__o = None
3168: else: end__o = end._o
3169: ret = libxml2mod.xmlXPtrNewRangeNodes(self._o, end__o)
3170: if ret is None:raise treeError('xmlXPtrNewRangeNodes() failed')
3171: return xpathObjectRet(ret)
3172:
3173: class xmlDoc(xmlNode):
3174: def __init__(self, _obj=None):
3175: if checkWrapper(_obj) != 0: raise TypeError('xmlDoc got a wrong wrapper object type')
3176: self._o = _obj
3177: xmlNode.__init__(self, _obj=_obj)
3178:
3179: def __repr__(self):
3180: return "<xmlDoc (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
3181:
3182: #
3183: # xmlDoc functions from module HTMLparser
3184: #
3185:
3186: def htmlAutoCloseTag(self, name, elem):
3187: """The HTML DTD allows a tag to implicitly close other tags.
3188: The list is kept in htmlStartClose array. This function
3189: checks if the element or one of it's children would
3190: autoclose the given tag. """
3191: ret = libxml2mod.htmlAutoCloseTag(self._o, name, elem)
3192: return ret
3193:
3194: def htmlIsAutoClosed(self, elem):
3195: """The HTML DTD allows a tag to implicitly close other tags.
3196: The list is kept in htmlStartClose array. This function
3197: checks if a tag is autoclosed by one of it's child """
3198: ret = libxml2mod.htmlIsAutoClosed(self._o, elem)
3199: return ret
3200:
3201: #
3202: # xmlDoc functions from module HTMLtree
3203: #
3204:
3205: def htmlDocContentDumpFormatOutput(self, buf, encoding, format):
3206: """Dump an HTML document. """
3207: if buf is None: buf__o = None
3208: else: buf__o = buf._o
3209: libxml2mod.htmlDocContentDumpFormatOutput(buf__o, self._o, encoding, format)
3210:
3211: def htmlDocContentDumpOutput(self, buf, encoding):
3212: """Dump an HTML document. Formating return/spaces are added. """
3213: if buf is None: buf__o = None
3214: else: buf__o = buf._o
3215: libxml2mod.htmlDocContentDumpOutput(buf__o, self._o, encoding)
3216:
3217: def htmlDocDump(self, f):
3218: """Dump an HTML document to an open FILE. """
3219: ret = libxml2mod.htmlDocDump(f, self._o)
3220: return ret
3221:
3222: def htmlGetMetaEncoding(self):
3223: """Encoding definition lookup in the Meta tags """
3224: ret = libxml2mod.htmlGetMetaEncoding(self._o)
3225: return ret
3226:
3227: def htmlNodeDumpFile(self, out, cur):
3228: """Dump an HTML node, recursive behaviour,children are printed
3229: too, and formatting returns are added. """
3230: if cur is None: cur__o = None
3231: else: cur__o = cur._o
3232: libxml2mod.htmlNodeDumpFile(out, self._o, cur__o)
3233:
3234: def htmlNodeDumpFileFormat(self, out, cur, encoding, format):
3235: """Dump an HTML node, recursive behaviour,children are printed
3236: too. TODO: if encoding == None try to save in the doc
3237: encoding """
3238: if cur is None: cur__o = None
3239: else: cur__o = cur._o
3240: ret = libxml2mod.htmlNodeDumpFileFormat(out, self._o, cur__o, encoding, format)
3241: return ret
3242:
3243: def htmlNodeDumpFormatOutput(self, buf, cur, encoding, format):
3244: """Dump an HTML node, recursive behaviour,children are printed
3245: too. """
3246: if buf is None: buf__o = None
3247: else: buf__o = buf._o
3248: if cur is None: cur__o = None
3249: else: cur__o = cur._o
3250: libxml2mod.htmlNodeDumpFormatOutput(buf__o, self._o, cur__o, encoding, format)
3251:
3252: def htmlNodeDumpOutput(self, buf, cur, encoding):
3253: """Dump an HTML node, recursive behaviour,children are printed
3254: too, and formatting returns/spaces are added. """
3255: if buf is None: buf__o = None
3256: else: buf__o = buf._o
3257: if cur is None: cur__o = None
3258: else: cur__o = cur._o
3259: libxml2mod.htmlNodeDumpOutput(buf__o, self._o, cur__o, encoding)
3260:
3261: def htmlSaveFile(self, filename):
3262: """Dump an HTML document to a file. If @filename is "-" the
3263: stdout file is used. """
3264: ret = libxml2mod.htmlSaveFile(filename, self._o)
3265: return ret
3266:
3267: def htmlSaveFileEnc(self, filename, encoding):
3268: """Dump an HTML document to a file using a given encoding and
3269: formatting returns/spaces are added. """
3270: ret = libxml2mod.htmlSaveFileEnc(filename, self._o, encoding)
3271: return ret
3272:
3273: def htmlSaveFileFormat(self, filename, encoding, format):
3274: """Dump an HTML document to a file using a given encoding. """
3275: ret = libxml2mod.htmlSaveFileFormat(filename, self._o, encoding, format)
3276: return ret
3277:
3278: def htmlSetMetaEncoding(self, encoding):
3279: """Sets the current encoding in the Meta tags NOTE: this will
3280: not change the document content encoding, just the META
3281: flag associated. """
3282: ret = libxml2mod.htmlSetMetaEncoding(self._o, encoding)
3283: return ret
3284:
3285: #
3286: # xmlDoc functions from module debugXML
3287: #
3288:
3289: def debugCheckDocument(self, output):
3290: """Check the document for potential content problems, and
3291: output the errors to @output """
3292: ret = libxml2mod.xmlDebugCheckDocument(output, self._o)
3293: return ret
3294:
3295: def debugDumpDocument(self, output):
3296: """Dumps debug information for the document, it's recursive """
3297: libxml2mod.xmlDebugDumpDocument(output, self._o)
3298:
3299: def debugDumpDocumentHead(self, output):
3300: """Dumps debug information cncerning the document, not
3301: recursive """
3302: libxml2mod.xmlDebugDumpDocumentHead(output, self._o)
3303:
3304: def debugDumpEntities(self, output):
3305: """Dumps debug information for all the entities in use by the
3306: document """
3307: libxml2mod.xmlDebugDumpEntities(output, self._o)
3308:
3309: #
3310: # xmlDoc functions from module entities
3311: #
3312:
3313: def addDocEntity(self, name, type, ExternalID, SystemID, content):
3314: """Register a new entity for this document. """
3315: ret = libxml2mod.xmlAddDocEntity(self._o, name, type, ExternalID, SystemID, content)
3316: if ret is None:raise treeError('xmlAddDocEntity() failed')
3317: __tmp = xmlEntity(_obj=ret)
3318: return __tmp
3319:
3320: def addDtdEntity(self, name, type, ExternalID, SystemID, content):
3321: """Register a new entity for this document DTD external subset. """
3322: ret = libxml2mod.xmlAddDtdEntity(self._o, name, type, ExternalID, SystemID, content)
3323: if ret is None:raise treeError('xmlAddDtdEntity() failed')
3324: __tmp = xmlEntity(_obj=ret)
3325: return __tmp
3326:
3327: def docEntity(self, name):
3328: """Do an entity lookup in the document entity hash table and """
3329: ret = libxml2mod.xmlGetDocEntity(self._o, name)
3330: if ret is None:raise treeError('xmlGetDocEntity() failed')
3331: __tmp = xmlEntity(_obj=ret)
3332: return __tmp
3333:
3334: def dtdEntity(self, name):
3335: """Do an entity lookup in the DTD entity hash table and """
3336: ret = libxml2mod.xmlGetDtdEntity(self._o, name)
3337: if ret is None:raise treeError('xmlGetDtdEntity() failed')
3338: __tmp = xmlEntity(_obj=ret)
3339: return __tmp
3340:
3341: def encodeEntities(self, input):
3342: """TODO: remove xmlEncodeEntities, once we are not afraid of
3343: breaking binary compatibility People must migrate their
3344: code to xmlEncodeEntitiesReentrant ! This routine will
3345: issue a warning when encountered. """
3346: ret = libxml2mod.xmlEncodeEntities(self._o, input)
3347: return ret
3348:
3349: def encodeEntitiesReentrant(self, input):
3350: """Do a global encoding of a string, replacing the predefined
3351: entities and non ASCII values with their entities and
3352: CharRef counterparts. Contrary to xmlEncodeEntities, this
3353: routine is reentrant, and result must be deallocated. """
3354: ret = libxml2mod.xmlEncodeEntitiesReentrant(self._o, input)
3355: return ret
3356:
3357: def encodeSpecialChars(self, input):
3358: """Do a global encoding of a string, replacing the predefined
3359: entities this routine is reentrant, and result must be
3360: deallocated. """
3361: ret = libxml2mod.xmlEncodeSpecialChars(self._o, input)
3362: return ret
3363:
3364: def newEntity(self, name, type, ExternalID, SystemID, content):
3365: """Create a new entity, this differs from xmlAddDocEntity()
3366: that if the document is None or has no internal subset
3367: defined, then an unlinked entity structure will be
3368: returned, it is then the responsability of the caller to
3369: link it to the document later or free it when not needed
3370: anymore. """
3371: ret = libxml2mod.xmlNewEntity(self._o, name, type, ExternalID, SystemID, content)
3372: if ret is None:raise treeError('xmlNewEntity() failed')
3373: __tmp = xmlEntity(_obj=ret)
3374: return __tmp
3375:
3376: def parameterEntity(self, name):
3377: """Do an entity lookup in the internal and external subsets and """
3378: ret = libxml2mod.xmlGetParameterEntity(self._o, name)
3379: if ret is None:raise treeError('xmlGetParameterEntity() failed')
3380: __tmp = xmlEntity(_obj=ret)
3381: return __tmp
3382:
3383: #
3384: # xmlDoc functions from module relaxng
3385: #
3386:
3387: def relaxNGNewDocParserCtxt(self):
3388: """Create an XML RelaxNGs parser context for that document.
3389: Note: since the process of compiling a RelaxNG schemas
3390: modifies the document, the @doc parameter is duplicated
3391: internally. """
3392: ret = libxml2mod.xmlRelaxNGNewDocParserCtxt(self._o)
3393: if ret is None:raise parserError('xmlRelaxNGNewDocParserCtxt() failed')
3394: __tmp = relaxNgParserCtxt(_obj=ret)
3395: return __tmp
3396:
3397: def relaxNGValidateDoc(self, ctxt):
3398: """Validate a document tree in memory. """
3399: if ctxt is None: ctxt__o = None
3400: else: ctxt__o = ctxt._o
3401: ret = libxml2mod.xmlRelaxNGValidateDoc(ctxt__o, self._o)
3402: return ret
3403:
3404: def relaxNGValidateFullElement(self, ctxt, elem):
3405: """Validate a full subtree when
3406: xmlRelaxNGValidatePushElement() returned 0 and the content
3407: of the node has been expanded. """
3408: if ctxt is None: ctxt__o = None
3409: else: ctxt__o = ctxt._o
3410: if elem is None: elem__o = None
3411: else: elem__o = elem._o
3412: ret = libxml2mod.xmlRelaxNGValidateFullElement(ctxt__o, self._o, elem__o)
3413: return ret
3414:
3415: def relaxNGValidatePopElement(self, ctxt, elem):
3416: """Pop the element end from the RelaxNG validation stack. """
3417: if ctxt is None: ctxt__o = None
3418: else: ctxt__o = ctxt._o
3419: if elem is None: elem__o = None
3420: else: elem__o = elem._o
3421: ret = libxml2mod.xmlRelaxNGValidatePopElement(ctxt__o, self._o, elem__o)
3422: return ret
3423:
3424: def relaxNGValidatePushElement(self, ctxt, elem):
3425: """Push a new element start on the RelaxNG validation stack. """
3426: if ctxt is None: ctxt__o = None
3427: else: ctxt__o = ctxt._o
3428: if elem is None: elem__o = None
3429: else: elem__o = elem._o
3430: ret = libxml2mod.xmlRelaxNGValidatePushElement(ctxt__o, self._o, elem__o)
3431: return ret
3432:
3433: #
3434: # xmlDoc functions from module tree
3435: #
3436:
3437: def copyDoc(self, recursive):
3438: """Do a copy of the document info. If recursive, the content
3439: tree will be copied too as well as DTD, namespaces and
3440: entities. """
3441: ret = libxml2mod.xmlCopyDoc(self._o, recursive)
3442: if ret is None:raise treeError('xmlCopyDoc() failed')
3443: __tmp = xmlDoc(_obj=ret)
3444: return __tmp
3445:
3446: def copyNode(self, node, extended):
3447: """Do a copy of the node to a given document. """
3448: if node is None: node__o = None
3449: else: node__o = node._o
3450: ret = libxml2mod.xmlDocCopyNode(node__o, self._o, extended)
3451: if ret is None:raise treeError('xmlDocCopyNode() failed')
3452: __tmp = xmlNode(_obj=ret)
3453: return __tmp
3454:
3455: def copyNodeList(self, node):
3456: """Do a recursive copy of the node list. """
3457: if node is None: node__o = None
3458: else: node__o = node._o
3459: ret = libxml2mod.xmlDocCopyNodeList(self._o, node__o)
3460: if ret is None:raise treeError('xmlDocCopyNodeList() failed')
3461: __tmp = xmlNode(_obj=ret)
3462: return __tmp
3463:
3464: def createIntSubset(self, name, ExternalID, SystemID):
3465: """Create the internal subset of a document """
3466: ret = libxml2mod.xmlCreateIntSubset(self._o, name, ExternalID, SystemID)
3467: if ret is None:raise treeError('xmlCreateIntSubset() failed')
3468: __tmp = xmlDtd(_obj=ret)
3469: return __tmp
3470:
3471: def docCompressMode(self):
3472: """get the compression ratio for a document, ZLIB based """
3473: ret = libxml2mod.xmlGetDocCompressMode(self._o)
3474: return ret
3475:
3476: def dump(self, f):
3477: """Dump an XML document to an open FILE. """
3478: ret = libxml2mod.xmlDocDump(f, self._o)
3479: return ret
3480:
3481: def elemDump(self, f, cur):
3482: """Dump an XML/HTML node, recursive behaviour, children are
3483: printed too. """
3484: if cur is None: cur__o = None
3485: else: cur__o = cur._o
3486: libxml2mod.xmlElemDump(f, self._o, cur__o)
3487:
3488: def formatDump(self, f, format):
3489: """Dump an XML document to an open FILE. """
3490: ret = libxml2mod.xmlDocFormatDump(f, self._o, format)
3491: return ret
3492:
3493: def freeDoc(self):
3494: """Free up all the structures used by a document, tree
3495: included. """
3496: libxml2mod.xmlFreeDoc(self._o)
3497:
3498: def getRootElement(self):
3499: """Get the root element of the document (doc->children is a
3500: list containing possibly comments, PIs, etc ...). """
3501: ret = libxml2mod.xmlDocGetRootElement(self._o)
3502: if ret is None:raise treeError('xmlDocGetRootElement() failed')
3503: __tmp = xmlNode(_obj=ret)
3504: return __tmp
3505:
3506: def intSubset(self):
3507: """Get the internal subset of a document """
3508: ret = libxml2mod.xmlGetIntSubset(self._o)
3509: if ret is None:raise treeError('xmlGetIntSubset() failed')
3510: __tmp = xmlDtd(_obj=ret)
3511: return __tmp
3512:
3513: def newCDataBlock(self, content, len):
3514: """Creation of a new node containing a CDATA block. """
3515: ret = libxml2mod.xmlNewCDataBlock(self._o, content, len)
3516: if ret is None:raise treeError('xmlNewCDataBlock() failed')
3517: __tmp = xmlNode(_obj=ret)
3518: return __tmp
3519:
3520: def newCharRef(self, name):
3521: """Creation of a new character reference node. """
3522: ret = libxml2mod.xmlNewCharRef(self._o, name)
3523: if ret is None:raise treeError('xmlNewCharRef() failed')
3524: __tmp = xmlNode(_obj=ret)
3525: return __tmp
3526:
3527: def newDocComment(self, content):
3528: """Creation of a new node containing a comment within a
3529: document. """
3530: ret = libxml2mod.xmlNewDocComment(self._o, content)
3531: if ret is None:raise treeError('xmlNewDocComment() failed')
3532: __tmp = xmlNode(_obj=ret)
3533: return __tmp
3534:
3535: def newDocFragment(self):
3536: """Creation of a new Fragment node. """
3537: ret = libxml2mod.xmlNewDocFragment(self._o)
3538: if ret is None:raise treeError('xmlNewDocFragment() failed')
3539: __tmp = xmlNode(_obj=ret)
3540: return __tmp
3541:
3542: def newDocNode(self, ns, name, content):
3543: """Creation of a new node element within a document. @ns and
3544: @content are optional (None). NOTE: @content is supposed to
3545: be a piece of XML CDATA, so it allow entities references,
3546: but XML special chars need to be escaped first by using
3547: xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you
3548: don't need entities support. """
3549: if ns is None: ns__o = None
3550: else: ns__o = ns._o
3551: ret = libxml2mod.xmlNewDocNode(self._o, ns__o, name, content)
3552: if ret is None:raise treeError('xmlNewDocNode() failed')
3553: __tmp = xmlNode(_obj=ret)
3554: return __tmp
3555:
3556: def newDocNodeEatName(self, ns, name, content):
3557: """Creation of a new node element within a document. @ns and
3558: @content are optional (None). NOTE: @content is supposed to
3559: be a piece of XML CDATA, so it allow entities references,
3560: but XML special chars need to be escaped first by using
3561: xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you
3562: don't need entities support. """
3563: if ns is None: ns__o = None
3564: else: ns__o = ns._o
3565: ret = libxml2mod.xmlNewDocNodeEatName(self._o, ns__o, name, content)
3566: if ret is None:raise treeError('xmlNewDocNodeEatName() failed')
3567: __tmp = xmlNode(_obj=ret)
3568: return __tmp
3569:
3570: def newDocPI(self, name, content):
3571: """Creation of a processing instruction element. """
3572: ret = libxml2mod.xmlNewDocPI(self._o, name, content)
3573: if ret is None:raise treeError('xmlNewDocPI() failed')
3574: __tmp = xmlNode(_obj=ret)
3575: return __tmp
3576:
3577: def newDocProp(self, name, value):
3578: """Create a new property carried by a document. """
3579: ret = libxml2mod.xmlNewDocProp(self._o, name, value)
3580: if ret is None:raise treeError('xmlNewDocProp() failed')
3581: __tmp = xmlAttr(_obj=ret)
3582: return __tmp
3583:
3584: def newDocRawNode(self, ns, name, content):
3585: """Creation of a new node element within a document. @ns and
3586: @content are optional (None). """
3587: if ns is None: ns__o = None
3588: else: ns__o = ns._o
3589: ret = libxml2mod.xmlNewDocRawNode(self._o, ns__o, name, content)
3590: if ret is None:raise treeError('xmlNewDocRawNode() failed')
3591: __tmp = xmlNode(_obj=ret)
3592: return __tmp
3593:
3594: def newDocText(self, content):
3595: """Creation of a new text node within a document. """
3596: ret = libxml2mod.xmlNewDocText(self._o, content)
3597: if ret is None:raise treeError('xmlNewDocText() failed')
3598: __tmp = xmlNode(_obj=ret)
3599: return __tmp
3600:
3601: def newDocTextLen(self, content, len):
3602: """Creation of a new text node with an extra content length
3603: parameter. The text node pertain to a given document. """
3604: ret = libxml2mod.xmlNewDocTextLen(self._o, content, len)
3605: if ret is None:raise treeError('xmlNewDocTextLen() failed')
3606: __tmp = xmlNode(_obj=ret)
3607: return __tmp
3608:
3609: def newDtd(self, name, ExternalID, SystemID):
3610: """Creation of a new DTD for the external subset. To create an
3611: internal subset, use xmlCreateIntSubset(). """
3612: ret = libxml2mod.xmlNewDtd(self._o, name, ExternalID, SystemID)
3613: if ret is None:raise treeError('xmlNewDtd() failed')
3614: __tmp = xmlDtd(_obj=ret)
3615: return __tmp
3616:
3617: def newGlobalNs(self, href, prefix):
3618: """Creation of a Namespace, the old way using PI and without
3619: scoping DEPRECATED !!! """
3620: ret = libxml2mod.xmlNewGlobalNs(self._o, href, prefix)
3621: if ret is None:raise treeError('xmlNewGlobalNs() failed')
3622: __tmp = xmlNs(_obj=ret)
3623: return __tmp
3624:
3625: def newReference(self, name):
3626: """Creation of a new reference node. """
3627: ret = libxml2mod.xmlNewReference(self._o, name)
3628: if ret is None:raise treeError('xmlNewReference() failed')
3629: __tmp = xmlNode(_obj=ret)
3630: return __tmp
3631:
3632: def nodeDumpOutput(self, buf, cur, level, format, encoding):
3633: """Dump an XML node, recursive behaviour, children are printed
3634: too. Note that @format = 1 provide node indenting only if
3635: xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was
3636: called """
3637: if buf is None: buf__o = None
3638: else: buf__o = buf._o
3639: if cur is None: cur__o = None
3640: else: cur__o = cur._o
3641: libxml2mod.xmlNodeDumpOutput(buf__o, self._o, cur__o, level, format, encoding)
3642:
3643: def nodeGetBase(self, cur):
3644: """Searches for the BASE URL. The code should work on both XML
3645: and HTML document even if base mechanisms are completely
3646: different. It returns the base as defined in RFC 2396
3647: sections 5.1.1. Base URI within Document Content and 5.1.2.
3648: Base URI from the Encapsulating Entity However it does not
3649: return the document base (5.1.3), use doc->URL in this case """
3650: if cur is None: cur__o = None
3651: else: cur__o = cur._o
3652: ret = libxml2mod.xmlNodeGetBase(self._o, cur__o)
3653: return ret
3654:
3655: def nodeListGetRawString(self, list, inLine):
3656: """Builds the string equivalent to the text contained in the
3657: Node list made of TEXTs and ENTITY_REFs, contrary to
3658: xmlNodeListGetString() this function doesn't do any
3659: character encoding handling. """
3660: if list is None: list__o = None
3661: else: list__o = list._o
3662: ret = libxml2mod.xmlNodeListGetRawString(self._o, list__o, inLine)
3663: return ret
3664:
3665: def nodeListGetString(self, list, inLine):
3666: """Build the string equivalent to the text contained in the
3667: Node list made of TEXTs and ENTITY_REFs """
3668: if list is None: list__o = None
3669: else: list__o = list._o
3670: ret = libxml2mod.xmlNodeListGetString(self._o, list__o, inLine)
3671: return ret
3672:
3673: def reconciliateNs(self, tree):
3674: """This function checks that all the namespaces declared
3675: within the given tree are properly declared. This is needed
3676: for example after Copy or Cut and then paste operations.
3677: The subtree may still hold pointers to namespace
3678: declarations outside the subtree or invalid/masked. As much
3679: as possible the function try to reuse the existing
3680: namespaces found in the new environment. If not possible
3681: the new namespaces are redeclared on @tree at the top of
3682: the given subtree. """
3683: if tree is None: tree__o = None
3684: else: tree__o = tree._o
3685: ret = libxml2mod.xmlReconciliateNs(self._o, tree__o)
3686: return ret
3687:
3688: def saveFile(self, filename):
3689: """Dump an XML document to a file. Will use compression if
3690: compiled in and enabled. If @filename is "-" the stdout
3691: file is used. """
3692: ret = libxml2mod.xmlSaveFile(filename, self._o)
3693: return ret
3694:
3695: def saveFileEnc(self, filename, encoding):
3696: """Dump an XML document, converting it to the given encoding """
3697: ret = libxml2mod.xmlSaveFileEnc(filename, self._o, encoding)
3698: return ret
3699:
3700: def saveFileTo(self, buf, encoding):
3701: """Dump an XML document to an I/O buffer. Warning ! This call
3702: xmlOutputBufferClose() on buf which is not available after
3703: this call. """
3704: if buf is None: buf__o = None
3705: else: buf__o = buf._o
3706: ret = libxml2mod.xmlSaveFileTo(buf__o, self._o, encoding)
3707: return ret
3708:
3709: def saveFormatFile(self, filename, format):
3710: """Dump an XML document to a file. Will use compression if
3711: compiled in and enabled. If @filename is "-" the stdout
3712: file is used. If @format is set then the document will be
3713: indented on output. Note that @format = 1 provide node
3714: indenting only if xmlIndentTreeOutput = 1 or
3715: xmlKeepBlanksDefault(0) was called """
3716: ret = libxml2mod.xmlSaveFormatFile(filename, self._o, format)
3717: return ret
3718:
3719: def saveFormatFileEnc(self, filename, encoding, format):
3720: """Dump an XML document to a file or an URL. """
3721: ret = libxml2mod.xmlSaveFormatFileEnc(filename, self._o, encoding, format)
3722: return ret
3723:
3724: def saveFormatFileTo(self, buf, encoding, format):
3725: """Dump an XML document to an I/O buffer. Warning ! This call
3726: xmlOutputBufferClose() on buf which is not available after
3727: this call. """
3728: if buf is None: buf__o = None
3729: else: buf__o = buf._o
3730: ret = libxml2mod.xmlSaveFormatFileTo(buf__o, self._o, encoding, format)
3731: return ret
3732:
3733: def searchNs(self, node, nameSpace):
3734: """Search a Ns registered under a given name space for a
3735: document. recurse on the parents until it finds the defined
3736: namespace or return None otherwise. @nameSpace can be None,
3737: this is a search for the default namespace. We don't allow
3738: to cross entities boundaries. If you don't declare the
3739: namespace within those you will be in troubles !!! A
3740: warning is generated to cover this case. """
3741: if node is None: node__o = None
3742: else: node__o = node._o
3743: ret = libxml2mod.xmlSearchNs(self._o, node__o, nameSpace)
3744: if ret is None:raise treeError('xmlSearchNs() failed')
3745: __tmp = xmlNs(_obj=ret)
3746: return __tmp
3747:
3748: def searchNsByHref(self, node, href):
3749: """Search a Ns aliasing a given URI. Recurse on the parents
3750: until it finds the defined namespace or return None
3751: otherwise. """
3752: if node is None: node__o = None
3753: else: node__o = node._o
3754: ret = libxml2mod.xmlSearchNsByHref(self._o, node__o, href)
3755: if ret is None:raise treeError('xmlSearchNsByHref() failed')
3756: __tmp = xmlNs(_obj=ret)
3757: return __tmp
3758:
3759: def setDocCompressMode(self, mode):
3760: """set the compression ratio for a document, ZLIB based
3761: Correct values: 0 (uncompressed) to 9 (max compression) """
3762: libxml2mod.xmlSetDocCompressMode(self._o, mode)
3763:
3764: def setListDoc(self, list):
3765: """update all nodes in the list to point to the right document """
3766: if list is None: list__o = None
3767: else: list__o = list._o
3768: libxml2mod.xmlSetListDoc(list__o, self._o)
3769:
3770: def setRootElement(self, root):
3771: """Set the root element of the document (doc->children is a
3772: list containing possibly comments, PIs, etc ...). """
3773: if root is None: root__o = None
3774: else: root__o = root._o
3775: ret = libxml2mod.xmlDocSetRootElement(self._o, root__o)
3776: if ret is None:return None
3777: __tmp = xmlNode(_obj=ret)
3778: return __tmp
3779:
3780: def setTreeDoc(self, tree):
3781: """update all nodes under the tree to point to the right
3782: document """
3783: if tree is None: tree__o = None
3784: else: tree__o = tree._o
3785: libxml2mod.xmlSetTreeDoc(tree__o, self._o)
3786:
3787: def stringGetNodeList(self, value):
3788: """Parse the value string and build the node list associated.
3789: Should produce a flat tree with only TEXTs and ENTITY_REFs. """
3790: ret = libxml2mod.xmlStringGetNodeList(self._o, value)
3791: if ret is None:raise treeError('xmlStringGetNodeList() failed')
3792: __tmp = xmlNode(_obj=ret)
3793: return __tmp
3794:
3795: def stringLenGetNodeList(self, value, len):
3796: """Parse the value string and build the node list associated.
3797: Should produce a flat tree with only TEXTs and ENTITY_REFs. """
3798: ret = libxml2mod.xmlStringLenGetNodeList(self._o, value, len)
3799: if ret is None:raise treeError('xmlStringLenGetNodeList() failed')
3800: __tmp = xmlNode(_obj=ret)
3801: return __tmp
3802:
3803: #
3804: # xmlDoc functions from module valid
3805: #
3806:
3807: def ID(self, ID):
3808: """Search the attribute declaring the given ID """
3809: ret = libxml2mod.xmlGetID(self._o, ID)
3810: if ret is None:raise treeError('xmlGetID() failed')
3811: __tmp = xmlAttr(_obj=ret)
3812: return __tmp
3813:
3814: def isID(self, elem, attr):
3815: """Determine whether an attribute is of type ID. In case we
3816: have DTD(s) then this is done if DTD loading has been
3817: requested. In the case of HTML documents parsed with the
3818: HTML parser, then ID detection is done systematically. """
3819: if elem is None: elem__o = None
3820: else: elem__o = elem._o
3821: if attr is None: attr__o = None
3822: else: attr__o = attr._o
3823: ret = libxml2mod.xmlIsID(self._o, elem__o, attr__o)
3824: return ret
3825:
3826: def isMixedElement(self, name):
3827: """Search in the DtDs whether an element accept Mixed content
3828: (or ANY) basically if it is supposed to accept text childs """
3829: ret = libxml2mod.xmlIsMixedElement(self._o, name)
3830: return ret
3831:
3832: def isRef(self, elem, attr):
3833: """Determine whether an attribute is of type Ref. In case we
3834: have DTD(s) then this is simple, otherwise we use an
3835: heuristic: name Ref (upper or lowercase). """
3836: if elem is None: elem__o = None
3837: else: elem__o = elem._o
3838: if attr is None: attr__o = None
3839: else: attr__o = attr._o
3840: ret = libxml2mod.xmlIsRef(self._o, elem__o, attr__o)
3841: return ret
3842:
3843: def removeID(self, attr):
3844: """Remove the given attribute from the ID table maintained
3845: internally. """
3846: if attr is None: attr__o = None
3847: else: attr__o = attr._o
3848: ret = libxml2mod.xmlRemoveID(self._o, attr__o)
3849: return ret
3850:
3851: def removeRef(self, attr):
3852: """Remove the given attribute from the Ref table maintained
3853: internally. """
3854: if attr is None: attr__o = None
3855: else: attr__o = attr._o
3856: ret = libxml2mod.xmlRemoveRef(self._o, attr__o)
3857: return ret
3858:
3859: def validCtxtNormalizeAttributeValue(self, ctxt, elem, name, value):
3860: """Does the validation related extra step of the normalization
3861: of attribute values: If the declared value is not CDATA,
3862: then the XML processor must further process the normalized
3863: attribute value by discarding any leading and trailing
3864: space (#x20) characters, and by replacing sequences of
3865: space (#x20) characters by single space (#x20) character.
3866: Also check VC: Standalone Document Declaration in P32, and
3867: update ctxt->valid accordingly """
3868: if ctxt is None: ctxt__o = None
3869: else: ctxt__o = ctxt._o
3870: if elem is None: elem__o = None
3871: else: elem__o = elem._o
3872: ret = libxml2mod.xmlValidCtxtNormalizeAttributeValue(ctxt__o, self._o, elem__o, name, value)
3873: return ret
3874:
3875: def validNormalizeAttributeValue(self, elem, name, value):
3876: """Does the validation related extra step of the normalization
3877: of attribute values: If the declared value is not CDATA,
3878: then the XML processor must further process the normalized
3879: attribute value by discarding any leading and trailing
3880: space (#x20) characters, and by replacing sequences of
3881: space (#x20) characters by single space (#x20) character. """
3882: if elem is None: elem__o = None
3883: else: elem__o = elem._o
3884: ret = libxml2mod.xmlValidNormalizeAttributeValue(self._o, elem__o, name, value)
3885: return ret
3886:
3887: def validateDocument(self, ctxt):
3888: """Try to validate the document instance basically it does
3889: the all the checks described by the XML Rec i.e. validates
3890: the internal and external subset (if present) and validate
3891: the document tree. """
3892: if ctxt is None: ctxt__o = None
3893: else: ctxt__o = ctxt._o
3894: ret = libxml2mod.xmlValidateDocument(ctxt__o, self._o)
3895: return ret
3896:
3897: def validateDocumentFinal(self, ctxt):
3898: """Does the final step for the document validation once all
3899: the incremental validation steps have been completed
3900: basically it does the following checks described by the XML
3901: Rec Check all the IDREF/IDREFS attributes definition for
3902: validity """
3903: if ctxt is None: ctxt__o = None
3904: else: ctxt__o = ctxt._o
3905: ret = libxml2mod.xmlValidateDocumentFinal(ctxt__o, self._o)
3906: return ret
3907:
3908: def validateDtd(self, ctxt, dtd):
3909: """Try to validate the document against the dtd instance
3910: Basically it does check all the definitions in the DtD.
3911: Note the the internal subset (if present) is de-coupled
3912: (i.e. not used), which could give problems if ID or IDREF
3913: is present. """
3914: if ctxt is None: ctxt__o = None
3915: else: ctxt__o = ctxt._o
3916: if dtd is None: dtd__o = None
3917: else: dtd__o = dtd._o
3918: ret = libxml2mod.xmlValidateDtd(ctxt__o, self._o, dtd__o)
3919: return ret
3920:
3921: def validateDtdFinal(self, ctxt):
3922: """Does the final step for the dtds validation once all the
3923: subsets have been parsed basically it does the following
3924: checks described by the XML Rec - check that ENTITY and
3925: ENTITIES type attributes default or possible values matches
3926: one of the defined entities. - check that NOTATION type
3927: attributes default or possible values matches one of the
3928: defined notations. """
3929: if ctxt is None: ctxt__o = None
3930: else: ctxt__o = ctxt._o
3931: ret = libxml2mod.xmlValidateDtdFinal(ctxt__o, self._o)
3932: return ret
3933:
3934: def validateElement(self, ctxt, elem):
3935: """Try to validate the subtree under an element """
3936: if ctxt is None: ctxt__o = None
3937: else: ctxt__o = ctxt._o
3938: if elem is None: elem__o = None
3939: else: elem__o = elem._o
3940: ret = libxml2mod.xmlValidateElement(ctxt__o, self._o, elem__o)
3941: return ret
3942:
3943: def validateNotationUse(self, ctxt, notationName):
3944: """Validate that the given name match a notation declaration.
3945: - [ VC: Notation Declared ] """
3946: if ctxt is None: ctxt__o = None
3947: else: ctxt__o = ctxt._o
3948: ret = libxml2mod.xmlValidateNotationUse(ctxt__o, self._o, notationName)
3949: return ret
3950:
3951: def validateOneAttribute(self, ctxt, elem, attr, value):
3952: """Try to validate a single attribute for an element basically
3953: it does the following checks as described by the XML-1.0
3954: recommendation: - [ VC: Attribute Value Type ] - [ VC:
3955: Fixed Attribute Default ] - [ VC: Entity Name ] - [ VC:
3956: Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC: Entity
3957: Name ] - [ VC: Notation Attributes ] The ID/IDREF
3958: uniqueness and matching are done separately """
3959: if ctxt is None: ctxt__o = None
3960: else: ctxt__o = ctxt._o
3961: if elem is None: elem__o = None
3962: else: elem__o = elem._o
3963: if attr is None: attr__o = None
3964: else: attr__o = attr._o
3965: ret = libxml2mod.xmlValidateOneAttribute(ctxt__o, self._o, elem__o, attr__o, value)
3966: return ret
3967:
3968: def validateOneElement(self, ctxt, elem):
3969: """Try to validate a single element and it's attributes,
3970: basically it does the following checks as described by the
3971: XML-1.0 recommendation: - [ VC: Element Valid ] - [ VC:
3972: Required Attribute ] Then call xmlValidateOneAttribute()
3973: for each attribute present. The ID/IDREF checkings are
3974: done separately """
3975: if ctxt is None: ctxt__o = None
3976: else: ctxt__o = ctxt._o
3977: if elem is None: elem__o = None
3978: else: elem__o = elem._o
3979: ret = libxml2mod.xmlValidateOneElement(ctxt__o, self._o, elem__o)
3980: return ret
3981:
3982: def validateOneNamespace(self, ctxt, elem, prefix, ns, value):
3983: """Try to validate a single namespace declaration for an
3984: element basically it does the following checks as described
3985: by the XML-1.0 recommendation: - [ VC: Attribute Value Type
3986: ] - [ VC: Fixed Attribute Default ] - [ VC: Entity Name ] -
3987: [ VC: Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC:
3988: Entity Name ] - [ VC: Notation Attributes ] The ID/IDREF
3989: uniqueness and matching are done separately """
3990: if ctxt is None: ctxt__o = None
3991: else: ctxt__o = ctxt._o
3992: if elem is None: elem__o = None
3993: else: elem__o = elem._o
3994: if ns is None: ns__o = None
3995: else: ns__o = ns._o
3996: ret = libxml2mod.xmlValidateOneNamespace(ctxt__o, self._o, elem__o, prefix, ns__o, value)
3997: return ret
3998:
3999: def validatePopElement(self, ctxt, elem, qname):
4000: """Pop the element end from the validation stack. """
4001: if ctxt is None: ctxt__o = None
4002: else: ctxt__o = ctxt._o
4003: if elem is None: elem__o = None
4004: else: elem__o = elem._o
4005: ret = libxml2mod.xmlValidatePopElement(ctxt__o, self._o, elem__o, qname)
4006: return ret
4007:
4008: def validatePushElement(self, ctxt, elem, qname):
4009: """Push a new element start on the validation stack. """
4010: if ctxt is None: ctxt__o = None
4011: else: ctxt__o = ctxt._o
4012: if elem is None: elem__o = None
4013: else: elem__o = elem._o
4014: ret = libxml2mod.xmlValidatePushElement(ctxt__o, self._o, elem__o, qname)
4015: return ret
4016:
4017: def validateRoot(self, ctxt):
4018: """Try to validate a the root element basically it does the
4019: following check as described by the XML-1.0 recommendation:
4020: - [ VC: Root Element Type ] it doesn't try to recurse or
4021: apply other check to the element """
4022: if ctxt is None: ctxt__o = None
4023: else: ctxt__o = ctxt._o
4024: ret = libxml2mod.xmlValidateRoot(ctxt__o, self._o)
4025: return ret
4026:
4027: #
4028: # xmlDoc functions from module xinclude
4029: #
4030:
4031: def xincludeProcess(self):
4032: """Implement the XInclude substitution on the XML document @doc """
4033: ret = libxml2mod.xmlXIncludeProcess(self._o)
4034: return ret
4035:
4036: def xincludeProcessFlags(self, flags):
4037: """Implement the XInclude substitution on the XML document @doc """
4038: ret = libxml2mod.xmlXIncludeProcessFlags(self._o, flags)
4039: return ret
4040:
4041: #
4042: # xmlDoc functions from module xmlreader
4043: #
4044:
4045: def NewWalker(self, reader):
4046: """Setup an xmltextReader to parse a preparsed XML document.
4047: This reuses the existing @reader xmlTextReader. """
4048: if reader is None: reader__o = None
4049: else: reader__o = reader._o
4050: ret = libxml2mod.xmlReaderNewWalker(reader__o, self._o)
4051: return ret
4052:
4053: def readerWalker(self):
4054: """Create an xmltextReader for a preparsed document. """
4055: ret = libxml2mod.xmlReaderWalker(self._o)
4056: if ret is None:raise treeError('xmlReaderWalker() failed')
4057: __tmp = xmlTextReader(_obj=ret)
4058: return __tmp
4059:
4060: #
4061: # xmlDoc functions from module xmlschemas
4062: #
4063:
4064: def schemaNewDocParserCtxt(self):
4065: """Create an XML Schemas parse context for that document. NB.
4066: The document may be modified during the parsing process. """
4067: ret = libxml2mod.xmlSchemaNewDocParserCtxt(self._o)
4068: if ret is None:raise parserError('xmlSchemaNewDocParserCtxt() failed')
4069: __tmp = SchemaParserCtxt(_obj=ret)
4070: return __tmp
4071:
4072: def schemaValidateDoc(self, ctxt):
4073: """Validate a document tree in memory. """
4074: if ctxt is None: ctxt__o = None
4075: else: ctxt__o = ctxt._o
4076: ret = libxml2mod.xmlSchemaValidateDoc(ctxt__o, self._o)
4077: return ret
4078:
4079: #
4080: # xmlDoc functions from module xpath
4081: #
4082:
4083: def xpathNewContext(self):
4084: """Create a new xmlXPathContext """
4085: ret = libxml2mod.xmlXPathNewContext(self._o)
4086: if ret is None:raise xpathError('xmlXPathNewContext() failed')
4087: __tmp = xpathContext(_obj=ret)
4088: return __tmp
4089:
4090: def xpathOrderDocElems(self):
4091: """Call this routine to speed up XPath computation on static
4092: documents. This stamps all the element nodes with the
4093: document order Like for line information, the order is kept
4094: in the element->content field, the value stored is actually
4095: - the node number (starting at -1) to be able to
4096: differentiate from line numbers. """
4097: ret = libxml2mod.xmlXPathOrderDocElems(self._o)
4098: return ret
4099:
4100: #
4101: # xmlDoc functions from module xpointer
4102: #
4103:
4104: def xpointerNewContext(self, here, origin):
4105: """Create a new XPointer context """
4106: if here is None: here__o = None
4107: else: here__o = here._o
4108: if origin is None: origin__o = None
4109: else: origin__o = origin._o
4110: ret = libxml2mod.xmlXPtrNewContext(self._o, here__o, origin__o)
4111: if ret is None:raise treeError('xmlXPtrNewContext() failed')
4112: __tmp = xpathContext(_obj=ret)
4113: return __tmp
4114:
4115: class parserCtxt(parserCtxtCore):
4116: def __init__(self, _obj=None):
4117: self._o = _obj
4118: parserCtxtCore.__init__(self, _obj=_obj)
4119:
4120: def __del__(self):
4121: if self._o != None:
4122: libxml2mod.xmlFreeParserCtxt(self._o)
4123: self._o = None
4124:
4125: # accessors for parserCtxt
4126: def doc(self):
4127: """Get the document tree from a parser context. """
4128: ret = libxml2mod.xmlParserGetDoc(self._o)
4129: if ret is None:raise parserError('xmlParserGetDoc() failed')
4130: __tmp = xmlDoc(_obj=ret)
4131: return __tmp
4132:
4133: def isValid(self):
4134: """Get the validity information from a parser context. """
4135: ret = libxml2mod.xmlParserGetIsValid(self._o)
4136: return ret
4137:
4138: def lineNumbers(self, linenumbers):
4139: """Switch on the generation of line number for elements nodes. """
4140: libxml2mod.xmlParserSetLineNumbers(self._o, linenumbers)
4141:
4142: def loadSubset(self, loadsubset):
4143: """Switch the parser to load the DTD without validating. """
4144: libxml2mod.xmlParserSetLoadSubset(self._o, loadsubset)
4145:
4146: def pedantic(self, pedantic):
4147: """Switch the parser to be pedantic. """
4148: libxml2mod.xmlParserSetPedantic(self._o, pedantic)
4149:
4150: def replaceEntities(self, replaceEntities):
4151: """Switch the parser to replace entities. """
4152: libxml2mod.xmlParserSetReplaceEntities(self._o, replaceEntities)
4153:
4154: def validate(self, validate):
4155: """Switch the parser to validation mode. """
4156: libxml2mod.xmlParserSetValidate(self._o, validate)
4157:
4158: def wellFormed(self):
4159: """Get the well formed information from a parser context. """
4160: ret = libxml2mod.xmlParserGetWellFormed(self._o)
4161: return ret
4162:
4163: #
4164: # parserCtxt functions from module HTMLparser
4165: #
4166:
4167: def htmlCtxtReadDoc(self, cur, URL, encoding, options):
4168: """parse an XML in-memory document and build a tree. This
4169: reuses the existing @ctxt parser context """
4170: ret = libxml2mod.htmlCtxtReadDoc(self._o, cur, URL, encoding, options)
4171: if ret is None:raise treeError('htmlCtxtReadDoc() failed')
4172: __tmp = xmlDoc(_obj=ret)
4173: return __tmp
4174:
4175: def htmlCtxtReadFd(self, fd, URL, encoding, options):
4176: """parse an XML from a file descriptor and build a tree. This
4177: reuses the existing @ctxt parser context """
4178: ret = libxml2mod.htmlCtxtReadFd(self._o, fd, URL, encoding, options)
4179: if ret is None:raise treeError('htmlCtxtReadFd() failed')
4180: __tmp = xmlDoc(_obj=ret)
4181: return __tmp
4182:
4183: def htmlCtxtReadFile(self, filename, encoding, options):
4184: """parse an XML file from the filesystem or the network. This
4185: reuses the existing @ctxt parser context """
4186: ret = libxml2mod.htmlCtxtReadFile(self._o, filename, encoding, options)
4187: if ret is None:raise treeError('htmlCtxtReadFile() failed')
4188: __tmp = xmlDoc(_obj=ret)
4189: return __tmp
4190:
4191: def htmlCtxtReadMemory(self, buffer, size, URL, encoding, options):
4192: """parse an XML in-memory document and build a tree. This
4193: reuses the existing @ctxt parser context """
4194: ret = libxml2mod.htmlCtxtReadMemory(self._o, buffer, size, URL, encoding, options)
4195: if ret is None:raise treeError('htmlCtxtReadMemory() failed')
4196: __tmp = xmlDoc(_obj=ret)
4197: return __tmp
4198:
4199: def htmlCtxtReset(self):
4200: """Reset a parser context """
4201: libxml2mod.htmlCtxtReset(self._o)
4202:
4203: def htmlCtxtUseOptions(self, options):
4204: """Applies the options to the parser context """
4205: ret = libxml2mod.htmlCtxtUseOptions(self._o, options)
4206: return ret
4207:
4208: def htmlFreeParserCtxt(self):
4209: """Free all the memory used by a parser context. However the
4210: parsed document in ctxt->myDoc is not freed. """
4211: libxml2mod.htmlFreeParserCtxt(self._o)
4212:
4213: def htmlParseCharRef(self):
4214: """parse Reference declarations [66] CharRef ::= '&#' [0-9]+
4215: ';' | '&#x' [0-9a-fA-F]+ ';' """
4216: ret = libxml2mod.htmlParseCharRef(self._o)
4217: return ret
4218:
4219: def htmlParseChunk(self, chunk, size, terminate):
4220: """Parse a Chunk of memory """
4221: ret = libxml2mod.htmlParseChunk(self._o, chunk, size, terminate)
4222: return ret
4223:
4224: def htmlParseDocument(self):
4225: """parse an HTML document (and build a tree if using the
4226: standard SAX interface). """
4227: ret = libxml2mod.htmlParseDocument(self._o)
4228: return ret
4229:
4230: def htmlParseElement(self):
4231: """parse an HTML element, this is highly recursive this is
4232: kept for compatibility with previous code versions [39]
4233: element ::= EmptyElemTag | STag content ETag [41]
4234: Attribute ::= Name Eq AttValue """
4235: libxml2mod.htmlParseElement(self._o)
4236:
4237: #
4238: # parserCtxt functions from module parser
4239: #
4240:
4241: def byteConsumed(self):
4242: """This function provides the current index of the parser
4243: relative to the start of the current entity. This function
4244: is computed in bytes from the beginning starting at zero
4245: and finishing at the size in byte of the file if parsing a
4246: file. The function is of constant cost if the input is
4247: UTF-8 but can be costly if run on non-UTF-8 input. """
4248: ret = libxml2mod.xmlByteConsumed(self._o)
4249: return ret
4250:
4251: def clearParserCtxt(self):
4252: """Clear (release owned resources) and reinitialize a parser
4253: context """
4254: libxml2mod.xmlClearParserCtxt(self._o)
4255:
4256: def ctxtReadDoc(self, cur, URL, encoding, options):
4257: """parse an XML in-memory document and build a tree. This
4258: reuses the existing @ctxt parser context """
4259: ret = libxml2mod.xmlCtxtReadDoc(self._o, cur, URL, encoding, options)
4260: if ret is None:raise treeError('xmlCtxtReadDoc() failed')
4261: __tmp = xmlDoc(_obj=ret)
4262: return __tmp
4263:
4264: def ctxtReadFd(self, fd, URL, encoding, options):
4265: """parse an XML from a file descriptor and build a tree. This
4266: reuses the existing @ctxt parser context NOTE that the file
4267: descriptor will not be closed when the reader is closed or
4268: reset. """
4269: ret = libxml2mod.xmlCtxtReadFd(self._o, fd, URL, encoding, options)
4270: if ret is None:raise treeError('xmlCtxtReadFd() failed')
4271: __tmp = xmlDoc(_obj=ret)
4272: return __tmp
4273:
4274: def ctxtReadFile(self, filename, encoding, options):
4275: """parse an XML file from the filesystem or the network. This
4276: reuses the existing @ctxt parser context """
4277: ret = libxml2mod.xmlCtxtReadFile(self._o, filename, encoding, options)
4278: if ret is None:raise treeError('xmlCtxtReadFile() failed')
4279: __tmp = xmlDoc(_obj=ret)
4280: return __tmp
4281:
4282: def ctxtReadMemory(self, buffer, size, URL, encoding, options):
4283: """parse an XML in-memory document and build a tree. This
4284: reuses the existing @ctxt parser context """
4285: ret = libxml2mod.xmlCtxtReadMemory(self._o, buffer, size, URL, encoding, options)
4286: if ret is None:raise treeError('xmlCtxtReadMemory() failed')
4287: __tmp = xmlDoc(_obj=ret)
4288: return __tmp
4289:
4290: def ctxtReset(self):
4291: """Reset a parser context """
4292: libxml2mod.xmlCtxtReset(self._o)
4293:
4294: def ctxtResetPush(self, chunk, size, filename, encoding):
4295: """Reset a push parser context """
4296: ret = libxml2mod.xmlCtxtResetPush(self._o, chunk, size, filename, encoding)
4297: return ret
4298:
4299: def ctxtUseOptions(self, options):
4300: """Applies the options to the parser context """
4301: ret = libxml2mod.xmlCtxtUseOptions(self._o, options)
4302: return ret
4303:
4304: def initParserCtxt(self):
4305: """Initialize a parser context """
4306: ret = libxml2mod.xmlInitParserCtxt(self._o)
4307: return ret
4308:
4309: def parseChunk(self, chunk, size, terminate):
4310: """Parse a Chunk of memory """
4311: ret = libxml2mod.xmlParseChunk(self._o, chunk, size, terminate)
4312: return ret
4313:
4314: def parseDocument(self):
4315: """parse an XML document (and build a tree if using the
4316: standard SAX interface). [1] document ::= prolog element
4317: Misc* [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)? """
4318: ret = libxml2mod.xmlParseDocument(self._o)
4319: return ret
4320:
4321: def parseExtParsedEnt(self):
4322: """parse a general parsed entity An external general parsed
4323: entity is well-formed if it matches the production labeled
4324: extParsedEnt. [78] extParsedEnt ::= TextDecl? content """
4325: ret = libxml2mod.xmlParseExtParsedEnt(self._o)
4326: return ret
4327:
4328: def setupParserForBuffer(self, buffer, filename):
4329: """Setup the parser context to parse a new buffer; Clears any
4330: prior contents from the parser context. The buffer
4331: parameter must not be None, but the filename parameter can
4332: be """
4333: libxml2mod.xmlSetupParserForBuffer(self._o, buffer, filename)
4334:
4335: def stopParser(self):
4336: """Blocks further parser processing """
4337: libxml2mod.xmlStopParser(self._o)
4338:
4339: #
4340: # parserCtxt functions from module parserInternals
4341: #
4342:
4343: def decodeEntities(self, len, what, end, end2, end3):
4344: """This function is deprecated, we now always process entities
4345: content through xmlStringDecodeEntities TODO: remove it in
4346: next major release. [67] Reference ::= EntityRef | CharRef
4347: [69] PEReference ::= '%' Name ';' """
4348: ret = libxml2mod.xmlDecodeEntities(self._o, len, what, end, end2, end3)
4349: return ret
4350:
4351: def handleEntity(self, entity):
4352: """Default handling of defined entities, when should we define
4353: a new input stream ? When do we just handle that as a set
4354: of chars ? OBSOLETE: to be removed at some point. """
4355: if entity is None: entity__o = None
4356: else: entity__o = entity._o
4357: libxml2mod.xmlHandleEntity(self._o, entity__o)
4358:
4359: def namespaceParseNCName(self):
4360: """parse an XML namespace name. TODO: this seems not in use
4361: anymore, the namespace handling is done on top of the SAX
4362: interfaces, i.e. not on raw input. [NS 3] NCName ::=
4363: (Letter | '_') (NCNameChar)* [NS 4] NCNameChar ::= Letter
4364: | Digit | '.' | '-' | '_' | CombiningChar | Extender """
4365: ret = libxml2mod.xmlNamespaceParseNCName(self._o)
4366: return ret
4367:
4368: def namespaceParseNSDef(self):
4369: """parse a namespace prefix declaration TODO: this seems not
4370: in use anymore, the namespace handling is done on top of
4371: the SAX interfaces, i.e. not on raw input. [NS 1] NSDef
4372: ::= PrefixDef Eq SystemLiteral [NS 2] PrefixDef ::=
4373: 'xmlns' (':' NCName)? """
4374: ret = libxml2mod.xmlNamespaceParseNSDef(self._o)
4375: return ret
4376:
4377: def nextChar(self):
4378: """Skip to the next char input char. """
4379: libxml2mod.xmlNextChar(self._o)
4380:
4381: def parseAttValue(self):
4382: """parse a value for an attribute Note: the parser won't do
4383: substitution of entities here, this will be handled later
4384: in xmlStringGetNodeList [10] AttValue ::= '"' ([^<&"] |
4385: Reference)* '"' | "'" ([^<&'] | Reference)* "'" 3.3.3
4386: Attribute-Value Normalization: Before the value of an
4387: attribute is passed to the application or checked for
4388: validity, the XML processor must normalize it as follows: -
4389: a character reference is processed by appending the
4390: referenced character to the attribute value - an entity
4391: reference is processed by recursively processing the
4392: replacement text of the entity - a whitespace character
4393: (#x20, #xD, #xA, #x9) is processed by appending #x20 to the
4394: normalized value, except that only a single #x20 is
4395: appended for a "#xD#xA" sequence that is part of an
4396: external parsed entity or the literal entity value of an
4397: internal parsed entity - other characters are processed by
4398: appending them to the normalized value If the declared
4399: value is not CDATA, then the XML processor must further
4400: process the normalized attribute value by discarding any
4401: leading and trailing space (#x20) characters, and by
4402: replacing sequences of space (#x20) characters by a single
4403: space (#x20) character. All attributes for which no
4404: declaration has been read should be treated by a
4405: non-validating parser as if declared CDATA. """
4406: ret = libxml2mod.xmlParseAttValue(self._o)
4407: return ret
4408:
4409: def parseAttributeListDecl(self):
4410: """: parse the Attribute list def for an element [52]
4411: AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>' [53]
4412: AttDef ::= S Name S AttType S DefaultDecl """
4413: libxml2mod.xmlParseAttributeListDecl(self._o)
4414:
4415: def parseCDSect(self):
4416: """Parse escaped pure raw content. [18] CDSect ::= CDStart
4417: CData CDEnd [19] CDStart ::= '<![CDATA[' [20] Data ::=
4418: (Char* - (Char* ']]>' Char*)) [21] CDEnd ::= ']]>' """
4419: libxml2mod.xmlParseCDSect(self._o)
4420:
4421: def parseCharData(self, cdata):
4422: """parse a CharData section. if we are within a CDATA section
4423: ']]>' marks an end of section. The right angle bracket (>)
4424: may be represented using the string ">", and must, for
4425: compatibility, be escaped using ">" or a character
4426: reference when it appears in the string "]]>" in content,
4427: when that string is not marking the end of a CDATA section.
4428: [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) """
4429: libxml2mod.xmlParseCharData(self._o, cdata)
4430:
4431: def parseCharRef(self):
4432: """parse Reference declarations [66] CharRef ::= '&#' [0-9]+
4433: ';' | '&#x' [0-9a-fA-F]+ ';' [ WFC: Legal Character ]
4434: Characters referred to using character references must
4435: match the production for Char. """
4436: ret = libxml2mod.xmlParseCharRef(self._o)
4437: return ret
4438:
4439: def parseComment(self):
4440: """Skip an XML (SGML) comment <!-- .... --> The spec says that
4441: "For compatibility, the string "--" (double-hyphen) must
4442: not occur within comments. " [15] Comment ::= '<!--'
4443: ((Char - '-') | ('-' (Char - '-')))* '-->' """
4444: libxml2mod.xmlParseComment(self._o)
4445:
4446: def parseContent(self):
4447: """Parse a content: [43] content ::= (element | CharData |
4448: Reference | CDSect | PI | Comment)* """
4449: libxml2mod.xmlParseContent(self._o)
4450:
4451: def parseDocTypeDecl(self):
4452: """parse a DOCTYPE declaration [28] doctypedecl ::=
4453: '<!DOCTYPE' S Name (S ExternalID)? S? ('[' (markupdecl |
4454: PEReference | S)* ']' S?)? '>' [ VC: Root Element Type ]
4455: The Name in the document type declaration must match the
4456: element type of the root element. """
4457: libxml2mod.xmlParseDocTypeDecl(self._o)
4458:
4459: def parseElement(self):
4460: """parse an XML element, this is highly recursive [39]
4461: element ::= EmptyElemTag | STag content ETag [ WFC:
4462: Element Type Match ] The Name in an element's end-tag must
4463: match the element type in the start-tag. """
4464: libxml2mod.xmlParseElement(self._o)
4465:
4466: def parseElementDecl(self):
4467: """parse an Element declaration. [45] elementdecl ::=
4468: '<!ELEMENT' S Name S contentspec S? '>' [ VC: Unique
4469: Element Type Declaration ] No element type may be declared
4470: more than once """
4471: ret = libxml2mod.xmlParseElementDecl(self._o)
4472: return ret
4473:
4474: def parseEncName(self):
4475: """parse the XML encoding name [81] EncName ::= [A-Za-z]
4476: ([A-Za-z0-9._] | '-')* """
4477: ret = libxml2mod.xmlParseEncName(self._o)
4478: return ret
4479:
4480: def parseEncodingDecl(self):
4481: """parse the XML encoding declaration [80] EncodingDecl ::= S
4482: 'encoding' Eq ('"' EncName '"' | "'" EncName "'") this
4483: setups the conversion filters. """
4484: ret = libxml2mod.xmlParseEncodingDecl(self._o)
4485: return ret
4486:
4487: def parseEndTag(self):
4488: """parse an end of tag [42] ETag ::= '</' Name S? '>' With
4489: namespace [NS 9] ETag ::= '</' QName S? '>' """
4490: libxml2mod.xmlParseEndTag(self._o)
4491:
4492: def parseEntityDecl(self):
4493: """parse <!ENTITY declarations [70] EntityDecl ::= GEDecl |
4494: PEDecl [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S?
4495: '>' [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
4496: [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)
4497: [74] PEDef ::= EntityValue | ExternalID [76] NDataDecl ::=
4498: S 'NDATA' S Name [ VC: Notation Declared ] The Name must
4499: match the declared name of a notation. """
4500: libxml2mod.xmlParseEntityDecl(self._o)
4501:
4502: def parseEntityRef(self):
4503: """parse ENTITY references declarations [68] EntityRef ::=
4504: '&' Name ';' [ WFC: Entity Declared ] In a document
4505: without any DTD, a document with only an internal DTD
4506: subset which contains no parameter entity references, or a
4507: document with "standalone='yes'", the Name given in the
4508: entity reference must match that in an entity declaration,
4509: except that well-formed documents need not declare any of
4510: the following entities: amp, lt, gt, apos, quot. The
4511: declaration of a parameter entity must precede any
4512: reference to it. Similarly, the declaration of a general
4513: entity must precede any reference to it which appears in a
4514: default value in an attribute-list declaration. Note that
4515: if entities are declared in the external subset or in
4516: external parameter entities, a non-validating processor is
4517: not obligated to read and process their declarations; for
4518: such documents, the rule that an entity must be declared is
4519: a well-formedness constraint only if standalone='yes'. [
4520: WFC: Parsed Entity ] An entity reference must not contain
4521: the name of an unparsed entity """
4522: ret = libxml2mod.xmlParseEntityRef(self._o)
4523: if ret is None:raise parserError('xmlParseEntityRef() failed')
4524: __tmp = xmlEntity(_obj=ret)
4525: return __tmp
4526:
4527: def parseExternalSubset(self, ExternalID, SystemID):
4528: """parse Markup declarations from an external subset [30]
4529: extSubset ::= textDecl? extSubsetDecl [31] extSubsetDecl
4530: ::= (markupdecl | conditionalSect | PEReference | S) * """
4531: libxml2mod.xmlParseExternalSubset(self._o, ExternalID, SystemID)
4532:
4533: def parseMarkupDecl(self):
4534: """parse Markup declarations [29] markupdecl ::= elementdecl
4535: | AttlistDecl | EntityDecl | NotationDecl | PI | Comment [
4536: VC: Proper Declaration/PE Nesting ] Parameter-entity
4537: replacement text must be properly nested with markup
4538: declarations. That is to say, if either the first character
4539: or the last character of a markup declaration (markupdecl
4540: above) is contained in the replacement text for a
4541: parameter-entity reference, both must be contained in the
4542: same replacement text. [ WFC: PEs in Internal Subset ] In
4543: the internal DTD subset, parameter-entity references can
4544: occur only where markup declarations can occur, not within
4545: markup declarations. (This does not apply to references
4546: that occur in external parameter entities or to the
4547: external subset.) """
4548: libxml2mod.xmlParseMarkupDecl(self._o)
4549:
4550: def parseMisc(self):
4551: """parse an XML Misc* optional field. [27] Misc ::= Comment |
4552: PI | S """
4553: libxml2mod.xmlParseMisc(self._o)
4554:
4555: def parseName(self):
4556: """parse an XML name. [4] NameChar ::= Letter | Digit | '.' |
4557: '-' | '_' | ':' | CombiningChar | Extender [5] Name ::=
4558: (Letter | '_' | ':') (NameChar)* [6] Names ::= Name (#x20
4559: Name)* """
4560: ret = libxml2mod.xmlParseName(self._o)
4561: return ret
4562:
4563: def parseNamespace(self):
4564: """xmlParseNamespace: parse specific PI '<?namespace ...'
4565: constructs. This is what the older xml-name Working Draft
4566: specified, a bunch of other stuff may still rely on it, so
4567: support is still here as if it was declared on the root of
4568: the Tree:-( TODO: remove from library To be removed at
4569: next drop of binary compatibility """
4570: libxml2mod.xmlParseNamespace(self._o)
4571:
4572: def parseNmtoken(self):
4573: """parse an XML Nmtoken. [7] Nmtoken ::= (NameChar)+ [8]
4574: Nmtokens ::= Nmtoken (#x20 Nmtoken)* """
4575: ret = libxml2mod.xmlParseNmtoken(self._o)
4576: return ret
4577:
4578: def parseNotationDecl(self):
4579: """parse a notation declaration [82] NotationDecl ::=
4580: '<!NOTATION' S Name S (ExternalID | PublicID) S? '>'
4581: Hence there is actually 3 choices: 'PUBLIC' S PubidLiteral
4582: 'PUBLIC' S PubidLiteral S SystemLiteral and 'SYSTEM' S
4583: SystemLiteral See the NOTE on xmlParseExternalID(). """
4584: libxml2mod.xmlParseNotationDecl(self._o)
4585:
4586: def parsePEReference(self):
4587: """parse PEReference declarations The entity content is
4588: handled directly by pushing it's content as a new input
4589: stream. [69] PEReference ::= '%' Name ';' [ WFC: No
4590: Recursion ] A parsed entity must not contain a recursive
4591: reference to itself, either directly or indirectly. [ WFC:
4592: Entity Declared ] In a document without any DTD, a document
4593: with only an internal DTD subset which contains no
4594: parameter entity references, or a document with
4595: "standalone='yes'", ... ... The declaration of a parameter
4596: entity must precede any reference to it... [ VC: Entity
4597: Declared ] In a document with an external subset or
4598: external parameter entities with "standalone='no'", ...
4599: ... The declaration of a parameter entity must precede any
4600: reference to it... [ WFC: In DTD ] Parameter-entity
4601: references may only appear in the DTD. NOTE: misleading but
4602: this is handled. """
4603: libxml2mod.xmlParsePEReference(self._o)
4604:
4605: def parsePI(self):
4606: """parse an XML Processing Instruction. [16] PI ::= '<?'
4607: PITarget (S (Char* - (Char* '?>' Char*)))? '?>' The
4608: processing is transfered to SAX once parsed. """
4609: libxml2mod.xmlParsePI(self._o)
4610:
4611: def parsePITarget(self):
4612: """parse the name of a PI [17] PITarget ::= Name - (('X' |
4613: 'x') ('M' | 'm') ('L' | 'l')) """
4614: ret = libxml2mod.xmlParsePITarget(self._o)
4615: return ret
4616:
4617: def parsePubidLiteral(self):
4618: """parse an XML public literal [12] PubidLiteral ::= '"'
4619: PubidChar* '"' | "'" (PubidChar - "'")* "'" """
4620: ret = libxml2mod.xmlParsePubidLiteral(self._o)
4621: return ret
4622:
4623: def parseQuotedString(self):
4624: """Parse and return a string between quotes or doublequotes
4625: TODO: Deprecated, to be removed at next drop of binary
4626: compatibility """
4627: ret = libxml2mod.xmlParseQuotedString(self._o)
4628: return ret
4629:
4630: def parseReference(self):
4631: """parse and handle entity references in content, depending on
4632: the SAX interface, this may end-up in a call to character()
4633: if this is a CharRef, a predefined entity, if there is no
4634: reference() callback. or if the parser was asked to switch
4635: to that mode. [67] Reference ::= EntityRef | CharRef """
4636: libxml2mod.xmlParseReference(self._o)
4637:
4638: def parseSDDecl(self):
4639: """parse the XML standalone declaration [32] SDDecl ::= S
4640: 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' |
4641: 'no')'"')) [ VC: Standalone Document Declaration ] TODO
4642: The standalone document declaration must have the value
4643: "no" if any external markup declarations contain
4644: declarations of: - attributes with default values, if
4645: elements to which these attributes apply appear in the
4646: document without specifications of values for these
4647: attributes, or - entities (other than amp, lt, gt, apos,
4648: quot), if references to those entities appear in the
4649: document, or - attributes with values subject to
4650: normalization, where the attribute appears in the document
4651: with a value which will change as a result of
4652: normalization, or - element types with element content, if
4653: white space occurs directly within any instance of those
4654: types. """
4655: ret = libxml2mod.xmlParseSDDecl(self._o)
4656: return ret
4657:
4658: def parseStartTag(self):
4659: """parse a start of tag either for rule element or
4660: EmptyElement. In both case we don't parse the tag closing
4661: chars. [40] STag ::= '<' Name (S Attribute)* S? '>' [
4662: WFC: Unique Att Spec ] No attribute name may appear more
4663: than once in the same start-tag or empty-element tag. [44]
4664: EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' [ WFC:
4665: Unique Att Spec ] No attribute name may appear more than
4666: once in the same start-tag or empty-element tag. With
4667: namespace: [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
4668: [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>' """
4669: ret = libxml2mod.xmlParseStartTag(self._o)
4670: return ret
4671:
4672: def parseSystemLiteral(self):
4673: """parse an XML Literal [11] SystemLiteral ::= ('"' [^"]*
4674: '"') | ("'" [^']* "'") """
4675: ret = libxml2mod.xmlParseSystemLiteral(self._o)
4676: return ret
4677:
4678: def parseTextDecl(self):
4679: """parse an XML declaration header for external entities [77]
4680: TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>' """
4681: libxml2mod.xmlParseTextDecl(self._o)
4682:
4683: def parseVersionInfo(self):
4684: """parse the XML version. [24] VersionInfo ::= S 'version' Eq
4685: (' VersionNum ' | " VersionNum ") [25] Eq ::= S? '=' S? """
4686: ret = libxml2mod.xmlParseVersionInfo(self._o)
4687: return ret
4688:
4689: def parseVersionNum(self):
4690: """parse the XML version value. [26] VersionNum ::= '1.'
4691: [0-9]+ In practice allow [0-9].[0-9]+ at that level """
4692: ret = libxml2mod.xmlParseVersionNum(self._o)
4693: return ret
4694:
4695: def parseXMLDecl(self):
4696: """parse an XML declaration header [23] XMLDecl ::= '<?xml'
4697: VersionInfo EncodingDecl? SDDecl? S? '?>' """
4698: libxml2mod.xmlParseXMLDecl(self._o)
4699:
4700: def parserHandlePEReference(self):
4701: """[69] PEReference ::= '%' Name ';' [ WFC: No Recursion ] A
4702: parsed entity must not contain a recursive reference to
4703: itself, either directly or indirectly. [ WFC: Entity
4704: Declared ] In a document without any DTD, a document with
4705: only an internal DTD subset which contains no parameter
4706: entity references, or a document with "standalone='yes'",
4707: ... ... The declaration of a parameter entity must precede
4708: any reference to it... [ VC: Entity Declared ] In a
4709: document with an external subset or external parameter
4710: entities with "standalone='no'", ... ... The declaration
4711: of a parameter entity must precede any reference to it...
4712: [ WFC: In DTD ] Parameter-entity references may only appear
4713: in the DTD. NOTE: misleading but this is handled. A
4714: PEReference may have been detected in the current input
4715: stream the handling is done accordingly to
4716: http://www.w3.org/TR/REC-xml#entproc i.e. - Included in
4717: literal in entity values - Included as Parameter Entity
4718: reference within DTDs """
4719: libxml2mod.xmlParserHandlePEReference(self._o)
4720:
4721: def parserHandleReference(self):
4722: """TODO: Remove, now deprecated ... the test is done directly
4723: in the content parsing routines. [67] Reference ::=
4724: EntityRef | CharRef [68] EntityRef ::= '&' Name ';' [
4725: WFC: Entity Declared ] the Name given in the entity
4726: reference must match that in an entity declaration, except
4727: that well-formed documents need not declare any of the
4728: following entities: amp, lt, gt, apos, quot. [ WFC: Parsed
4729: Entity ] An entity reference must not contain the name of
4730: an unparsed entity [66] CharRef ::= '&#' [0-9]+ ';' |
4731: '&#x' [0-9a-fA-F]+ ';' A PEReference may have been
4732: detected in the current input stream the handling is done
4733: accordingly to http://www.w3.org/TR/REC-xml#entproc """
4734: libxml2mod.xmlParserHandleReference(self._o)
4735:
4736: def popInput(self):
4737: """xmlPopInput: the current input pointed by ctxt->input came
4738: to an end pop it and return the next char. """
4739: ret = libxml2mod.xmlPopInput(self._o)
4740: return ret
4741:
4742: def scanName(self):
4743: """Trickery: parse an XML name but without consuming the input
4744: flow Needed for rollback cases. Used only when parsing
4745: entities references. TODO: seems deprecated now, only used
4746: in the default part of xmlParserHandleReference [4]
4747: NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
4748: CombiningChar | Extender [5] Name ::= (Letter | '_' | ':')
4749: (NameChar)* [6] Names ::= Name (S Name)* """
4750: ret = libxml2mod.xmlScanName(self._o)
4751: return ret
4752:
4753: def skipBlankChars(self):
4754: """skip all blanks character found at that point in the input
4755: streams. It pops up finished entities in the process if
4756: allowable at that point. """
4757: ret = libxml2mod.xmlSkipBlankChars(self._o)
4758: return ret
4759:
4760: def stringDecodeEntities(self, str, what, end, end2, end3):
4761: """Takes a entity string content and process to do the
4762: adequate substitutions. [67] Reference ::= EntityRef |
4763: CharRef [69] PEReference ::= '%' Name ';' """
4764: ret = libxml2mod.xmlStringDecodeEntities(self._o, str, what, end, end2, end3)
4765: return ret
4766:
4767: def stringLenDecodeEntities(self, str, len, what, end, end2, end3):
4768: """Takes a entity string content and process to do the
4769: adequate substitutions. [67] Reference ::= EntityRef |
4770: CharRef [69] PEReference ::= '%' Name ';' """
4771: ret = libxml2mod.xmlStringLenDecodeEntities(self._o, str, len, what, end, end2, end3)
4772: return ret
4773:
4774: class xmlAttr(xmlNode):
4775: def __init__(self, _obj=None):
4776: if checkWrapper(_obj) != 0: raise TypeError('xmlAttr got a wrong wrapper object type')
4777: self._o = _obj
4778: xmlNode.__init__(self, _obj=_obj)
4779:
4780: def __repr__(self):
4781: return "<xmlAttr (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
4782:
4783: #
4784: # xmlAttr functions from module debugXML
4785: #
4786:
4787: def debugDumpAttr(self, output, depth):
4788: """Dumps debug information for the attribute """
4789: libxml2mod.xmlDebugDumpAttr(output, self._o, depth)
4790:
4791: def debugDumpAttrList(self, output, depth):
4792: """Dumps debug information for the attribute list """
4793: libxml2mod.xmlDebugDumpAttrList(output, self._o, depth)
4794:
4795: #
4796: # xmlAttr functions from module tree
4797: #
4798:
4799: def copyProp(self, target):
4800: """Do a copy of the attribute. """
4801: if target is None: target__o = None
4802: else: target__o = target._o
4803: ret = libxml2mod.xmlCopyProp(target__o, self._o)
4804: if ret is None:raise treeError('xmlCopyProp() failed')
4805: __tmp = xmlAttr(_obj=ret)
4806: return __tmp
4807:
4808: def copyPropList(self, target):
4809: """Do a copy of an attribute list. """
4810: if target is None: target__o = None
4811: else: target__o = target._o
4812: ret = libxml2mod.xmlCopyPropList(target__o, self._o)
4813: if ret is None:raise treeError('xmlCopyPropList() failed')
4814: __tmp = xmlAttr(_obj=ret)
4815: return __tmp
4816:
4817: def freeProp(self):
4818: """Free one attribute, all the content is freed too """
4819: libxml2mod.xmlFreeProp(self._o)
4820:
4821: def freePropList(self):
4822: """Free a property and all its siblings, all the children are
4823: freed too. """
4824: libxml2mod.xmlFreePropList(self._o)
4825:
4826: def removeProp(self):
4827: """Unlink and free one attribute, all the content is freed too
4828: Note this doesn't work for namespace definition attributes """
4829: ret = libxml2mod.xmlRemoveProp(self._o)
4830: return ret
4831:
4832: #
4833: # xmlAttr functions from module valid
4834: #
4835:
4836: def removeID(self, doc):
4837: """Remove the given attribute from the ID table maintained
4838: internally. """
4839: if doc is None: doc__o = None
4840: else: doc__o = doc._o
4841: ret = libxml2mod.xmlRemoveID(doc__o, self._o)
4842: return ret
4843:
4844: def removeRef(self, doc):
4845: """Remove the given attribute from the Ref table maintained
4846: internally. """
4847: if doc is None: doc__o = None
4848: else: doc__o = doc._o
4849: ret = libxml2mod.xmlRemoveRef(doc__o, self._o)
4850: return ret
4851:
4852: class xmlAttribute(xmlNode):
4853: def __init__(self, _obj=None):
4854: if checkWrapper(_obj) != 0: raise TypeError('xmlAttribute got a wrong wrapper object type')
4855: self._o = _obj
4856: xmlNode.__init__(self, _obj=_obj)
4857:
4858: def __repr__(self):
4859: return "<xmlAttribute (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
4860:
4861: class catalog:
4862: def __init__(self, _obj=None):
4863: if _obj != None:self._o = _obj;return
4864: self._o = None
4865:
4866: def __del__(self):
4867: if self._o != None:
4868: libxml2mod.xmlFreeCatalog(self._o)
4869: self._o = None
4870:
4871: #
4872: # catalog functions from module catalog
4873: #
4874:
4875: def add(self, type, orig, replace):
4876: """Add an entry in the catalog, it may overwrite existing but
4877: different entries. """
4878: ret = libxml2mod.xmlACatalogAdd(self._o, type, orig, replace)
4879: return ret
4880:
4881: def catalogIsEmpty(self):
4882: """Check is a catalog is empty """
4883: ret = libxml2mod.xmlCatalogIsEmpty(self._o)
4884: return ret
4885:
4886: def convertSGMLCatalog(self):
4887: """Convert all the SGML catalog entries as XML ones """
4888: ret = libxml2mod.xmlConvertSGMLCatalog(self._o)
4889: return ret
4890:
4891: def dump(self, out):
4892: """Dump the given catalog to the given file. """
4893: libxml2mod.xmlACatalogDump(self._o, out)
4894:
4895: def remove(self, value):
4896: """Remove an entry from the catalog """
4897: ret = libxml2mod.xmlACatalogRemove(self._o, value)
4898: return ret
4899:
4900: def resolve(self, pubID, sysID):
4901: """Do a complete resolution lookup of an External Identifier """
4902: ret = libxml2mod.xmlACatalogResolve(self._o, pubID, sysID)
4903: return ret
4904:
4905: def resolvePublic(self, pubID):
4906: """Try to lookup the catalog local reference associated to a
4907: public ID in that catalog """
4908: ret = libxml2mod.xmlACatalogResolvePublic(self._o, pubID)
4909: return ret
4910:
4911: def resolveSystem(self, sysID):
4912: """Try to lookup the catalog resource for a system ID """
4913: ret = libxml2mod.xmlACatalogResolveSystem(self._o, sysID)
4914: return ret
4915:
4916: def resolveURI(self, URI):
4917: """Do a complete resolution lookup of an URI """
4918: ret = libxml2mod.xmlACatalogResolveURI(self._o, URI)
4919: return ret
4920:
4921: class xmlDtd(xmlNode):
4922: def __init__(self, _obj=None):
4923: if checkWrapper(_obj) != 0: raise TypeError('xmlDtd got a wrong wrapper object type')
4924: self._o = _obj
4925: xmlNode.__init__(self, _obj=_obj)
4926:
4927: def __repr__(self):
4928: return "<xmlDtd (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
4929:
4930: #
4931: # xmlDtd functions from module debugXML
4932: #
4933:
4934: def debugDumpDTD(self, output):
4935: """Dumps debug information for the DTD """
4936: libxml2mod.xmlDebugDumpDTD(output, self._o)
4937:
4938: #
4939: # xmlDtd functions from module tree
4940: #
4941:
4942: def copyDtd(self):
4943: """Do a copy of the dtd. """
4944: ret = libxml2mod.xmlCopyDtd(self._o)
4945: if ret is None:raise treeError('xmlCopyDtd() failed')
4946: __tmp = xmlDtd(_obj=ret)
4947: return __tmp
4948:
4949: def freeDtd(self):
4950: """Free a DTD structure. """
4951: libxml2mod.xmlFreeDtd(self._o)
4952:
4953: #
4954: # xmlDtd functions from module valid
4955: #
4956:
4957: def dtdAttrDesc(self, elem, name):
4958: """Search the DTD for the description of this attribute on
4959: this element. """
4960: ret = libxml2mod.xmlGetDtdAttrDesc(self._o, elem, name)
4961: if ret is None:raise treeError('xmlGetDtdAttrDesc() failed')
4962: __tmp = xmlAttribute(_obj=ret)
4963: return __tmp
4964:
4965: def dtdElementDesc(self, name):
4966: """Search the DTD for the description of this element """
4967: ret = libxml2mod.xmlGetDtdElementDesc(self._o, name)
4968: if ret is None:raise treeError('xmlGetDtdElementDesc() failed')
4969: __tmp = xmlElement(_obj=ret)
4970: return __tmp
4971:
4972: def dtdQAttrDesc(self, elem, name, prefix):
4973: """Search the DTD for the description of this qualified
4974: attribute on this element. """
4975: ret = libxml2mod.xmlGetDtdQAttrDesc(self._o, elem, name, prefix)
4976: if ret is None:raise treeError('xmlGetDtdQAttrDesc() failed')
4977: __tmp = xmlAttribute(_obj=ret)
4978: return __tmp
4979:
4980: def dtdQElementDesc(self, name, prefix):
4981: """Search the DTD for the description of this element """
4982: ret = libxml2mod.xmlGetDtdQElementDesc(self._o, name, prefix)
4983: if ret is None:raise treeError('xmlGetDtdQElementDesc() failed')
4984: __tmp = xmlElement(_obj=ret)
4985: return __tmp
4986:
4987: class xmlElement(xmlNode):
4988: def __init__(self, _obj=None):
4989: if checkWrapper(_obj) != 0: raise TypeError('xmlElement got a wrong wrapper object type')
4990: self._o = _obj
4991: xmlNode.__init__(self, _obj=_obj)
4992:
4993: def __repr__(self):
4994: return "<xmlElement (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
4995:
4996: class xmlEntity(xmlNode):
4997: def __init__(self, _obj=None):
4998: if checkWrapper(_obj) != 0: raise TypeError('xmlEntity got a wrong wrapper object type')
4999: self._o = _obj
5000: xmlNode.__init__(self, _obj=_obj)
5001:
5002: def __repr__(self):
5003: return "<xmlEntity (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
5004:
5005: #
5006: # xmlEntity functions from module parserInternals
5007: #
5008:
5009: def handleEntity(self, ctxt):
5010: """Default handling of defined entities, when should we define
5011: a new input stream ? When do we just handle that as a set
5012: of chars ? OBSOLETE: to be removed at some point. """
5013: if ctxt is None: ctxt__o = None
5014: else: ctxt__o = ctxt._o
5015: libxml2mod.xmlHandleEntity(ctxt__o, self._o)
5016:
5017: class Error:
5018: def __init__(self, _obj=None):
5019: if _obj != None:self._o = _obj;return
5020: self._o = None
5021:
5022: # accessors for Error
5023: def code(self):
5024: """The error code, e.g. an xmlParserError """
5025: ret = libxml2mod.xmlErrorGetCode(self._o)
5026: return ret
5027:
5028: def domain(self):
5029: """What part of the library raised this error """
5030: ret = libxml2mod.xmlErrorGetDomain(self._o)
5031: return ret
5032:
5033: def file(self):
5034: """the filename """
5035: ret = libxml2mod.xmlErrorGetFile(self._o)
5036: return ret
5037:
5038: def level(self):
5039: """how consequent is the error """
5040: ret = libxml2mod.xmlErrorGetLevel(self._o)
5041: return ret
5042:
5043: def line(self):
5044: """the line number if available """
5045: ret = libxml2mod.xmlErrorGetLine(self._o)
5046: return ret
5047:
5048: def message(self):
5049: """human-readable informative error message """
5050: ret = libxml2mod.xmlErrorGetMessage(self._o)
5051: return ret
5052:
5053: #
5054: # Error functions from module xmlerror
5055: #
5056:
5057: def copyError(self, to):
5058: """Save the original error to the new place. """
5059: if to is None: to__o = None
5060: else: to__o = to._o
5061: ret = libxml2mod.xmlCopyError(self._o, to__o)
5062: return ret
5063:
5064: def resetError(self):
5065: """Cleanup the error. """
5066: libxml2mod.xmlResetError(self._o)
5067:
5068: class xmlNs(xmlNode):
5069: def __init__(self, _obj=None):
5070: if checkWrapper(_obj) != 0: raise TypeError('xmlNs got a wrong wrapper object type')
5071: self._o = _obj
5072: xmlNode.__init__(self, _obj=_obj)
5073:
5074: def __repr__(self):
5075: return "<xmlNs (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
5076:
5077: #
5078: # xmlNs functions from module tree
5079: #
5080:
5081: def copyNamespace(self):
5082: """Do a copy of the namespace. """
5083: ret = libxml2mod.xmlCopyNamespace(self._o)
5084: if ret is None:raise treeError('xmlCopyNamespace() failed')
5085: __tmp = xmlNs(_obj=ret)
5086: return __tmp
5087:
5088: def copyNamespaceList(self):
5089: """Do a copy of an namespace list. """
5090: ret = libxml2mod.xmlCopyNamespaceList(self._o)
5091: if ret is None:raise treeError('xmlCopyNamespaceList() failed')
5092: __tmp = xmlNs(_obj=ret)
5093: return __tmp
5094:
5095: def freeNs(self):
5096: """Free up the structures associated to a namespace """
5097: libxml2mod.xmlFreeNs(self._o)
5098:
5099: def freeNsList(self):
5100: """Free up all the structures associated to the chained
5101: namespaces. """
5102: libxml2mod.xmlFreeNsList(self._o)
5103:
5104: def newChild(self, parent, name, content):
5105: """Creation of a new child element, added at the end of
5106: @parent children list. @ns and @content parameters are
5107: optional (None). If @ns is None, the newly created element
5108: inherits the namespace of @parent. If @content is non None,
5109: a child list containing the TEXTs and ENTITY_REFs node will
5110: be created. NOTE: @content is supposed to be a piece of XML
5111: CDATA, so it allows entity references. XML special chars
5112: must be escaped first by using
5113: xmlEncodeEntitiesReentrant(), or xmlNewTextChild() should
5114: be used. """
5115: if parent is None: parent__o = None
5116: else: parent__o = parent._o
5117: ret = libxml2mod.xmlNewChild(parent__o, self._o, name, content)
5118: if ret is None:raise treeError('xmlNewChild() failed')
5119: __tmp = xmlNode(_obj=ret)
5120: return __tmp
5121:
5122: def newDocNode(self, doc, name, content):
5123: """Creation of a new node element within a document. @ns and
5124: @content are optional (None). NOTE: @content is supposed to
5125: be a piece of XML CDATA, so it allow entities references,
5126: but XML special chars need to be escaped first by using
5127: xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you
5128: don't need entities support. """
5129: if doc is None: doc__o = None
5130: else: doc__o = doc._o
5131: ret = libxml2mod.xmlNewDocNode(doc__o, self._o, name, content)
5132: if ret is None:raise treeError('xmlNewDocNode() failed')
5133: __tmp = xmlNode(_obj=ret)
5134: return __tmp
5135:
5136: def newDocNodeEatName(self, doc, name, content):
5137: """Creation of a new node element within a document. @ns and
5138: @content are optional (None). NOTE: @content is supposed to
5139: be a piece of XML CDATA, so it allow entities references,
5140: but XML special chars need to be escaped first by using
5141: xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you
5142: don't need entities support. """
5143: if doc is None: doc__o = None
5144: else: doc__o = doc._o
5145: ret = libxml2mod.xmlNewDocNodeEatName(doc__o, self._o, name, content)
5146: if ret is None:raise treeError('xmlNewDocNodeEatName() failed')
5147: __tmp = xmlNode(_obj=ret)
5148: return __tmp
5149:
5150: def newDocRawNode(self, doc, name, content):
5151: """Creation of a new node element within a document. @ns and
5152: @content are optional (None). """
5153: if doc is None: doc__o = None
5154: else: doc__o = doc._o
5155: ret = libxml2mod.xmlNewDocRawNode(doc__o, self._o, name, content)
5156: if ret is None:raise treeError('xmlNewDocRawNode() failed')
5157: __tmp = xmlNode(_obj=ret)
5158: return __tmp
5159:
5160: def newNodeEatName(self, name):
5161: """Creation of a new node element. @ns is optional (None). """
5162: ret = libxml2mod.xmlNewNodeEatName(self._o, name)
5163: if ret is None:raise treeError('xmlNewNodeEatName() failed')
5164: __tmp = xmlNode(_obj=ret)
5165: return __tmp
5166:
5167: def newNsProp(self, node, name, value):
5168: """Create a new property tagged with a namespace and carried
5169: by a node. """
5170: if node is None: node__o = None
5171: else: node__o = node._o
5172: ret = libxml2mod.xmlNewNsProp(node__o, self._o, name, value)
5173: if ret is None:raise treeError('xmlNewNsProp() failed')
5174: __tmp = xmlAttr(_obj=ret)
5175: return __tmp
5176:
5177: def newNsPropEatName(self, node, name, value):
5178: """Create a new property tagged with a namespace and carried
5179: by a node. """
5180: if node is None: node__o = None
5181: else: node__o = node._o
5182: ret = libxml2mod.xmlNewNsPropEatName(node__o, self._o, name, value)
5183: if ret is None:raise treeError('xmlNewNsPropEatName() failed')
5184: __tmp = xmlAttr(_obj=ret)
5185: return __tmp
5186:
5187: def newTextChild(self, parent, name, content):
5188: """Creation of a new child element, added at the end of
5189: @parent children list. @ns and @content parameters are
5190: optional (None). If @ns is None, the newly created element
5191: inherits the namespace of @parent. If @content is non None,
5192: a child TEXT node will be created containing the string
5193: @content. NOTE: Use xmlNewChild() if @content will contain
5194: entities that need to be preserved. Use this function,
5195: xmlNewTextChild(), if you need to ensure that reserved XML
5196: chars that might appear in @content, such as the ampersand,
5197: greater-than or less-than signs, are automatically replaced
5198: by their XML escaped entity representations. """
5199: if parent is None: parent__o = None
5200: else: parent__o = parent._o
5201: ret = libxml2mod.xmlNewTextChild(parent__o, self._o, name, content)
5202: if ret is None:raise treeError('xmlNewTextChild() failed')
5203: __tmp = xmlNode(_obj=ret)
5204: return __tmp
5205:
5206: def setNs(self, node):
5207: """Associate a namespace to a node, a posteriori. """
5208: if node is None: node__o = None
5209: else: node__o = node._o
5210: libxml2mod.xmlSetNs(node__o, self._o)
5211:
5212: def setNsProp(self, node, name, value):
5213: """Set (or reset) an attribute carried by a node. The ns
5214: structure must be in scope, this is not checked """
5215: if node is None: node__o = None
5216: else: node__o = node._o
5217: ret = libxml2mod.xmlSetNsProp(node__o, self._o, name, value)
5218: if ret is None:raise treeError('xmlSetNsProp() failed')
5219: __tmp = xmlAttr(_obj=ret)
5220: return __tmp
5221:
5222: def unsetNsProp(self, node, name):
5223: """Remove an attribute carried by a node. """
5224: if node is None: node__o = None
5225: else: node__o = node._o
5226: ret = libxml2mod.xmlUnsetNsProp(node__o, self._o, name)
5227: return ret
5228:
5229: #
5230: # xmlNs functions from module xpathInternals
5231: #
5232:
5233: def xpathNodeSetFreeNs(self):
5234: """Namespace nodes in libxml don't match the XPath semantic.
5235: In a node set the namespace nodes are duplicated and the
5236: next pointer is set to the parent node in the XPath
5237: semantic. Check if such a node needs to be freed """
5238: libxml2mod.xmlXPathNodeSetFreeNs(self._o)
5239:
5240: class outputBuffer(ioWriteWrapper):
5241: def __init__(self, _obj=None):
5242: self._o = _obj
5243: ioWriteWrapper.__init__(self, _obj=_obj)
5244:
5245: #
5246: # outputBuffer functions from module HTMLtree
5247: #
5248:
5249: def htmlDocContentDumpFormatOutput(self, cur, encoding, format):
5250: """Dump an HTML document. """
5251: if cur is None: cur__o = None
5252: else: cur__o = cur._o
5253: libxml2mod.htmlDocContentDumpFormatOutput(self._o, cur__o, encoding, format)
5254:
5255: def htmlDocContentDumpOutput(self, cur, encoding):
5256: """Dump an HTML document. Formating return/spaces are added. """
5257: if cur is None: cur__o = None
5258: else: cur__o = cur._o
5259: libxml2mod.htmlDocContentDumpOutput(self._o, cur__o, encoding)
5260:
5261: def htmlNodeDumpFormatOutput(self, doc, cur, encoding, format):
5262: """Dump an HTML node, recursive behaviour,children are printed
5263: too. """
5264: if doc is None: doc__o = None
5265: else: doc__o = doc._o
5266: if cur is None: cur__o = None
5267: else: cur__o = cur._o
5268: libxml2mod.htmlNodeDumpFormatOutput(self._o, doc__o, cur__o, encoding, format)
5269:
5270: def htmlNodeDumpOutput(self, doc, cur, encoding):
5271: """Dump an HTML node, recursive behaviour,children are printed
5272: too, and formatting returns/spaces are added. """
5273: if doc is None: doc__o = None
5274: else: doc__o = doc._o
5275: if cur is None: cur__o = None
5276: else: cur__o = cur._o
5277: libxml2mod.htmlNodeDumpOutput(self._o, doc__o, cur__o, encoding)
5278:
5279: #
5280: # outputBuffer functions from module tree
5281: #
5282:
5283: def nodeDumpOutput(self, doc, cur, level, format, encoding):
5284: """Dump an XML node, recursive behaviour, children are printed
5285: too. Note that @format = 1 provide node indenting only if
5286: xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was
5287: called """
5288: if doc is None: doc__o = None
5289: else: doc__o = doc._o
5290: if cur is None: cur__o = None
5291: else: cur__o = cur._o
5292: libxml2mod.xmlNodeDumpOutput(self._o, doc__o, cur__o, level, format, encoding)
5293:
5294: def saveFileTo(self, cur, encoding):
5295: """Dump an XML document to an I/O buffer. Warning ! This call
5296: xmlOutputBufferClose() on buf which is not available after
5297: this call. """
5298: if cur is None: cur__o = None
5299: else: cur__o = cur._o
5300: ret = libxml2mod.xmlSaveFileTo(self._o, cur__o, encoding)
5301: return ret
5302:
5303: def saveFormatFileTo(self, cur, encoding, format):
5304: """Dump an XML document to an I/O buffer. Warning ! This call
5305: xmlOutputBufferClose() on buf which is not available after
5306: this call. """
5307: if cur is None: cur__o = None
5308: else: cur__o = cur._o
5309: ret = libxml2mod.xmlSaveFormatFileTo(self._o, cur__o, encoding, format)
5310: return ret
5311:
5312: #
5313: # outputBuffer functions from module xmlIO
5314: #
5315:
5316: def getContent(self):
5317: """Gives a pointer to the data currently held in the output
5318: buffer """
5319: ret = libxml2mod.xmlOutputBufferGetContent(self._o)
5320: return ret
5321:
5322: def write(self, len, buf):
5323: """Write the content of the array in the output I/O buffer
5324: This routine handle the I18N transcoding from internal
5325: UTF-8 The buffer is lossless, i.e. will store in case of
5326: partial or delayed writes. """
5327: ret = libxml2mod.xmlOutputBufferWrite(self._o, len, buf)
5328: return ret
5329:
5330: def writeString(self, str):
5331: """Write the content of the string in the output I/O buffer
5332: This routine handle the I18N transcoding from internal
5333: UTF-8 The buffer is lossless, i.e. will store in case of
5334: partial or delayed writes. """
5335: ret = libxml2mod.xmlOutputBufferWriteString(self._o, str)
5336: return ret
5337:
5338: class inputBuffer(ioReadWrapper):
5339: def __init__(self, _obj=None):
5340: self._o = _obj
5341: ioReadWrapper.__init__(self, _obj=_obj)
5342:
5343: def __del__(self):
5344: if self._o != None:
5345: libxml2mod.xmlFreeParserInputBuffer(self._o)
5346: self._o = None
5347:
5348: #
5349: # inputBuffer functions from module xmlIO
5350: #
5351:
5352: def grow(self, len):
5353: """Grow up the content of the input buffer, the old data are
5354: preserved This routine handle the I18N transcoding to
5355: internal UTF-8 This routine is used when operating the
5356: parser in normal (pull) mode TODO: one should be able to
5357: remove one extra copy by copying directly onto in->buffer
5358: or in->raw """
5359: ret = libxml2mod.xmlParserInputBufferGrow(self._o, len)
5360: return ret
5361:
5362: def push(self, len, buf):
5363: """Push the content of the arry in the input buffer This
5364: routine handle the I18N transcoding to internal UTF-8 This
5365: is used when operating the parser in progressive (push)
5366: mode. """
5367: ret = libxml2mod.xmlParserInputBufferPush(self._o, len, buf)
5368: return ret
5369:
5370: def read(self, len):
5371: """Refresh the content of the input buffer, the old data are
5372: considered consumed This routine handle the I18N
5373: transcoding to internal UTF-8 """
5374: ret = libxml2mod.xmlParserInputBufferRead(self._o, len)
5375: return ret
5376:
5377: #
5378: # inputBuffer functions from module xmlreader
5379: #
5380:
5381: def Setup(self, reader, URL, encoding, options):
5382: """Setup an XML reader with new options """
5383: if reader is None: reader__o = None
5384: else: reader__o = reader._o
5385: ret = libxml2mod.xmlTextReaderSetup(reader__o, self._o, URL, encoding, options)
5386: return ret
5387:
5388: def newTextReader(self, URI):
5389: """Create an xmlTextReader structure fed with @input """
5390: ret = libxml2mod.xmlNewTextReader(self._o, URI)
5391: if ret is None:raise treeError('xmlNewTextReader() failed')
5392: __tmp = xmlTextReader(_obj=ret)
5393: __tmp.input = self
5394: return __tmp
5395:
5396: class xmlReg:
5397: def __init__(self, _obj=None):
5398: if _obj != None:self._o = _obj;return
5399: self._o = None
5400:
5401: def __del__(self):
5402: if self._o != None:
5403: libxml2mod.xmlRegFreeRegexp(self._o)
5404: self._o = None
5405:
5406: #
5407: # xmlReg functions from module xmlregexp
5408: #
5409:
5410: def regexpExec(self, content):
5411: """Check if the regular expression generates the value """
5412: ret = libxml2mod.xmlRegexpExec(self._o, content)
5413: return ret
5414:
5415: def regexpIsDeterminist(self):
5416: """Check if the regular expression is determinist """
5417: ret = libxml2mod.xmlRegexpIsDeterminist(self._o)
5418: return ret
5419:
5420: def regexpPrint(self, output):
5421: """Print the content of the compiled regular expression """
5422: libxml2mod.xmlRegexpPrint(output, self._o)
5423:
5424: class relaxNgParserCtxt:
5425: def __init__(self, _obj=None):
5426: if _obj != None:self._o = _obj;return
5427: self._o = None
5428:
5429: def __del__(self):
5430: if self._o != None:
5431: libxml2mod.xmlRelaxNGFreeParserCtxt(self._o)
5432: self._o = None
5433:
5434: #
5435: # relaxNgParserCtxt functions from module relaxng
5436: #
5437:
5438: def relaxNGParse(self):
5439: """parse a schema definition resource and build an internal
5440: XML Shema struture which can be used to validate instances. """
5441: ret = libxml2mod.xmlRelaxNGParse(self._o)
5442: if ret is None:raise parserError('xmlRelaxNGParse() failed')
5443: __tmp = relaxNgSchema(_obj=ret)
5444: return __tmp
5445:
5446: def relaxParserSetFlag(self, flags):
5447: """Semi private function used to pass informations to a parser
5448: context which are a combination of xmlRelaxNGParserFlag . """
5449: ret = libxml2mod.xmlRelaxParserSetFlag(self._o, flags)
5450: return ret
5451:
5452: class relaxNgSchema:
5453: def __init__(self, _obj=None):
5454: if _obj != None:self._o = _obj;return
5455: self._o = None
5456:
5457: def __del__(self):
5458: if self._o != None:
5459: libxml2mod.xmlRelaxNGFree(self._o)
5460: self._o = None
5461:
5462: #
5463: # relaxNgSchema functions from module relaxng
5464: #
5465:
5466: def relaxNGDump(self, output):
5467: """Dump a RelaxNG structure back """
5468: libxml2mod.xmlRelaxNGDump(output, self._o)
5469:
5470: def relaxNGDumpTree(self, output):
5471: """Dump the transformed RelaxNG tree. """
5472: libxml2mod.xmlRelaxNGDumpTree(output, self._o)
5473:
5474: def relaxNGNewValidCtxt(self):
5475: """Create an XML RelaxNGs validation context based on the
5476: given schema """
5477: ret = libxml2mod.xmlRelaxNGNewValidCtxt(self._o)
5478: if ret is None:raise treeError('xmlRelaxNGNewValidCtxt() failed')
5479: __tmp = relaxNgValidCtxt(_obj=ret)
5480: __tmp.schema = self
5481: return __tmp
5482:
5483: #
5484: # relaxNgSchema functions from module xmlreader
5485: #
5486:
5487: def RelaxNGSetSchema(self, reader):
5488: """Use RelaxNG to validate the document as it is processed.
5489: Activation is only possible before the first Read(). if
5490: @schema is None, then RelaxNG validation is desactivated. @
5491: The @schema should not be freed until the reader is
5492: deallocated or its use has been deactivated. """
5493: if reader is None: reader__o = None
5494: else: reader__o = reader._o
5495: ret = libxml2mod.xmlTextReaderRelaxNGSetSchema(reader__o, self._o)
5496: return ret
5497:
5498: class relaxNgValidCtxt(relaxNgValidCtxtCore):
5499: def __init__(self, _obj=None):
5500: self.schema = None
5501: self._o = _obj
5502: relaxNgValidCtxtCore.__init__(self, _obj=_obj)
5503:
5504: def __del__(self):
5505: if self._o != None:
5506: libxml2mod.xmlRelaxNGFreeValidCtxt(self._o)
5507: self._o = None
5508:
5509: #
5510: # relaxNgValidCtxt functions from module relaxng
5511: #
5512:
5513: def relaxNGValidateDoc(self, doc):
5514: """Validate a document tree in memory. """
5515: if doc is None: doc__o = None
5516: else: doc__o = doc._o
5517: ret = libxml2mod.xmlRelaxNGValidateDoc(self._o, doc__o)
5518: return ret
5519:
5520: def relaxNGValidateFullElement(self, doc, elem):
5521: """Validate a full subtree when
5522: xmlRelaxNGValidatePushElement() returned 0 and the content
5523: of the node has been expanded. """
5524: if doc is None: doc__o = None
5525: else: doc__o = doc._o
5526: if elem is None: elem__o = None
5527: else: elem__o = elem._o
5528: ret = libxml2mod.xmlRelaxNGValidateFullElement(self._o, doc__o, elem__o)
5529: return ret
5530:
5531: def relaxNGValidatePopElement(self, doc, elem):
5532: """Pop the element end from the RelaxNG validation stack. """
5533: if doc is None: doc__o = None
5534: else: doc__o = doc._o
5535: if elem is None: elem__o = None
5536: else: elem__o = elem._o
5537: ret = libxml2mod.xmlRelaxNGValidatePopElement(self._o, doc__o, elem__o)
5538: return ret
5539:
5540: def relaxNGValidatePushCData(self, data, len):
5541: """check the CData parsed for validation in the current stack """
5542: ret = libxml2mod.xmlRelaxNGValidatePushCData(self._o, data, len)
5543: return ret
5544:
5545: def relaxNGValidatePushElement(self, doc, elem):
5546: """Push a new element start on the RelaxNG validation stack. """
5547: if doc is None: doc__o = None
5548: else: doc__o = doc._o
5549: if elem is None: elem__o = None
5550: else: elem__o = elem._o
5551: ret = libxml2mod.xmlRelaxNGValidatePushElement(self._o, doc__o, elem__o)
5552: return ret
5553:
5554: #
5555: # relaxNgValidCtxt functions from module xmlreader
5556: #
5557:
5558: def RelaxNGValidateCtxt(self, reader, options):
5559: """Use RelaxNG schema context to validate the document as it
5560: is processed. Activation is only possible before the first
5561: Read(). If @ctxt is None, then RelaxNG schema validation is
5562: deactivated. """
5563: if reader is None: reader__o = None
5564: else: reader__o = reader._o
5565: ret = libxml2mod.xmlTextReaderRelaxNGValidateCtxt(reader__o, self._o, options)
5566: return ret
5567:
5568: class SchemaParserCtxt:
5569: def __init__(self, _obj=None):
5570: if _obj != None:self._o = _obj;return
5571: self._o = None
5572:
5573: def __del__(self):
5574: if self._o != None:
5575: libxml2mod.xmlSchemaFreeParserCtxt(self._o)
5576: self._o = None
5577:
5578: #
5579: # SchemaParserCtxt functions from module xmlschemas
5580: #
5581:
5582: def schemaParse(self):
5583: """parse a schema definition resource and build an internal
5584: XML Shema struture which can be used to validate instances. """
5585: ret = libxml2mod.xmlSchemaParse(self._o)
5586: if ret is None:raise parserError('xmlSchemaParse() failed')
5587: __tmp = Schema(_obj=ret)
5588: return __tmp
5589:
5590: class Schema:
5591: def __init__(self, _obj=None):
5592: if _obj != None:self._o = _obj;return
5593: self._o = None
5594:
5595: def __del__(self):
5596: if self._o != None:
5597: libxml2mod.xmlSchemaFree(self._o)
5598: self._o = None
5599:
5600: #
5601: # Schema functions from module xmlreader
5602: #
5603:
5604: def SetSchema(self, reader):
5605: """Use XSD Schema to validate the document as it is processed.
5606: Activation is only possible before the first Read(). if
5607: @schema is None, then Schema validation is desactivated. @
5608: The @schema should not be freed until the reader is
5609: deallocated or its use has been deactivated. """
5610: if reader is None: reader__o = None
5611: else: reader__o = reader._o
5612: ret = libxml2mod.xmlTextReaderSetSchema(reader__o, self._o)
5613: return ret
5614:
5615: #
5616: # Schema functions from module xmlschemas
5617: #
5618:
5619: def schemaDump(self, output):
5620: """Dump a Schema structure. """
5621: libxml2mod.xmlSchemaDump(output, self._o)
5622:
5623: def schemaNewValidCtxt(self):
5624: """Create an XML Schemas validation context based on the given
5625: schema. """
5626: ret = libxml2mod.xmlSchemaNewValidCtxt(self._o)
5627: if ret is None:raise treeError('xmlSchemaNewValidCtxt() failed')
5628: __tmp = SchemaValidCtxt(_obj=ret)
5629: __tmp.schema = self
5630: return __tmp
5631:
5632: class SchemaValidCtxt(SchemaValidCtxtCore):
5633: def __init__(self, _obj=None):
5634: self.schema = None
5635: self._o = _obj
5636: SchemaValidCtxtCore.__init__(self, _obj=_obj)
5637:
5638: def __del__(self):
5639: if self._o != None:
5640: libxml2mod.xmlSchemaFreeValidCtxt(self._o)
5641: self._o = None
5642:
5643: #
5644: # SchemaValidCtxt functions from module xmlreader
5645: #
5646:
5647: def SchemaValidateCtxt(self, reader, options):
5648: """Use W3C XSD schema context to validate the document as it
5649: is processed. Activation is only possible before the first
5650: Read(). If @ctxt is None, then XML Schema validation is
5651: deactivated. """
5652: if reader is None: reader__o = None
5653: else: reader__o = reader._o
5654: ret = libxml2mod.xmlTextReaderSchemaValidateCtxt(reader__o, self._o, options)
5655: return ret
5656:
5657: #
5658: # SchemaValidCtxt functions from module xmlschemas
5659: #
5660:
5661: def schemaIsValid(self):
5662: """Check if any error was detected during validation. """
5663: ret = libxml2mod.xmlSchemaIsValid(self._o)
5664: return ret
5665:
5666: def schemaSetValidOptions(self, options):
5667: """Sets the options to be used during the validation. """
5668: ret = libxml2mod.xmlSchemaSetValidOptions(self._o, options)
5669: return ret
5670:
5671: def schemaValidCtxtGetOptions(self):
5672: """Get the validation context options. """
5673: ret = libxml2mod.xmlSchemaValidCtxtGetOptions(self._o)
5674: return ret
5675:
5676: def schemaValidCtxtGetParserCtxt(self):
5677: """allow access to the parser context of the schema validation
5678: context """
5679: ret = libxml2mod.xmlSchemaValidCtxtGetParserCtxt(self._o)
5680: if ret is None:raise parserError('xmlSchemaValidCtxtGetParserCtxt() failed')
5681: __tmp = parserCtxt(_obj=ret)
5682: return __tmp
5683:
5684: def schemaValidateDoc(self, doc):
5685: """Validate a document tree in memory. """
5686: if doc is None: doc__o = None
5687: else: doc__o = doc._o
5688: ret = libxml2mod.xmlSchemaValidateDoc(self._o, doc__o)
5689: return ret
5690:
5691: def schemaValidateFile(self, filename, options):
5692: """Do a schemas validation of the given resource, it will use
5693: the SAX streamable validation internally. """
5694: ret = libxml2mod.xmlSchemaValidateFile(self._o, filename, options)
5695: return ret
5696:
5697: def schemaValidateOneElement(self, elem):
5698: """Validate a branch of a tree, starting with the given @elem. """
5699: if elem is None: elem__o = None
5700: else: elem__o = elem._o
5701: ret = libxml2mod.xmlSchemaValidateOneElement(self._o, elem__o)
5702: return ret
5703:
5704: def schemaValidateSetFilename(self, filename):
5705: """Workaround to provide file error reporting information when
5706: this is not provided by current APIs """
5707: libxml2mod.xmlSchemaValidateSetFilename(self._o, filename)
5708:
5709: class xmlTextReaderLocator:
5710: def __init__(self, _obj=None):
5711: if _obj != None:self._o = _obj;return
5712: self._o = None
5713:
5714: #
5715: # xmlTextReaderLocator functions from module xmlreader
5716: #
5717:
5718: def BaseURI(self):
5719: """Obtain the base URI for the given locator. """
5720: ret = libxml2mod.xmlTextReaderLocatorBaseURI(self._o)
5721: return ret
5722:
5723: def LineNumber(self):
5724: """Obtain the line number for the given locator. """
5725: ret = libxml2mod.xmlTextReaderLocatorLineNumber(self._o)
5726: return ret
5727:
5728: class xmlTextReader(xmlTextReaderCore):
5729: def __init__(self, _obj=None):
5730: self.input = None
5731: self._o = _obj
5732: xmlTextReaderCore.__init__(self, _obj=_obj)
5733:
5734: def __del__(self):
5735: if self._o != None:
5736: libxml2mod.xmlFreeTextReader(self._o)
5737: self._o = None
5738:
5739: #
5740: # xmlTextReader functions from module xmlreader
5741: #
5742:
5743: def AttributeCount(self):
5744: """Provides the number of attributes of the current node """
5745: ret = libxml2mod.xmlTextReaderAttributeCount(self._o)
5746: return ret
5747:
5748: def BaseUri(self):
5749: """The base URI of the node. """
5750: ret = libxml2mod.xmlTextReaderConstBaseUri(self._o)
5751: return ret
5752:
5753: def ByteConsumed(self):
5754: """This function provides the current index of the parser used
5755: by the reader, relative to the start of the current entity.
5756: This function actually just wraps a call to
5757: xmlBytesConsumed() for the parser context associated with
5758: the reader. See xmlBytesConsumed() for more information. """
5759: ret = libxml2mod.xmlTextReaderByteConsumed(self._o)
5760: return ret
5761:
5762: def Close(self):
5763: """This method releases any resources allocated by the current
5764: instance changes the state to Closed and close any
5765: underlying input. """
5766: ret = libxml2mod.xmlTextReaderClose(self._o)
5767: return ret
5768:
5769: def CurrentDoc(self):
5770: """Hacking interface allowing to get the xmlDocPtr
5771: correponding to the current document being accessed by the
5772: xmlTextReader. NOTE: as a result of this call, the reader
5773: will not destroy the associated XML document and calling
5774: xmlFreeDoc() on the result is needed once the reader
5775: parsing has finished. """
5776: ret = libxml2mod.xmlTextReaderCurrentDoc(self._o)
5777: if ret is None:raise treeError('xmlTextReaderCurrentDoc() failed')
5778: __tmp = xmlDoc(_obj=ret)
5779: return __tmp
5780:
5781: def CurrentNode(self):
5782: """Hacking interface allowing to get the xmlNodePtr
5783: correponding to the current node being accessed by the
5784: xmlTextReader. This is dangerous because the underlying
5785: node may be destroyed on the next Reads. """
5786: ret = libxml2mod.xmlTextReaderCurrentNode(self._o)
5787: if ret is None:raise treeError('xmlTextReaderCurrentNode() failed')
5788: __tmp = xmlNode(_obj=ret)
5789: return __tmp
5790:
5791: def Depth(self):
5792: """The depth of the node in the tree. """
5793: ret = libxml2mod.xmlTextReaderDepth(self._o)
5794: return ret
5795:
5796: def Encoding(self):
5797: """Determine the encoding of the document being read. """
5798: ret = libxml2mod.xmlTextReaderConstEncoding(self._o)
5799: return ret
5800:
5801: def Expand(self):
5802: """Reads the contents of the current node and the full
5803: subtree. It then makes the subtree available until the next
5804: xmlTextReaderRead() call """
5805: ret = libxml2mod.xmlTextReaderExpand(self._o)
5806: if ret is None:raise treeError('xmlTextReaderExpand() failed')
5807: __tmp = xmlNode(_obj=ret)
5808: return __tmp
5809:
5810: def GetAttribute(self, name):
5811: """Provides the value of the attribute with the specified
5812: qualified name. """
5813: ret = libxml2mod.xmlTextReaderGetAttribute(self._o, name)
5814: return ret
5815:
5816: def GetAttributeNo(self, no):
5817: """Provides the value of the attribute with the specified
5818: index relative to the containing element. """
5819: ret = libxml2mod.xmlTextReaderGetAttributeNo(self._o, no)
5820: return ret
5821:
5822: def GetAttributeNs(self, localName, namespaceURI):
5823: """Provides the value of the specified attribute """
5824: ret = libxml2mod.xmlTextReaderGetAttributeNs(self._o, localName, namespaceURI)
5825: return ret
5826:
5827: def GetParserColumnNumber(self):
5828: """Provide the column number of the current parsing point. """
5829: ret = libxml2mod.xmlTextReaderGetParserColumnNumber(self._o)
5830: return ret
5831:
5832: def GetParserLineNumber(self):
5833: """Provide the line number of the current parsing point. """
5834: ret = libxml2mod.xmlTextReaderGetParserLineNumber(self._o)
5835: return ret
5836:
5837: def GetParserProp(self, prop):
5838: """Read the parser internal property. """
5839: ret = libxml2mod.xmlTextReaderGetParserProp(self._o, prop)
5840: return ret
5841:
5842: def GetRemainder(self):
5843: """Method to get the remainder of the buffered XML. this
5844: method stops the parser, set its state to End Of File and
5845: return the input stream with what is left that the parser
5846: did not use. The implementation is not good, the parser
5847: certainly procgressed past what's left in reader->input,
5848: and there is an allocation problem. Best would be to
5849: rewrite it differently. """
5850: ret = libxml2mod.xmlTextReaderGetRemainder(self._o)
5851: if ret is None:raise treeError('xmlTextReaderGetRemainder() failed')
5852: __tmp = inputBuffer(_obj=ret)
5853: return __tmp
5854:
5855: def HasAttributes(self):
5856: """Whether the node has attributes. """
5857: ret = libxml2mod.xmlTextReaderHasAttributes(self._o)
5858: return ret
5859:
5860: def HasValue(self):
5861: """Whether the node can have a text value. """
5862: ret = libxml2mod.xmlTextReaderHasValue(self._o)
5863: return ret
5864:
5865: def IsDefault(self):
5866: """Whether an Attribute node was generated from the default
5867: value defined in the DTD or schema. """
5868: ret = libxml2mod.xmlTextReaderIsDefault(self._o)
5869: return ret
5870:
5871: def IsEmptyElement(self):
5872: """Check if the current node is empty """
5873: ret = libxml2mod.xmlTextReaderIsEmptyElement(self._o)
5874: return ret
5875:
5876: def IsNamespaceDecl(self):
5877: """Determine whether the current node is a namespace
5878: declaration rather than a regular attribute. """
5879: ret = libxml2mod.xmlTextReaderIsNamespaceDecl(self._o)
5880: return ret
5881:
5882: def IsValid(self):
5883: """Retrieve the validity status from the parser context """
5884: ret = libxml2mod.xmlTextReaderIsValid(self._o)
5885: return ret
5886:
5887: def LocalName(self):
5888: """The local name of the node. """
5889: ret = libxml2mod.xmlTextReaderConstLocalName(self._o)
5890: return ret
5891:
5892: def LookupNamespace(self, prefix):
5893: """Resolves a namespace prefix in the scope of the current
5894: element. """
5895: ret = libxml2mod.xmlTextReaderLookupNamespace(self._o, prefix)
5896: return ret
5897:
5898: def MoveToAttribute(self, name):
5899: """Moves the position of the current instance to the attribute
5900: with the specified qualified name. """
5901: ret = libxml2mod.xmlTextReaderMoveToAttribute(self._o, name)
5902: return ret
5903:
5904: def MoveToAttributeNo(self, no):
5905: """Moves the position of the current instance to the attribute
5906: with the specified index relative to the containing element. """
5907: ret = libxml2mod.xmlTextReaderMoveToAttributeNo(self._o, no)
5908: return ret
5909:
5910: def MoveToAttributeNs(self, localName, namespaceURI):
5911: """Moves the position of the current instance to the attribute
5912: with the specified local name and namespace URI. """
5913: ret = libxml2mod.xmlTextReaderMoveToAttributeNs(self._o, localName, namespaceURI)
5914: return ret
5915:
5916: def MoveToElement(self):
5917: """Moves the position of the current instance to the node that
5918: contains the current Attribute node. """
5919: ret = libxml2mod.xmlTextReaderMoveToElement(self._o)
5920: return ret
5921:
5922: def MoveToFirstAttribute(self):
5923: """Moves the position of the current instance to the first
5924: attribute associated with the current node. """
5925: ret = libxml2mod.xmlTextReaderMoveToFirstAttribute(self._o)
5926: return ret
5927:
5928: def MoveToNextAttribute(self):
5929: """Moves the position of the current instance to the next
5930: attribute associated with the current node. """
5931: ret = libxml2mod.xmlTextReaderMoveToNextAttribute(self._o)
5932: return ret
5933:
5934: def Name(self):
5935: """The qualified name of the node, equal to Prefix :LocalName. """
5936: ret = libxml2mod.xmlTextReaderConstName(self._o)
5937: return ret
5938:
5939: def NamespaceUri(self):
5940: """The URI defining the namespace associated with the node. """
5941: ret = libxml2mod.xmlTextReaderConstNamespaceUri(self._o)
5942: return ret
5943:
5944: def NewDoc(self, cur, URL, encoding, options):
5945: """Setup an xmltextReader to parse an XML in-memory document.
5946: The parsing flags @options are a combination of
5947: xmlParserOption. This reuses the existing @reader
5948: xmlTextReader. """
5949: ret = libxml2mod.xmlReaderNewDoc(self._o, cur, URL, encoding, options)
5950: return ret
5951:
5952: def NewFd(self, fd, URL, encoding, options):
5953: """Setup an xmltextReader to parse an XML from a file
5954: descriptor. NOTE that the file descriptor will not be
5955: closed when the reader is closed or reset. The parsing
5956: flags @options are a combination of xmlParserOption. This
5957: reuses the existing @reader xmlTextReader. """
5958: ret = libxml2mod.xmlReaderNewFd(self._o, fd, URL, encoding, options)
5959: return ret
5960:
5961: def NewFile(self, filename, encoding, options):
5962: """parse an XML file from the filesystem or the network. The
5963: parsing flags @options are a combination of
5964: xmlParserOption. This reuses the existing @reader
5965: xmlTextReader. """
5966: ret = libxml2mod.xmlReaderNewFile(self._o, filename, encoding, options)
5967: return ret
5968:
5969: def NewMemory(self, buffer, size, URL, encoding, options):
5970: """Setup an xmltextReader to parse an XML in-memory document.
5971: The parsing flags @options are a combination of
5972: xmlParserOption. This reuses the existing @reader
5973: xmlTextReader. """
5974: ret = libxml2mod.xmlReaderNewMemory(self._o, buffer, size, URL, encoding, options)
5975: return ret
5976:
5977: def NewWalker(self, doc):
5978: """Setup an xmltextReader to parse a preparsed XML document.
5979: This reuses the existing @reader xmlTextReader. """
5980: if doc is None: doc__o = None
5981: else: doc__o = doc._o
5982: ret = libxml2mod.xmlReaderNewWalker(self._o, doc__o)
5983: return ret
5984:
5985: def Next(self):
5986: """Skip to the node following the current one in document
5987: order while avoiding the subtree if any. """
5988: ret = libxml2mod.xmlTextReaderNext(self._o)
5989: return ret
5990:
5991: def NextSibling(self):
5992: """Skip to the node following the current one in document
5993: order while avoiding the subtree if any. Currently
5994: implemented only for Readers built on a document """
5995: ret = libxml2mod.xmlTextReaderNextSibling(self._o)
5996: return ret
5997:
5998: def NodeType(self):
5999: """Get the node type of the current node Reference:
6000: http://www.gnu.org/software/dotgnu/pnetlib-doc/System/Xml/Xm
6001: lNodeType.html """
6002: ret = libxml2mod.xmlTextReaderNodeType(self._o)
6003: return ret
6004:
6005: def Normalization(self):
6006: """The value indicating whether to normalize white space and
6007: attribute values. Since attribute value and end of line
6008: normalizations are a MUST in the XML specification only the
6009: value true is accepted. The broken bahaviour of accepting
6010: out of range character entities like � is of course not
6011: supported either. """
6012: ret = libxml2mod.xmlTextReaderNormalization(self._o)
6013: return ret
6014:
6015: def Prefix(self):
6016: """A shorthand reference to the namespace associated with the
6017: node. """
6018: ret = libxml2mod.xmlTextReaderConstPrefix(self._o)
6019: return ret
6020:
6021: def Preserve(self):
6022: """This tells the XML Reader to preserve the current node. The
6023: caller must also use xmlTextReaderCurrentDoc() to keep an
6024: handle on the resulting document once parsing has finished """
6025: ret = libxml2mod.xmlTextReaderPreserve(self._o)
6026: if ret is None:raise treeError('xmlTextReaderPreserve() failed')
6027: __tmp = xmlNode(_obj=ret)
6028: return __tmp
6029:
6030: def QuoteChar(self):
6031: """The quotation mark character used to enclose the value of
6032: an attribute. """
6033: ret = libxml2mod.xmlTextReaderQuoteChar(self._o)
6034: return ret
6035:
6036: def Read(self):
6037: """Moves the position of the current instance to the next node
6038: in the stream, exposing its properties. """
6039: ret = libxml2mod.xmlTextReaderRead(self._o)
6040: return ret
6041:
6042: def ReadAttributeValue(self):
6043: """Parses an attribute value into one or more Text and
6044: EntityReference nodes. """
6045: ret = libxml2mod.xmlTextReaderReadAttributeValue(self._o)
6046: return ret
6047:
6048: def ReadInnerXml(self):
6049: """Reads the contents of the current node, including child
6050: nodes and markup. """
6051: ret = libxml2mod.xmlTextReaderReadInnerXml(self._o)
6052: return ret
6053:
6054: def ReadOuterXml(self):
6055: """Reads the contents of the current node, including child
6056: nodes and markup. """
6057: ret = libxml2mod.xmlTextReaderReadOuterXml(self._o)
6058: return ret
6059:
6060: def ReadState(self):
6061: """Gets the read state of the reader. """
6062: ret = libxml2mod.xmlTextReaderReadState(self._o)
6063: return ret
6064:
6065: def ReadString(self):
6066: """Reads the contents of an element or a text node as a string. """
6067: ret = libxml2mod.xmlTextReaderReadString(self._o)
6068: return ret
6069:
6070: def RelaxNGSetSchema(self, schema):
6071: """Use RelaxNG to validate the document as it is processed.
6072: Activation is only possible before the first Read(). if
6073: @schema is None, then RelaxNG validation is desactivated. @
6074: The @schema should not be freed until the reader is
6075: deallocated or its use has been deactivated. """
6076: if schema is None: schema__o = None
6077: else: schema__o = schema._o
6078: ret = libxml2mod.xmlTextReaderRelaxNGSetSchema(self._o, schema__o)
6079: return ret
6080:
6081: def RelaxNGValidate(self, rng):
6082: """Use RelaxNG schema to validate the document as it is
6083: processed. Activation is only possible before the first
6084: Read(). If @rng is None, then RelaxNG schema validation is
6085: deactivated. """
6086: ret = libxml2mod.xmlTextReaderRelaxNGValidate(self._o, rng)
6087: return ret
6088:
6089: def RelaxNGValidateCtxt(self, ctxt, options):
6090: """Use RelaxNG schema context to validate the document as it
6091: is processed. Activation is only possible before the first
6092: Read(). If @ctxt is None, then RelaxNG schema validation is
6093: deactivated. """
6094: if ctxt is None: ctxt__o = None
6095: else: ctxt__o = ctxt._o
6096: ret = libxml2mod.xmlTextReaderRelaxNGValidateCtxt(self._o, ctxt__o, options)
6097: return ret
6098:
6099: def SchemaValidate(self, xsd):
6100: """Use W3C XSD schema to validate the document as it is
6101: processed. Activation is only possible before the first
6102: Read(). If @xsd is None, then XML Schema validation is
6103: deactivated. """
6104: ret = libxml2mod.xmlTextReaderSchemaValidate(self._o, xsd)
6105: return ret
6106:
6107: def SchemaValidateCtxt(self, ctxt, options):
6108: """Use W3C XSD schema context to validate the document as it
6109: is processed. Activation is only possible before the first
6110: Read(). If @ctxt is None, then XML Schema validation is
6111: deactivated. """
6112: if ctxt is None: ctxt__o = None
6113: else: ctxt__o = ctxt._o
6114: ret = libxml2mod.xmlTextReaderSchemaValidateCtxt(self._o, ctxt__o, options)
6115: return ret
6116:
6117: def SetParserProp(self, prop, value):
6118: """Change the parser processing behaviour by changing some of
6119: its internal properties. Note that some properties can only
6120: be changed before any read has been done. """
6121: ret = libxml2mod.xmlTextReaderSetParserProp(self._o, prop, value)
6122: return ret
6123:
6124: def SetSchema(self, schema):
6125: """Use XSD Schema to validate the document as it is processed.
6126: Activation is only possible before the first Read(). if
6127: @schema is None, then Schema validation is desactivated. @
6128: The @schema should not be freed until the reader is
6129: deallocated or its use has been deactivated. """
6130: if schema is None: schema__o = None
6131: else: schema__o = schema._o
6132: ret = libxml2mod.xmlTextReaderSetSchema(self._o, schema__o)
6133: return ret
6134:
6135: def Setup(self, input, URL, encoding, options):
6136: """Setup an XML reader with new options """
6137: if input is None: input__o = None
6138: else: input__o = input._o
6139: ret = libxml2mod.xmlTextReaderSetup(self._o, input__o, URL, encoding, options)
6140: return ret
6141:
6142: def Standalone(self):
6143: """Determine the standalone status of the document being read. """
6144: ret = libxml2mod.xmlTextReaderStandalone(self._o)
6145: return ret
6146:
6147: def String(self, str):
6148: """Get an interned string from the reader, allows for example
6149: to speedup string name comparisons """
6150: ret = libxml2mod.xmlTextReaderConstString(self._o, str)
6151: return ret
6152:
6153: def Value(self):
6154: """Provides the text value of the node if present """
6155: ret = libxml2mod.xmlTextReaderConstValue(self._o)
6156: return ret
6157:
6158: def XmlLang(self):
6159: """The xml:lang scope within which the node resides. """
6160: ret = libxml2mod.xmlTextReaderConstXmlLang(self._o)
6161: return ret
6162:
6163: def XmlVersion(self):
6164: """Determine the XML version of the document being read. """
6165: ret = libxml2mod.xmlTextReaderConstXmlVersion(self._o)
6166: return ret
6167:
6168: class URI:
6169: def __init__(self, _obj=None):
6170: if _obj != None:self._o = _obj;return
6171: self._o = None
6172:
6173: def __del__(self):
6174: if self._o != None:
6175: libxml2mod.xmlFreeURI(self._o)
6176: self._o = None
6177:
6178: # accessors for URI
6179: def authority(self):
6180: """Get the authority part from an URI """
6181: ret = libxml2mod.xmlURIGetAuthority(self._o)
6182: return ret
6183:
6184: def fragment(self):
6185: """Get the fragment part from an URI """
6186: ret = libxml2mod.xmlURIGetFragment(self._o)
6187: return ret
6188:
6189: def opaque(self):
6190: """Get the opaque part from an URI """
6191: ret = libxml2mod.xmlURIGetOpaque(self._o)
6192: return ret
6193:
6194: def path(self):
6195: """Get the path part from an URI """
6196: ret = libxml2mod.xmlURIGetPath(self._o)
6197: return ret
6198:
6199: def port(self):
6200: """Get the port part from an URI """
6201: ret = libxml2mod.xmlURIGetPort(self._o)
6202: return ret
6203:
6204: def query(self):
6205: """Get the query part from an URI """
6206: ret = libxml2mod.xmlURIGetQuery(self._o)
6207: return ret
6208:
6209: def queryRaw(self):
6210: """Get the raw query part from an URI (i.e. the unescaped
6211: form). """
6212: ret = libxml2mod.xmlURIGetQueryRaw(self._o)
6213: return ret
6214:
6215: def scheme(self):
6216: """Get the scheme part from an URI """
6217: ret = libxml2mod.xmlURIGetScheme(self._o)
6218: return ret
6219:
6220: def server(self):
6221: """Get the server part from an URI """
6222: ret = libxml2mod.xmlURIGetServer(self._o)
6223: return ret
6224:
6225: def setAuthority(self, authority):
6226: """Set the authority part of an URI. """
6227: libxml2mod.xmlURISetAuthority(self._o, authority)
6228:
6229: def setFragment(self, fragment):
6230: """Set the fragment part of an URI. """
6231: libxml2mod.xmlURISetFragment(self._o, fragment)
6232:
6233: def setOpaque(self, opaque):
6234: """Set the opaque part of an URI. """
6235: libxml2mod.xmlURISetOpaque(self._o, opaque)
6236:
6237: def setPath(self, path):
6238: """Set the path part of an URI. """
6239: libxml2mod.xmlURISetPath(self._o, path)
6240:
6241: def setPort(self, port):
6242: """Set the port part of an URI. """
6243: libxml2mod.xmlURISetPort(self._o, port)
6244:
6245: def setQuery(self, query):
6246: """Set the query part of an URI. """
6247: libxml2mod.xmlURISetQuery(self._o, query)
6248:
6249: def setQueryRaw(self, query_raw):
6250: """Set the raw query part of an URI (i.e. the unescaped form). """
6251: libxml2mod.xmlURISetQueryRaw(self._o, query_raw)
6252:
6253: def setScheme(self, scheme):
6254: """Set the scheme part of an URI. """
6255: libxml2mod.xmlURISetScheme(self._o, scheme)
6256:
6257: def setServer(self, server):
6258: """Set the server part of an URI. """
6259: libxml2mod.xmlURISetServer(self._o, server)
6260:
6261: def setUser(self, user):
6262: """Set the user part of an URI. """
6263: libxml2mod.xmlURISetUser(self._o, user)
6264:
6265: def user(self):
6266: """Get the user part from an URI """
6267: ret = libxml2mod.xmlURIGetUser(self._o)
6268: return ret
6269:
6270: #
6271: # URI functions from module uri
6272: #
6273:
6274: def parseURIReference(self, str):
6275: """Parse an URI reference string based on RFC 3986 and fills
6276: in the appropriate fields of the @uri structure
6277: URI-reference = URI / relative-ref """
6278: ret = libxml2mod.xmlParseURIReference(self._o, str)
6279: return ret
6280:
6281: def printURI(self, stream):
6282: """Prints the URI in the stream @stream. """
6283: libxml2mod.xmlPrintURI(stream, self._o)
6284:
6285: def saveUri(self):
6286: """Save the URI as an escaped string """
6287: ret = libxml2mod.xmlSaveUri(self._o)
6288: return ret
6289:
6290: class ValidCtxt(ValidCtxtCore):
6291: def __init__(self, _obj=None):
6292: self._o = _obj
6293: ValidCtxtCore.__init__(self, _obj=_obj)
6294:
6295: def __del__(self):
6296: if self._o != None:
6297: libxml2mod.xmlFreeValidCtxt(self._o)
6298: self._o = None
6299:
6300: #
6301: # ValidCtxt functions from module valid
6302: #
6303:
6304: def validCtxtNormalizeAttributeValue(self, doc, elem, name, value):
6305: """Does the validation related extra step of the normalization
6306: of attribute values: If the declared value is not CDATA,
6307: then the XML processor must further process the normalized
6308: attribute value by discarding any leading and trailing
6309: space (#x20) characters, and by replacing sequences of
6310: space (#x20) characters by single space (#x20) character.
6311: Also check VC: Standalone Document Declaration in P32, and
6312: update ctxt->valid accordingly """
6313: if doc is None: doc__o = None
6314: else: doc__o = doc._o
6315: if elem is None: elem__o = None
6316: else: elem__o = elem._o
6317: ret = libxml2mod.xmlValidCtxtNormalizeAttributeValue(self._o, doc__o, elem__o, name, value)
6318: return ret
6319:
6320: def validateDocument(self, doc):
6321: """Try to validate the document instance basically it does
6322: the all the checks described by the XML Rec i.e. validates
6323: the internal and external subset (if present) and validate
6324: the document tree. """
6325: if doc is None: doc__o = None
6326: else: doc__o = doc._o
6327: ret = libxml2mod.xmlValidateDocument(self._o, doc__o)
6328: return ret
6329:
6330: def validateDocumentFinal(self, doc):
6331: """Does the final step for the document validation once all
6332: the incremental validation steps have been completed
6333: basically it does the following checks described by the XML
6334: Rec Check all the IDREF/IDREFS attributes definition for
6335: validity """
6336: if doc is None: doc__o = None
6337: else: doc__o = doc._o
6338: ret = libxml2mod.xmlValidateDocumentFinal(self._o, doc__o)
6339: return ret
6340:
6341: def validateDtd(self, doc, dtd):
6342: """Try to validate the document against the dtd instance
6343: Basically it does check all the definitions in the DtD.
6344: Note the the internal subset (if present) is de-coupled
6345: (i.e. not used), which could give problems if ID or IDREF
6346: is present. """
6347: if doc is None: doc__o = None
6348: else: doc__o = doc._o
6349: if dtd is None: dtd__o = None
6350: else: dtd__o = dtd._o
6351: ret = libxml2mod.xmlValidateDtd(self._o, doc__o, dtd__o)
6352: return ret
6353:
6354: def validateDtdFinal(self, doc):
6355: """Does the final step for the dtds validation once all the
6356: subsets have been parsed basically it does the following
6357: checks described by the XML Rec - check that ENTITY and
6358: ENTITIES type attributes default or possible values matches
6359: one of the defined entities. - check that NOTATION type
6360: attributes default or possible values matches one of the
6361: defined notations. """
6362: if doc is None: doc__o = None
6363: else: doc__o = doc._o
6364: ret = libxml2mod.xmlValidateDtdFinal(self._o, doc__o)
6365: return ret
6366:
6367: def validateElement(self, doc, elem):
6368: """Try to validate the subtree under an element """
6369: if doc is None: doc__o = None
6370: else: doc__o = doc._o
6371: if elem is None: elem__o = None
6372: else: elem__o = elem._o
6373: ret = libxml2mod.xmlValidateElement(self._o, doc__o, elem__o)
6374: return ret
6375:
6376: def validateNotationUse(self, doc, notationName):
6377: """Validate that the given name match a notation declaration.
6378: - [ VC: Notation Declared ] """
6379: if doc is None: doc__o = None
6380: else: doc__o = doc._o
6381: ret = libxml2mod.xmlValidateNotationUse(self._o, doc__o, notationName)
6382: return ret
6383:
6384: def validateOneAttribute(self, doc, elem, attr, value):
6385: """Try to validate a single attribute for an element basically
6386: it does the following checks as described by the XML-1.0
6387: recommendation: - [ VC: Attribute Value Type ] - [ VC:
6388: Fixed Attribute Default ] - [ VC: Entity Name ] - [ VC:
6389: Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC: Entity
6390: Name ] - [ VC: Notation Attributes ] The ID/IDREF
6391: uniqueness and matching are done separately """
6392: if doc is None: doc__o = None
6393: else: doc__o = doc._o
6394: if elem is None: elem__o = None
6395: else: elem__o = elem._o
6396: if attr is None: attr__o = None
6397: else: attr__o = attr._o
6398: ret = libxml2mod.xmlValidateOneAttribute(self._o, doc__o, elem__o, attr__o, value)
6399: return ret
6400:
6401: def validateOneElement(self, doc, elem):
6402: """Try to validate a single element and it's attributes,
6403: basically it does the following checks as described by the
6404: XML-1.0 recommendation: - [ VC: Element Valid ] - [ VC:
6405: Required Attribute ] Then call xmlValidateOneAttribute()
6406: for each attribute present. The ID/IDREF checkings are
6407: done separately """
6408: if doc is None: doc__o = None
6409: else: doc__o = doc._o
6410: if elem is None: elem__o = None
6411: else: elem__o = elem._o
6412: ret = libxml2mod.xmlValidateOneElement(self._o, doc__o, elem__o)
6413: return ret
6414:
6415: def validateOneNamespace(self, doc, elem, prefix, ns, value):
6416: """Try to validate a single namespace declaration for an
6417: element basically it does the following checks as described
6418: by the XML-1.0 recommendation: - [ VC: Attribute Value Type
6419: ] - [ VC: Fixed Attribute Default ] - [ VC: Entity Name ] -
6420: [ VC: Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC:
6421: Entity Name ] - [ VC: Notation Attributes ] The ID/IDREF
6422: uniqueness and matching are done separately """
6423: if doc is None: doc__o = None
6424: else: doc__o = doc._o
6425: if elem is None: elem__o = None
6426: else: elem__o = elem._o
6427: if ns is None: ns__o = None
6428: else: ns__o = ns._o
6429: ret = libxml2mod.xmlValidateOneNamespace(self._o, doc__o, elem__o, prefix, ns__o, value)
6430: return ret
6431:
6432: def validatePopElement(self, doc, elem, qname):
6433: """Pop the element end from the validation stack. """
6434: if doc is None: doc__o = None
6435: else: doc__o = doc._o
6436: if elem is None: elem__o = None
6437: else: elem__o = elem._o
6438: ret = libxml2mod.xmlValidatePopElement(self._o, doc__o, elem__o, qname)
6439: return ret
6440:
6441: def validatePushCData(self, data, len):
6442: """check the CData parsed for validation in the current stack """
6443: ret = libxml2mod.xmlValidatePushCData(self._o, data, len)
6444: return ret
6445:
6446: def validatePushElement(self, doc, elem, qname):
6447: """Push a new element start on the validation stack. """
6448: if doc is None: doc__o = None
6449: else: doc__o = doc._o
6450: if elem is None: elem__o = None
6451: else: elem__o = elem._o
6452: ret = libxml2mod.xmlValidatePushElement(self._o, doc__o, elem__o, qname)
6453: return ret
6454:
6455: def validateRoot(self, doc):
6456: """Try to validate a the root element basically it does the
6457: following check as described by the XML-1.0 recommendation:
6458: - [ VC: Root Element Type ] it doesn't try to recurse or
6459: apply other check to the element """
6460: if doc is None: doc__o = None
6461: else: doc__o = doc._o
6462: ret = libxml2mod.xmlValidateRoot(self._o, doc__o)
6463: return ret
6464:
6465: class xpathContext:
6466: def __init__(self, _obj=None):
6467: if _obj != None:self._o = _obj;return
6468: self._o = None
6469:
6470: # accessors for xpathContext
6471: def contextDoc(self):
6472: """Get the doc from an xpathContext """
6473: ret = libxml2mod.xmlXPathGetContextDoc(self._o)
6474: if ret is None:raise xpathError('xmlXPathGetContextDoc() failed')
6475: __tmp = xmlDoc(_obj=ret)
6476: return __tmp
6477:
6478: def contextNode(self):
6479: """Get the current node from an xpathContext """
6480: ret = libxml2mod.xmlXPathGetContextNode(self._o)
6481: if ret is None:raise xpathError('xmlXPathGetContextNode() failed')
6482: __tmp = xmlNode(_obj=ret)
6483: return __tmp
6484:
6485: def contextPosition(self):
6486: """Get the current node from an xpathContext """
6487: ret = libxml2mod.xmlXPathGetContextPosition(self._o)
6488: return ret
6489:
6490: def contextSize(self):
6491: """Get the current node from an xpathContext """
6492: ret = libxml2mod.xmlXPathGetContextSize(self._o)
6493: return ret
6494:
6495: def function(self):
6496: """Get the current function name xpathContext """
6497: ret = libxml2mod.xmlXPathGetFunction(self._o)
6498: return ret
6499:
6500: def functionURI(self):
6501: """Get the current function name URI xpathContext """
6502: ret = libxml2mod.xmlXPathGetFunctionURI(self._o)
6503: return ret
6504:
6505: def setContextDoc(self, doc):
6506: """Set the doc of an xpathContext """
6507: if doc is None: doc__o = None
6508: else: doc__o = doc._o
6509: libxml2mod.xmlXPathSetContextDoc(self._o, doc__o)
6510:
6511: def setContextNode(self, node):
6512: """Set the current node of an xpathContext """
6513: if node is None: node__o = None
6514: else: node__o = node._o
6515: libxml2mod.xmlXPathSetContextNode(self._o, node__o)
6516:
6517: #
6518: # xpathContext functions from module python
6519: #
6520:
6521: def registerXPathFunction(self, name, ns_uri, f):
6522: """Register a Python written function to the XPath interpreter """
6523: ret = libxml2mod.xmlRegisterXPathFunction(self._o, name, ns_uri, f)
6524: return ret
6525:
6526: def xpathRegisterVariable(self, name, ns_uri, value):
6527: """Register a variable with the XPath context """
6528: ret = libxml2mod.xmlXPathRegisterVariable(self._o, name, ns_uri, value)
6529: return ret
6530:
6531: #
6532: # xpathContext functions from module xpath
6533: #
6534:
6535: def xpathContextSetCache(self, active, value, options):
6536: """Creates/frees an object cache on the XPath context. If
6537: activates XPath objects (xmlXPathObject) will be cached
6538: internally to be reused. @options: 0: This will set the
6539: XPath object caching: @value: This will set the maximum
6540: number of XPath objects to be cached per slot There are 5
6541: slots for: node-set, string, number, boolean, and misc
6542: objects. Use <0 for the default number (100). Other values
6543: for @options have currently no effect. """
6544: ret = libxml2mod.xmlXPathContextSetCache(self._o, active, value, options)
6545: return ret
6546:
6547: def xpathEval(self, str):
6548: """Evaluate the XPath Location Path in the given context. """
6549: ret = libxml2mod.xmlXPathEval(str, self._o)
6550: if ret is None:raise xpathError('xmlXPathEval() failed')
6551: return xpathObjectRet(ret)
6552:
6553: def xpathEvalExpression(self, str):
6554: """Evaluate the XPath expression in the given context. """
6555: ret = libxml2mod.xmlXPathEvalExpression(str, self._o)
6556: if ret is None:raise xpathError('xmlXPathEvalExpression() failed')
6557: return xpathObjectRet(ret)
6558:
6559: def xpathFreeContext(self):
6560: """Free up an xmlXPathContext """
6561: libxml2mod.xmlXPathFreeContext(self._o)
6562:
6563: #
6564: # xpathContext functions from module xpathInternals
6565: #
6566:
6567: def xpathNewParserContext(self, str):
6568: """Create a new xmlXPathParserContext """
6569: ret = libxml2mod.xmlXPathNewParserContext(str, self._o)
6570: if ret is None:raise xpathError('xmlXPathNewParserContext() failed')
6571: __tmp = xpathParserContext(_obj=ret)
6572: return __tmp
6573:
6574: def xpathNsLookup(self, prefix):
6575: """Search in the namespace declaration array of the context
6576: for the given namespace name associated to the given prefix """
6577: ret = libxml2mod.xmlXPathNsLookup(self._o, prefix)
6578: return ret
6579:
6580: def xpathRegisterAllFunctions(self):
6581: """Registers all default XPath functions in this context """
6582: libxml2mod.xmlXPathRegisterAllFunctions(self._o)
6583:
6584: def xpathRegisterNs(self, prefix, ns_uri):
6585: """Register a new namespace. If @ns_uri is None it unregisters
6586: the namespace """
6587: ret = libxml2mod.xmlXPathRegisterNs(self._o, prefix, ns_uri)
6588: return ret
6589:
6590: def xpathRegisteredFuncsCleanup(self):
6591: """Cleanup the XPath context data associated to registered
6592: functions """
6593: libxml2mod.xmlXPathRegisteredFuncsCleanup(self._o)
6594:
6595: def xpathRegisteredNsCleanup(self):
6596: """Cleanup the XPath context data associated to registered
6597: variables """
6598: libxml2mod.xmlXPathRegisteredNsCleanup(self._o)
6599:
6600: def xpathRegisteredVariablesCleanup(self):
6601: """Cleanup the XPath context data associated to registered
6602: variables """
6603: libxml2mod.xmlXPathRegisteredVariablesCleanup(self._o)
6604:
6605: def xpathVariableLookup(self, name):
6606: """Search in the Variable array of the context for the given
6607: variable value. """
6608: ret = libxml2mod.xmlXPathVariableLookup(self._o, name)
6609: if ret is None:raise xpathError('xmlXPathVariableLookup() failed')
6610: return xpathObjectRet(ret)
6611:
6612: def xpathVariableLookupNS(self, name, ns_uri):
6613: """Search in the Variable array of the context for the given
6614: variable value. """
6615: ret = libxml2mod.xmlXPathVariableLookupNS(self._o, name, ns_uri)
6616: if ret is None:raise xpathError('xmlXPathVariableLookupNS() failed')
6617: return xpathObjectRet(ret)
6618:
6619: #
6620: # xpathContext functions from module xpointer
6621: #
6622:
6623: def xpointerEval(self, str):
6624: """Evaluate the XPath Location Path in the given context. """
6625: ret = libxml2mod.xmlXPtrEval(str, self._o)
6626: if ret is None:raise treeError('xmlXPtrEval() failed')
6627: return xpathObjectRet(ret)
6628:
6629: class xpathParserContext:
6630: def __init__(self, _obj=None):
6631: if _obj != None:self._o = _obj;return
6632: self._o = None
6633:
6634: # accessors for xpathParserContext
6635: def context(self):
6636: """Get the xpathContext from an xpathParserContext """
6637: ret = libxml2mod.xmlXPathParserGetContext(self._o)
6638: if ret is None:raise xpathError('xmlXPathParserGetContext() failed')
6639: __tmp = xpathContext(_obj=ret)
6640: return __tmp
6641:
6642: #
6643: # xpathParserContext functions from module xpathInternals
6644: #
6645:
6646: def xpathAddValues(self):
6647: """Implement the add operation on XPath objects: The numeric
6648: operators convert their operands to numbers as if by
6649: calling the number function. """
6650: libxml2mod.xmlXPathAddValues(self._o)
6651:
6652: def xpathBooleanFunction(self, nargs):
6653: """Implement the boolean() XPath function boolean
6654: boolean(object) The boolean function converts its argument
6655: to a boolean as follows: - a number is true if and only if
6656: it is neither positive or negative zero nor NaN - a
6657: node-set is true if and only if it is non-empty - a string
6658: is true if and only if its length is non-zero """
6659: libxml2mod.xmlXPathBooleanFunction(self._o, nargs)
6660:
6661: def xpathCeilingFunction(self, nargs):
6662: """Implement the ceiling() XPath function number
6663: ceiling(number) The ceiling function returns the smallest
6664: (closest to negative infinity) number that is not less than
6665: the argument and that is an integer. """
6666: libxml2mod.xmlXPathCeilingFunction(self._o, nargs)
6667:
6668: def xpathCompareValues(self, inf, strict):
6669: """Implement the compare operation on XPath objects: @arg1 <
6670: @arg2 (1, 1, ... @arg1 <= @arg2 (1, 0, ... @arg1 >
6671: @arg2 (0, 1, ... @arg1 >= @arg2 (0, 0, ... When
6672: neither object to be compared is a node-set and the
6673: operator is <=, <, >=, >, then the objects are compared by
6674: converted both objects to numbers and comparing the numbers
6675: according to IEEE 754. The < comparison will be true if and
6676: only if the first number is less than the second number.
6677: The <= comparison will be true if and only if the first
6678: number is less than or equal to the second number. The >
6679: comparison will be true if and only if the first number is
6680: greater than the second number. The >= comparison will be
6681: true if and only if the first number is greater than or
6682: equal to the second number. """
6683: ret = libxml2mod.xmlXPathCompareValues(self._o, inf, strict)
6684: return ret
6685:
6686: def xpathConcatFunction(self, nargs):
6687: """Implement the concat() XPath function string concat(string,
6688: string, string*) The concat function returns the
6689: concatenation of its arguments. """
6690: libxml2mod.xmlXPathConcatFunction(self._o, nargs)
6691:
6692: def xpathContainsFunction(self, nargs):
6693: """Implement the contains() XPath function boolean
6694: contains(string, string) The contains function returns true
6695: if the first argument string contains the second argument
6696: string, and otherwise returns false. """
6697: libxml2mod.xmlXPathContainsFunction(self._o, nargs)
6698:
6699: def xpathCountFunction(self, nargs):
6700: """Implement the count() XPath function number count(node-set) """
6701: libxml2mod.xmlXPathCountFunction(self._o, nargs)
6702:
6703: def xpathDivValues(self):
6704: """Implement the div operation on XPath objects @arg1 / @arg2:
6705: The numeric operators convert their operands to numbers as
6706: if by calling the number function. """
6707: libxml2mod.xmlXPathDivValues(self._o)
6708:
6709: def xpathEqualValues(self):
6710: """Implement the equal operation on XPath objects content:
6711: @arg1 == @arg2 """
6712: ret = libxml2mod.xmlXPathEqualValues(self._o)
6713: return ret
6714:
6715: def xpathErr(self, error):
6716: """Handle an XPath error """
6717: libxml2mod.xmlXPathErr(self._o, error)
6718:
6719: def xpathEvalExpr(self):
6720: """Parse and evaluate an XPath expression in the given
6721: context, then push the result on the context stack """
6722: libxml2mod.xmlXPathEvalExpr(self._o)
6723:
6724: def xpathFalseFunction(self, nargs):
6725: """Implement the false() XPath function boolean false() """
6726: libxml2mod.xmlXPathFalseFunction(self._o, nargs)
6727:
6728: def xpathFloorFunction(self, nargs):
6729: """Implement the floor() XPath function number floor(number)
6730: The floor function returns the largest (closest to positive
6731: infinity) number that is not greater than the argument and
6732: that is an integer. """
6733: libxml2mod.xmlXPathFloorFunction(self._o, nargs)
6734:
6735: def xpathFreeParserContext(self):
6736: """Free up an xmlXPathParserContext """
6737: libxml2mod.xmlXPathFreeParserContext(self._o)
6738:
6739: def xpathIdFunction(self, nargs):
6740: """Implement the id() XPath function node-set id(object) The
6741: id function selects elements by their unique ID (see [5.2.1
6742: Unique IDs]). When the argument to id is of type node-set,
6743: then the result is the union of the result of applying id
6744: to the string value of each of the nodes in the argument
6745: node-set. When the argument to id is of any other type, the
6746: argument is converted to a string as if by a call to the
6747: string function; the string is split into a
6748: whitespace-separated list of tokens (whitespace is any
6749: sequence of characters matching the production S); the
6750: result is a node-set containing the elements in the same
6751: document as the context node that have a unique ID equal to
6752: any of the tokens in the list. """
6753: libxml2mod.xmlXPathIdFunction(self._o, nargs)
6754:
6755: def xpathLangFunction(self, nargs):
6756: """Implement the lang() XPath function boolean lang(string)
6757: The lang function returns true or false depending on
6758: whether the language of the context node as specified by
6759: xml:lang attributes is the same as or is a sublanguage of
6760: the language specified by the argument string. The language
6761: of the context node is determined by the value of the
6762: xml:lang attribute on the context node, or, if the context
6763: node has no xml:lang attribute, by the value of the
6764: xml:lang attribute on the nearest ancestor of the context
6765: node that has an xml:lang attribute. If there is no such
6766: attribute, then lang """
6767: libxml2mod.xmlXPathLangFunction(self._o, nargs)
6768:
6769: def xpathLastFunction(self, nargs):
6770: """Implement the last() XPath function number last() The last
6771: function returns the number of nodes in the context node
6772: list. """
6773: libxml2mod.xmlXPathLastFunction(self._o, nargs)
6774:
6775: def xpathLocalNameFunction(self, nargs):
6776: """Implement the local-name() XPath function string
6777: local-name(node-set?) The local-name function returns a
6778: string containing the local part of the name of the node in
6779: the argument node-set that is first in document order. If
6780: the node-set is empty or the first node has no name, an
6781: empty string is returned. If the argument is omitted it
6782: defaults to the context node. """
6783: libxml2mod.xmlXPathLocalNameFunction(self._o, nargs)
6784:
6785: def xpathModValues(self):
6786: """Implement the mod operation on XPath objects: @arg1 / @arg2
6787: The numeric operators convert their operands to numbers as
6788: if by calling the number function. """
6789: libxml2mod.xmlXPathModValues(self._o)
6790:
6791: def xpathMultValues(self):
6792: """Implement the multiply operation on XPath objects: The
6793: numeric operators convert their operands to numbers as if
6794: by calling the number function. """
6795: libxml2mod.xmlXPathMultValues(self._o)
6796:
6797: def xpathNamespaceURIFunction(self, nargs):
6798: """Implement the namespace-uri() XPath function string
6799: namespace-uri(node-set?) The namespace-uri function returns
6800: a string containing the namespace URI of the expanded name
6801: of the node in the argument node-set that is first in
6802: document order. If the node-set is empty, the first node
6803: has no name, or the expanded name has no namespace URI, an
6804: empty string is returned. If the argument is omitted it
6805: defaults to the context node. """
6806: libxml2mod.xmlXPathNamespaceURIFunction(self._o, nargs)
6807:
6808: def xpathNextAncestor(self, cur):
6809: """Traversal function for the "ancestor" direction the
6810: ancestor axis contains the ancestors of the context node;
6811: the ancestors of the context node consist of the parent of
6812: context node and the parent's parent and so on; the nodes
6813: are ordered in reverse document order; thus the parent is
6814: the first node on the axis, and the parent's parent is the
6815: second node on the axis """
6816: if cur is None: cur__o = None
6817: else: cur__o = cur._o
6818: ret = libxml2mod.xmlXPathNextAncestor(self._o, cur__o)
6819: if ret is None:raise xpathError('xmlXPathNextAncestor() failed')
6820: __tmp = xmlNode(_obj=ret)
6821: return __tmp
6822:
6823: def xpathNextAncestorOrSelf(self, cur):
6824: """Traversal function for the "ancestor-or-self" direction he
6825: ancestor-or-self axis contains the context node and
6826: ancestors of the context node in reverse document order;
6827: thus the context node is the first node on the axis, and
6828: the context node's parent the second; parent here is
6829: defined the same as with the parent axis. """
6830: if cur is None: cur__o = None
6831: else: cur__o = cur._o
6832: ret = libxml2mod.xmlXPathNextAncestorOrSelf(self._o, cur__o)
6833: if ret is None:raise xpathError('xmlXPathNextAncestorOrSelf() failed')
6834: __tmp = xmlNode(_obj=ret)
6835: return __tmp
6836:
6837: def xpathNextAttribute(self, cur):
6838: """Traversal function for the "attribute" direction TODO:
6839: support DTD inherited default attributes """
6840: if cur is None: cur__o = None
6841: else: cur__o = cur._o
6842: ret = libxml2mod.xmlXPathNextAttribute(self._o, cur__o)
6843: if ret is None:raise xpathError('xmlXPathNextAttribute() failed')
6844: __tmp = xmlNode(_obj=ret)
6845: return __tmp
6846:
6847: def xpathNextChild(self, cur):
6848: """Traversal function for the "child" direction The child axis
6849: contains the children of the context node in document order. """
6850: if cur is None: cur__o = None
6851: else: cur__o = cur._o
6852: ret = libxml2mod.xmlXPathNextChild(self._o, cur__o)
6853: if ret is None:raise xpathError('xmlXPathNextChild() failed')
6854: __tmp = xmlNode(_obj=ret)
6855: return __tmp
6856:
6857: def xpathNextDescendant(self, cur):
6858: """Traversal function for the "descendant" direction the
6859: descendant axis contains the descendants of the context
6860: node in document order; a descendant is a child or a child
6861: of a child and so on. """
6862: if cur is None: cur__o = None
6863: else: cur__o = cur._o
6864: ret = libxml2mod.xmlXPathNextDescendant(self._o, cur__o)
6865: if ret is None:raise xpathError('xmlXPathNextDescendant() failed')
6866: __tmp = xmlNode(_obj=ret)
6867: return __tmp
6868:
6869: def xpathNextDescendantOrSelf(self, cur):
6870: """Traversal function for the "descendant-or-self" direction
6871: the descendant-or-self axis contains the context node and
6872: the descendants of the context node in document order; thus
6873: the context node is the first node on the axis, and the
6874: first child of the context node is the second node on the
6875: axis """
6876: if cur is None: cur__o = None
6877: else: cur__o = cur._o
6878: ret = libxml2mod.xmlXPathNextDescendantOrSelf(self._o, cur__o)
6879: if ret is None:raise xpathError('xmlXPathNextDescendantOrSelf() failed')
6880: __tmp = xmlNode(_obj=ret)
6881: return __tmp
6882:
6883: def xpathNextFollowing(self, cur):
6884: """Traversal function for the "following" direction The
6885: following axis contains all nodes in the same document as
6886: the context node that are after the context node in
6887: document order, excluding any descendants and excluding
6888: attribute nodes and namespace nodes; the nodes are ordered
6889: in document order """
6890: if cur is None: cur__o = None
6891: else: cur__o = cur._o
6892: ret = libxml2mod.xmlXPathNextFollowing(self._o, cur__o)
6893: if ret is None:raise xpathError('xmlXPathNextFollowing() failed')
6894: __tmp = xmlNode(_obj=ret)
6895: return __tmp
6896:
6897: def xpathNextFollowingSibling(self, cur):
6898: """Traversal function for the "following-sibling" direction
6899: The following-sibling axis contains the following siblings
6900: of the context node in document order. """
6901: if cur is None: cur__o = None
6902: else: cur__o = cur._o
6903: ret = libxml2mod.xmlXPathNextFollowingSibling(self._o, cur__o)
6904: if ret is None:raise xpathError('xmlXPathNextFollowingSibling() failed')
6905: __tmp = xmlNode(_obj=ret)
6906: return __tmp
6907:
6908: def xpathNextNamespace(self, cur):
6909: """Traversal function for the "namespace" direction the
6910: namespace axis contains the namespace nodes of the context
6911: node; the order of nodes on this axis is
6912: implementation-defined; the axis will be empty unless the
6913: context node is an element We keep the XML namespace node
6914: at the end of the list. """
6915: if cur is None: cur__o = None
6916: else: cur__o = cur._o
6917: ret = libxml2mod.xmlXPathNextNamespace(self._o, cur__o)
6918: if ret is None:raise xpathError('xmlXPathNextNamespace() failed')
6919: __tmp = xmlNode(_obj=ret)
6920: return __tmp
6921:
6922: def xpathNextParent(self, cur):
6923: """Traversal function for the "parent" direction The parent
6924: axis contains the parent of the context node, if there is
6925: one. """
6926: if cur is None: cur__o = None
6927: else: cur__o = cur._o
6928: ret = libxml2mod.xmlXPathNextParent(self._o, cur__o)
6929: if ret is None:raise xpathError('xmlXPathNextParent() failed')
6930: __tmp = xmlNode(_obj=ret)
6931: return __tmp
6932:
6933: def xpathNextPreceding(self, cur):
6934: """Traversal function for the "preceding" direction the
6935: preceding axis contains all nodes in the same document as
6936: the context node that are before the context node in
6937: document order, excluding any ancestors and excluding
6938: attribute nodes and namespace nodes; the nodes are ordered
6939: in reverse document order """
6940: if cur is None: cur__o = None
6941: else: cur__o = cur._o
6942: ret = libxml2mod.xmlXPathNextPreceding(self._o, cur__o)
6943: if ret is None:raise xpathError('xmlXPathNextPreceding() failed')
6944: __tmp = xmlNode(_obj=ret)
6945: return __tmp
6946:
6947: def xpathNextPrecedingSibling(self, cur):
6948: """Traversal function for the "preceding-sibling" direction
6949: The preceding-sibling axis contains the preceding siblings
6950: of the context node in reverse document order; the first
6951: preceding sibling is first on the axis; the sibling
6952: preceding that node is the second on the axis and so on. """
6953: if cur is None: cur__o = None
6954: else: cur__o = cur._o
6955: ret = libxml2mod.xmlXPathNextPrecedingSibling(self._o, cur__o)
6956: if ret is None:raise xpathError('xmlXPathNextPrecedingSibling() failed')
6957: __tmp = xmlNode(_obj=ret)
6958: return __tmp
6959:
6960: def xpathNextSelf(self, cur):
6961: """Traversal function for the "self" direction The self axis
6962: contains just the context node itself """
6963: if cur is None: cur__o = None
6964: else: cur__o = cur._o
6965: ret = libxml2mod.xmlXPathNextSelf(self._o, cur__o)
6966: if ret is None:raise xpathError('xmlXPathNextSelf() failed')
6967: __tmp = xmlNode(_obj=ret)
6968: return __tmp
6969:
6970: def xpathNormalizeFunction(self, nargs):
6971: """Implement the normalize-space() XPath function string
6972: normalize-space(string?) The normalize-space function
6973: returns the argument string with white space normalized by
6974: stripping leading and trailing whitespace and replacing
6975: sequences of whitespace characters by a single space.
6976: Whitespace characters are the same allowed by the S
6977: production in XML. If the argument is omitted, it defaults
6978: to the context node converted to a string, in other words
6979: the value of the context node. """
6980: libxml2mod.xmlXPathNormalizeFunction(self._o, nargs)
6981:
6982: def xpathNotEqualValues(self):
6983: """Implement the equal operation on XPath objects content:
6984: @arg1 == @arg2 """
6985: ret = libxml2mod.xmlXPathNotEqualValues(self._o)
6986: return ret
6987:
6988: def xpathNotFunction(self, nargs):
6989: """Implement the not() XPath function boolean not(boolean) The
6990: not function returns true if its argument is false, and
6991: false otherwise. """
6992: libxml2mod.xmlXPathNotFunction(self._o, nargs)
6993:
6994: def xpathNumberFunction(self, nargs):
6995: """Implement the number() XPath function number number(object?) """
6996: libxml2mod.xmlXPathNumberFunction(self._o, nargs)
6997:
6998: def xpathParseNCName(self):
6999: """parse an XML namespace non qualified name. [NS 3] NCName
7000: ::= (Letter | '_') (NCNameChar)* [NS 4] NCNameChar ::=
7001: Letter | Digit | '.' | '-' | '_' | CombiningChar | Extender """
7002: ret = libxml2mod.xmlXPathParseNCName(self._o)
7003: return ret
7004:
7005: def xpathParseName(self):
7006: """parse an XML name [4] NameChar ::= Letter | Digit | '.' |
7007: '-' | '_' | ':' | CombiningChar | Extender [5] Name ::=
7008: (Letter | '_' | ':') (NameChar)* """
7009: ret = libxml2mod.xmlXPathParseName(self._o)
7010: return ret
7011:
7012: def xpathPopBoolean(self):
7013: """Pops a boolean from the stack, handling conversion if
7014: needed. Check error with #xmlXPathCheckError. """
7015: ret = libxml2mod.xmlXPathPopBoolean(self._o)
7016: return ret
7017:
7018: def xpathPopNumber(self):
7019: """Pops a number from the stack, handling conversion if
7020: needed. Check error with #xmlXPathCheckError. """
7021: ret = libxml2mod.xmlXPathPopNumber(self._o)
7022: return ret
7023:
7024: def xpathPopString(self):
7025: """Pops a string from the stack, handling conversion if
7026: needed. Check error with #xmlXPathCheckError. """
7027: ret = libxml2mod.xmlXPathPopString(self._o)
7028: return ret
7029:
7030: def xpathPositionFunction(self, nargs):
7031: """Implement the position() XPath function number position()
7032: The position function returns the position of the context
7033: node in the context node list. The first position is 1, and
7034: so the last position will be equal to last(). """
7035: libxml2mod.xmlXPathPositionFunction(self._o, nargs)
7036:
7037: def xpathRoot(self):
7038: """Initialize the context to the root of the document """
7039: libxml2mod.xmlXPathRoot(self._o)
7040:
7041: def xpathRoundFunction(self, nargs):
7042: """Implement the round() XPath function number round(number)
7043: The round function returns the number that is closest to
7044: the argument and that is an integer. If there are two such
7045: numbers, then the one that is even is returned. """
7046: libxml2mod.xmlXPathRoundFunction(self._o, nargs)
7047:
7048: def xpathStartsWithFunction(self, nargs):
7049: """Implement the starts-with() XPath function boolean
7050: starts-with(string, string) The starts-with function
7051: returns true if the first argument string starts with the
7052: second argument string, and otherwise returns false. """
7053: libxml2mod.xmlXPathStartsWithFunction(self._o, nargs)
7054:
7055: def xpathStringFunction(self, nargs):
7056: """Implement the string() XPath function string
7057: string(object?) The string function converts an object to a
7058: string as follows: - A node-set is converted to a string by
7059: returning the value of the node in the node-set that is
7060: first in document order. If the node-set is empty, an empty
7061: string is returned. - A number is converted to a string as
7062: follows + NaN is converted to the string NaN + positive
7063: zero is converted to the string 0 + negative zero is
7064: converted to the string 0 + positive infinity is converted
7065: to the string Infinity + negative infinity is converted to
7066: the string -Infinity + if the number is an integer, the
7067: number is represented in decimal form as a Number with no
7068: decimal point and no leading zeros, preceded by a minus
7069: sign (-) if the number is negative + otherwise, the number
7070: is represented in decimal form as a Number including a
7071: decimal point with at least one digit before the decimal
7072: point and at least one digit after the decimal point,
7073: preceded by a minus sign (-) if the number is negative;
7074: there must be no leading zeros before the decimal point
7075: apart possibly from the one required digit immediately
7076: before the decimal point; beyond the one required digit
7077: after the decimal point there must be as many, but only as
7078: many, more digits as are needed to uniquely distinguish the
7079: number from all other IEEE 754 numeric values. - The
7080: boolean false value is converted to the string false. The
7081: boolean true value is converted to the string true. If the
7082: argument is omitted, it defaults to a node-set with the
7083: context node as its only member. """
7084: libxml2mod.xmlXPathStringFunction(self._o, nargs)
7085:
7086: def xpathStringLengthFunction(self, nargs):
7087: """Implement the string-length() XPath function number
7088: string-length(string?) The string-length returns the number
7089: of characters in the string (see [3.6 Strings]). If the
7090: argument is omitted, it defaults to the context node
7091: converted to a string, in other words the value of the
7092: context node. """
7093: libxml2mod.xmlXPathStringLengthFunction(self._o, nargs)
7094:
7095: def xpathSubValues(self):
7096: """Implement the subtraction operation on XPath objects: The
7097: numeric operators convert their operands to numbers as if
7098: by calling the number function. """
7099: libxml2mod.xmlXPathSubValues(self._o)
7100:
7101: def xpathSubstringAfterFunction(self, nargs):
7102: """Implement the substring-after() XPath function string
7103: substring-after(string, string) The substring-after
7104: function returns the substring of the first argument string
7105: that follows the first occurrence of the second argument
7106: string in the first argument string, or the empty stringi
7107: if the first argument string does not contain the second
7108: argument string. For example,
7109: substring-after("1999/04/01","/") returns 04/01, and
7110: substring-after("1999/04/01","19") returns 99/04/01. """
7111: libxml2mod.xmlXPathSubstringAfterFunction(self._o, nargs)
7112:
7113: def xpathSubstringBeforeFunction(self, nargs):
7114: """Implement the substring-before() XPath function string
7115: substring-before(string, string) The substring-before
7116: function returns the substring of the first argument string
7117: that precedes the first occurrence of the second argument
7118: string in the first argument string, or the empty string if
7119: the first argument string does not contain the second
7120: argument string. For example,
7121: substring-before("1999/04/01","/") returns 1999. """
7122: libxml2mod.xmlXPathSubstringBeforeFunction(self._o, nargs)
7123:
7124: def xpathSubstringFunction(self, nargs):
7125: """Implement the substring() XPath function string
7126: substring(string, number, number?) The substring function
7127: returns the substring of the first argument starting at the
7128: position specified in the second argument with length
7129: specified in the third argument. For example,
7130: substring("12345",2,3) returns "234". If the third argument
7131: is not specified, it returns the substring starting at the
7132: position specified in the second argument and continuing to
7133: the end of the string. For example, substring("12345",2)
7134: returns "2345". More precisely, each character in the
7135: string (see [3.6 Strings]) is considered to have a numeric
7136: position: the position of the first character is 1, the
7137: position of the second character is 2 and so on. The
7138: returned substring contains those characters for which the
7139: position of the character is greater than or equal to the
7140: second argument and, if the third argument is specified,
7141: less than the sum of the second and third arguments; the
7142: comparisons and addition used for the above follow the
7143: standard IEEE 754 rules. Thus: - substring("12345", 1.5,
7144: 2.6) returns "234" - substring("12345", 0, 3) returns "12"
7145: - substring("12345", 0 div 0, 3) returns "" -
7146: substring("12345", 1, 0 div 0) returns "" -
7147: substring("12345", -42, 1 div 0) returns "12345" -
7148: substring("12345", -1 div 0, 1 div 0) returns "" """
7149: libxml2mod.xmlXPathSubstringFunction(self._o, nargs)
7150:
7151: def xpathSumFunction(self, nargs):
7152: """Implement the sum() XPath function number sum(node-set) The
7153: sum function returns the sum of the values of the nodes in
7154: the argument node-set. """
7155: libxml2mod.xmlXPathSumFunction(self._o, nargs)
7156:
7157: def xpathTranslateFunction(self, nargs):
7158: """Implement the translate() XPath function string
7159: translate(string, string, string) The translate function
7160: returns the first argument string with occurrences of
7161: characters in the second argument string replaced by the
7162: character at the corresponding position in the third
7163: argument string. For example, translate("bar","abc","ABC")
7164: returns the string BAr. If there is a character in the
7165: second argument string with no character at a corresponding
7166: position in the third argument string (because the second
7167: argument string is longer than the third argument string),
7168: then occurrences of that character in the first argument
7169: string are removed. For example,
7170: translate("--aaa--","abc-","ABC") """
7171: libxml2mod.xmlXPathTranslateFunction(self._o, nargs)
7172:
7173: def xpathTrueFunction(self, nargs):
7174: """Implement the true() XPath function boolean true() """
7175: libxml2mod.xmlXPathTrueFunction(self._o, nargs)
7176:
7177: def xpathValueFlipSign(self):
7178: """Implement the unary - operation on an XPath object The
7179: numeric operators convert their operands to numbers as if
7180: by calling the number function. """
7181: libxml2mod.xmlXPathValueFlipSign(self._o)
7182:
7183: def xpatherror(self, file, line, no):
7184: """Formats an error message. """
7185: libxml2mod.xmlXPatherror(self._o, file, line, no)
7186:
7187: #
7188: # xpathParserContext functions from module xpointer
7189: #
7190:
7191: def xpointerEvalRangePredicate(self):
7192: """[8] Predicate ::= '[' PredicateExpr ']' [9]
7193: PredicateExpr ::= Expr Evaluate a predicate as in
7194: xmlXPathEvalPredicate() but for a Location Set instead of a
7195: node set """
7196: libxml2mod.xmlXPtrEvalRangePredicate(self._o)
7197:
7198: def xpointerRangeToFunction(self, nargs):
7199: """Implement the range-to() XPointer function """
7200: libxml2mod.xmlXPtrRangeToFunction(self._o, nargs)
7201:
7202: # xlinkShow
7203: XLINK_SHOW_NONE = 0
7204: XLINK_SHOW_NEW = 1
7205: XLINK_SHOW_EMBED = 2
7206: XLINK_SHOW_REPLACE = 3
7207:
7208: # xmlRelaxNGParserFlag
7209: XML_RELAXNGP_NONE = 0
7210: XML_RELAXNGP_FREE_DOC = 1
7211: XML_RELAXNGP_CRNG = 2
7212:
7213: # xmlBufferAllocationScheme
7214: XML_BUFFER_ALLOC_DOUBLEIT = 1
7215: XML_BUFFER_ALLOC_EXACT = 2
7216: XML_BUFFER_ALLOC_IMMUTABLE = 3
7217: XML_BUFFER_ALLOC_IO = 4
7218: XML_BUFFER_ALLOC_HYBRID = 5
7219:
7220: # xmlParserSeverities
7221: XML_PARSER_SEVERITY_VALIDITY_WARNING = 1
7222: XML_PARSER_SEVERITY_VALIDITY_ERROR = 2
7223: XML_PARSER_SEVERITY_WARNING = 3
7224: XML_PARSER_SEVERITY_ERROR = 4
7225:
7226: # xmlAttributeDefault
7227: XML_ATTRIBUTE_NONE = 1
7228: XML_ATTRIBUTE_REQUIRED = 2
7229: XML_ATTRIBUTE_IMPLIED = 3
7230: XML_ATTRIBUTE_FIXED = 4
7231:
7232: # xmlSchemaValType
7233: XML_SCHEMAS_UNKNOWN = 0
7234: XML_SCHEMAS_STRING = 1
7235: XML_SCHEMAS_NORMSTRING = 2
7236: XML_SCHEMAS_DECIMAL = 3
7237: XML_SCHEMAS_TIME = 4
7238: XML_SCHEMAS_GDAY = 5
7239: XML_SCHEMAS_GMONTH = 6
7240: XML_SCHEMAS_GMONTHDAY = 7
7241: XML_SCHEMAS_GYEAR = 8
7242: XML_SCHEMAS_GYEARMONTH = 9
7243: XML_SCHEMAS_DATE = 10
7244: XML_SCHEMAS_DATETIME = 11
7245: XML_SCHEMAS_DURATION = 12
7246: XML_SCHEMAS_FLOAT = 13
7247: XML_SCHEMAS_DOUBLE = 14
7248: XML_SCHEMAS_BOOLEAN = 15
7249: XML_SCHEMAS_TOKEN = 16
7250: XML_SCHEMAS_LANGUAGE = 17
7251: XML_SCHEMAS_NMTOKEN = 18
7252: XML_SCHEMAS_NMTOKENS = 19
7253: XML_SCHEMAS_NAME = 20
7254: XML_SCHEMAS_QNAME = 21
7255: XML_SCHEMAS_NCNAME = 22
7256: XML_SCHEMAS_ID = 23
7257: XML_SCHEMAS_IDREF = 24
7258: XML_SCHEMAS_IDREFS = 25
7259: XML_SCHEMAS_ENTITY = 26
7260: XML_SCHEMAS_ENTITIES = 27
7261: XML_SCHEMAS_NOTATION = 28
7262: XML_SCHEMAS_ANYURI = 29
7263: XML_SCHEMAS_INTEGER = 30
7264: XML_SCHEMAS_NPINTEGER = 31
7265: XML_SCHEMAS_NINTEGER = 32
7266: XML_SCHEMAS_NNINTEGER = 33
7267: XML_SCHEMAS_PINTEGER = 34
7268: XML_SCHEMAS_INT = 35
7269: XML_SCHEMAS_UINT = 36
7270: XML_SCHEMAS_LONG = 37
7271: XML_SCHEMAS_ULONG = 38
7272: XML_SCHEMAS_SHORT = 39
7273: XML_SCHEMAS_USHORT = 40
7274: XML_SCHEMAS_BYTE = 41
7275: XML_SCHEMAS_UBYTE = 42
7276: XML_SCHEMAS_HEXBINARY = 43
7277: XML_SCHEMAS_BASE64BINARY = 44
7278: XML_SCHEMAS_ANYTYPE = 45
7279: XML_SCHEMAS_ANYSIMPLETYPE = 46
7280:
7281: # xmlParserInputState
7282: XML_PARSER_EOF = -1
7283: XML_PARSER_START = 0
7284: XML_PARSER_MISC = 1
7285: XML_PARSER_PI = 2
7286: XML_PARSER_DTD = 3
7287: XML_PARSER_PROLOG = 4
7288: XML_PARSER_COMMENT = 5
7289: XML_PARSER_START_TAG = 6
7290: XML_PARSER_CONTENT = 7
7291: XML_PARSER_CDATA_SECTION = 8
7292: XML_PARSER_END_TAG = 9
7293: XML_PARSER_ENTITY_DECL = 10
7294: XML_PARSER_ENTITY_VALUE = 11
7295: XML_PARSER_ATTRIBUTE_VALUE = 12
7296: XML_PARSER_SYSTEM_LITERAL = 13
7297: XML_PARSER_EPILOG = 14
7298: XML_PARSER_IGNORE = 15
7299: XML_PARSER_PUBLIC_LITERAL = 16
7300:
7301: # xmlEntityType
7302: XML_INTERNAL_GENERAL_ENTITY = 1
7303: XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2
7304: XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3
7305: XML_INTERNAL_PARAMETER_ENTITY = 4
7306: XML_EXTERNAL_PARAMETER_ENTITY = 5
7307: XML_INTERNAL_PREDEFINED_ENTITY = 6
7308:
7309: # xmlSaveOption
7310: XML_SAVE_FORMAT = 1
7311: XML_SAVE_NO_DECL = 2
7312: XML_SAVE_NO_EMPTY = 4
7313: XML_SAVE_NO_XHTML = 8
7314: XML_SAVE_XHTML = 16
7315: XML_SAVE_AS_XML = 32
7316: XML_SAVE_AS_HTML = 64
7317: XML_SAVE_WSNONSIG = 128
7318:
7319: # xmlPatternFlags
7320: XML_PATTERN_DEFAULT = 0
7321: XML_PATTERN_XPATH = 1
7322: XML_PATTERN_XSSEL = 2
7323: XML_PATTERN_XSFIELD = 4
7324:
7325: # xmlParserErrors
7326: XML_ERR_OK = 0
7327: XML_ERR_INTERNAL_ERROR = 1
7328: XML_ERR_NO_MEMORY = 2
7329: XML_ERR_DOCUMENT_START = 3
7330: XML_ERR_DOCUMENT_EMPTY = 4
7331: XML_ERR_DOCUMENT_END = 5
7332: XML_ERR_INVALID_HEX_CHARREF = 6
7333: XML_ERR_INVALID_DEC_CHARREF = 7
7334: XML_ERR_INVALID_CHARREF = 8
7335: XML_ERR_INVALID_CHAR = 9
7336: XML_ERR_CHARREF_AT_EOF = 10
7337: XML_ERR_CHARREF_IN_PROLOG = 11
7338: XML_ERR_CHARREF_IN_EPILOG = 12
7339: XML_ERR_CHARREF_IN_DTD = 13
7340: XML_ERR_ENTITYREF_AT_EOF = 14
7341: XML_ERR_ENTITYREF_IN_PROLOG = 15
7342: XML_ERR_ENTITYREF_IN_EPILOG = 16
7343: XML_ERR_ENTITYREF_IN_DTD = 17
7344: XML_ERR_PEREF_AT_EOF = 18
7345: XML_ERR_PEREF_IN_PROLOG = 19
7346: XML_ERR_PEREF_IN_EPILOG = 20
7347: XML_ERR_PEREF_IN_INT_SUBSET = 21
7348: XML_ERR_ENTITYREF_NO_NAME = 22
7349: XML_ERR_ENTITYREF_SEMICOL_MISSING = 23
7350: XML_ERR_PEREF_NO_NAME = 24
7351: XML_ERR_PEREF_SEMICOL_MISSING = 25
7352: XML_ERR_UNDECLARED_ENTITY = 26
7353: XML_WAR_UNDECLARED_ENTITY = 27
7354: XML_ERR_UNPARSED_ENTITY = 28
7355: XML_ERR_ENTITY_IS_EXTERNAL = 29
7356: XML_ERR_ENTITY_IS_PARAMETER = 30
7357: XML_ERR_UNKNOWN_ENCODING = 31
7358: XML_ERR_UNSUPPORTED_ENCODING = 32
7359: XML_ERR_STRING_NOT_STARTED = 33
7360: XML_ERR_STRING_NOT_CLOSED = 34
7361: XML_ERR_NS_DECL_ERROR = 35
7362: XML_ERR_ENTITY_NOT_STARTED = 36
7363: XML_ERR_ENTITY_NOT_FINISHED = 37
7364: XML_ERR_LT_IN_ATTRIBUTE = 38
7365: XML_ERR_ATTRIBUTE_NOT_STARTED = 39
7366: XML_ERR_ATTRIBUTE_NOT_FINISHED = 40
7367: XML_ERR_ATTRIBUTE_WITHOUT_VALUE = 41
7368: XML_ERR_ATTRIBUTE_REDEFINED = 42
7369: XML_ERR_LITERAL_NOT_STARTED = 43
7370: XML_ERR_LITERAL_NOT_FINISHED = 44
7371: XML_ERR_COMMENT_NOT_FINISHED = 45
7372: XML_ERR_PI_NOT_STARTED = 46
7373: XML_ERR_PI_NOT_FINISHED = 47
7374: XML_ERR_NOTATION_NOT_STARTED = 48
7375: XML_ERR_NOTATION_NOT_FINISHED = 49
7376: XML_ERR_ATTLIST_NOT_STARTED = 50
7377: XML_ERR_ATTLIST_NOT_FINISHED = 51
7378: XML_ERR_MIXED_NOT_STARTED = 52
7379: XML_ERR_MIXED_NOT_FINISHED = 53
7380: XML_ERR_ELEMCONTENT_NOT_STARTED = 54
7381: XML_ERR_ELEMCONTENT_NOT_FINISHED = 55
7382: XML_ERR_XMLDECL_NOT_STARTED = 56
7383: XML_ERR_XMLDECL_NOT_FINISHED = 57
7384: XML_ERR_CONDSEC_NOT_STARTED = 58
7385: XML_ERR_CONDSEC_NOT_FINISHED = 59
7386: XML_ERR_EXT_SUBSET_NOT_FINISHED = 60
7387: XML_ERR_DOCTYPE_NOT_FINISHED = 61
7388: XML_ERR_MISPLACED_CDATA_END = 62
7389: XML_ERR_CDATA_NOT_FINISHED = 63
7390: XML_ERR_RESERVED_XML_NAME = 64
7391: XML_ERR_SPACE_REQUIRED = 65
7392: XML_ERR_SEPARATOR_REQUIRED = 66
7393: XML_ERR_NMTOKEN_REQUIRED = 67
7394: XML_ERR_NAME_REQUIRED = 68
7395: XML_ERR_PCDATA_REQUIRED = 69
7396: XML_ERR_URI_REQUIRED = 70
7397: XML_ERR_PUBID_REQUIRED = 71
7398: XML_ERR_LT_REQUIRED = 72
7399: XML_ERR_GT_REQUIRED = 73
7400: XML_ERR_LTSLASH_REQUIRED = 74
7401: XML_ERR_EQUAL_REQUIRED = 75
7402: XML_ERR_TAG_NAME_MISMATCH = 76
7403: XML_ERR_TAG_NOT_FINISHED = 77
7404: XML_ERR_STANDALONE_VALUE = 78
7405: XML_ERR_ENCODING_NAME = 79
7406: XML_ERR_HYPHEN_IN_COMMENT = 80
7407: XML_ERR_INVALID_ENCODING = 81
7408: XML_ERR_EXT_ENTITY_STANDALONE = 82
7409: XML_ERR_CONDSEC_INVALID = 83
7410: XML_ERR_VALUE_REQUIRED = 84
7411: XML_ERR_NOT_WELL_BALANCED = 85
7412: XML_ERR_EXTRA_CONTENT = 86
7413: XML_ERR_ENTITY_CHAR_ERROR = 87
7414: XML_ERR_ENTITY_PE_INTERNAL = 88
7415: XML_ERR_ENTITY_LOOP = 89
7416: XML_ERR_ENTITY_BOUNDARY = 90
7417: XML_ERR_INVALID_URI = 91
7418: XML_ERR_URI_FRAGMENT = 92
7419: XML_WAR_CATALOG_PI = 93
7420: XML_ERR_NO_DTD = 94
7421: XML_ERR_CONDSEC_INVALID_KEYWORD = 95
7422: XML_ERR_VERSION_MISSING = 96
7423: XML_WAR_UNKNOWN_VERSION = 97
7424: XML_WAR_LANG_VALUE = 98
7425: XML_WAR_NS_URI = 99
7426: XML_WAR_NS_URI_RELATIVE = 100
7427: XML_ERR_MISSING_ENCODING = 101
7428: XML_WAR_SPACE_VALUE = 102
7429: XML_ERR_NOT_STANDALONE = 103
7430: XML_ERR_ENTITY_PROCESSING = 104
7431: XML_ERR_NOTATION_PROCESSING = 105
7432: XML_WAR_NS_COLUMN = 106
7433: XML_WAR_ENTITY_REDEFINED = 107
7434: XML_ERR_UNKNOWN_VERSION = 108
7435: XML_ERR_VERSION_MISMATCH = 109
7436: XML_ERR_NAME_TOO_LONG = 110
7437: XML_ERR_USER_STOP = 111
7438: XML_NS_ERR_XML_NAMESPACE = 200
7439: XML_NS_ERR_UNDEFINED_NAMESPACE = 201
7440: XML_NS_ERR_QNAME = 202
7441: XML_NS_ERR_ATTRIBUTE_REDEFINED = 203
7442: XML_NS_ERR_EMPTY = 204
7443: XML_NS_ERR_COLON = 205
7444: XML_DTD_ATTRIBUTE_DEFAULT = 500
7445: XML_DTD_ATTRIBUTE_REDEFINED = 501
7446: XML_DTD_ATTRIBUTE_VALUE = 502
7447: XML_DTD_CONTENT_ERROR = 503
7448: XML_DTD_CONTENT_MODEL = 504
7449: XML_DTD_CONTENT_NOT_DETERMINIST = 505
7450: XML_DTD_DIFFERENT_PREFIX = 506
7451: XML_DTD_ELEM_DEFAULT_NAMESPACE = 507
7452: XML_DTD_ELEM_NAMESPACE = 508
7453: XML_DTD_ELEM_REDEFINED = 509
7454: XML_DTD_EMPTY_NOTATION = 510
7455: XML_DTD_ENTITY_TYPE = 511
7456: XML_DTD_ID_FIXED = 512
7457: XML_DTD_ID_REDEFINED = 513
7458: XML_DTD_ID_SUBSET = 514
7459: XML_DTD_INVALID_CHILD = 515
7460: XML_DTD_INVALID_DEFAULT = 516
7461: XML_DTD_LOAD_ERROR = 517
7462: XML_DTD_MISSING_ATTRIBUTE = 518
7463: XML_DTD_MIXED_CORRUPT = 519
7464: XML_DTD_MULTIPLE_ID = 520
7465: XML_DTD_NO_DOC = 521
7466: XML_DTD_NO_DTD = 522
7467: XML_DTD_NO_ELEM_NAME = 523
7468: XML_DTD_NO_PREFIX = 524
7469: XML_DTD_NO_ROOT = 525
7470: XML_DTD_NOTATION_REDEFINED = 526
7471: XML_DTD_NOTATION_VALUE = 527
7472: XML_DTD_NOT_EMPTY = 528
7473: XML_DTD_NOT_PCDATA = 529
7474: XML_DTD_NOT_STANDALONE = 530
7475: XML_DTD_ROOT_NAME = 531
7476: XML_DTD_STANDALONE_WHITE_SPACE = 532
7477: XML_DTD_UNKNOWN_ATTRIBUTE = 533
7478: XML_DTD_UNKNOWN_ELEM = 534
7479: XML_DTD_UNKNOWN_ENTITY = 535
7480: XML_DTD_UNKNOWN_ID = 536
7481: XML_DTD_UNKNOWN_NOTATION = 537
7482: XML_DTD_STANDALONE_DEFAULTED = 538
7483: XML_DTD_XMLID_VALUE = 539
7484: XML_DTD_XMLID_TYPE = 540
7485: XML_DTD_DUP_TOKEN = 541
7486: XML_HTML_STRUCURE_ERROR = 800
7487: XML_HTML_UNKNOWN_TAG = 801
7488: XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000
7489: XML_RNGP_ATTR_CONFLICT = 1001
7490: XML_RNGP_ATTRIBUTE_CHILDREN = 1002
7491: XML_RNGP_ATTRIBUTE_CONTENT = 1003
7492: XML_RNGP_ATTRIBUTE_EMPTY = 1004
7493: XML_RNGP_ATTRIBUTE_NOOP = 1005
7494: XML_RNGP_CHOICE_CONTENT = 1006
7495: XML_RNGP_CHOICE_EMPTY = 1007
7496: XML_RNGP_CREATE_FAILURE = 1008
7497: XML_RNGP_DATA_CONTENT = 1009
7498: XML_RNGP_DEF_CHOICE_AND_INTERLEAVE = 1010
7499: XML_RNGP_DEFINE_CREATE_FAILED = 1011
7500: XML_RNGP_DEFINE_EMPTY = 1012
7501: XML_RNGP_DEFINE_MISSING = 1013
7502: XML_RNGP_DEFINE_NAME_MISSING = 1014
7503: XML_RNGP_ELEM_CONTENT_EMPTY = 1015
7504: XML_RNGP_ELEM_CONTENT_ERROR = 1016
7505: XML_RNGP_ELEMENT_EMPTY = 1017
7506: XML_RNGP_ELEMENT_CONTENT = 1018
7507: XML_RNGP_ELEMENT_NAME = 1019
7508: XML_RNGP_ELEMENT_NO_CONTENT = 1020
7509: XML_RNGP_ELEM_TEXT_CONFLICT = 1021
7510: XML_RNGP_EMPTY = 1022
7511: XML_RNGP_EMPTY_CONSTRUCT = 1023
7512: XML_RNGP_EMPTY_CONTENT = 1024
7513: XML_RNGP_EMPTY_NOT_EMPTY = 1025
7514: XML_RNGP_ERROR_TYPE_LIB = 1026
7515: XML_RNGP_EXCEPT_EMPTY = 1027
7516: XML_RNGP_EXCEPT_MISSING = 1028
7517: XML_RNGP_EXCEPT_MULTIPLE = 1029
7518: XML_RNGP_EXCEPT_NO_CONTENT = 1030
7519: XML_RNGP_EXTERNALREF_EMTPY = 1031
7520: XML_RNGP_EXTERNAL_REF_FAILURE = 1032
7521: XML_RNGP_EXTERNALREF_RECURSE = 1033
7522: XML_RNGP_FORBIDDEN_ATTRIBUTE = 1034
7523: XML_RNGP_FOREIGN_ELEMENT = 1035
7524: XML_RNGP_GRAMMAR_CONTENT = 1036
7525: XML_RNGP_GRAMMAR_EMPTY = 1037
7526: XML_RNGP_GRAMMAR_MISSING = 1038
7527: XML_RNGP_GRAMMAR_NO_START = 1039
7528: XML_RNGP_GROUP_ATTR_CONFLICT = 1040
7529: XML_RNGP_HREF_ERROR = 1041
7530: XML_RNGP_INCLUDE_EMPTY = 1042
7531: XML_RNGP_INCLUDE_FAILURE = 1043
7532: XML_RNGP_INCLUDE_RECURSE = 1044
7533: XML_RNGP_INTERLEAVE_ADD = 1045
7534: XML_RNGP_INTERLEAVE_CREATE_FAILED = 1046
7535: XML_RNGP_INTERLEAVE_EMPTY = 1047
7536: XML_RNGP_INTERLEAVE_NO_CONTENT = 1048
7537: XML_RNGP_INVALID_DEFINE_NAME = 1049
7538: XML_RNGP_INVALID_URI = 1050
7539: XML_RNGP_INVALID_VALUE = 1051
7540: XML_RNGP_MISSING_HREF = 1052
7541: XML_RNGP_NAME_MISSING = 1053
7542: XML_RNGP_NEED_COMBINE = 1054
7543: XML_RNGP_NOTALLOWED_NOT_EMPTY = 1055
7544: XML_RNGP_NSNAME_ATTR_ANCESTOR = 1056
7545: XML_RNGP_NSNAME_NO_NS = 1057
7546: XML_RNGP_PARAM_FORBIDDEN = 1058
7547: XML_RNGP_PARAM_NAME_MISSING = 1059
7548: XML_RNGP_PARENTREF_CREATE_FAILED = 1060
7549: XML_RNGP_PARENTREF_NAME_INVALID = 1061
7550: XML_RNGP_PARENTREF_NO_NAME = 1062
7551: XML_RNGP_PARENTREF_NO_PARENT = 1063
7552: XML_RNGP_PARENTREF_NOT_EMPTY = 1064
7553: XML_RNGP_PARSE_ERROR = 1065
7554: XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME = 1066
7555: XML_RNGP_PAT_ATTR_ATTR = 1067
7556: XML_RNGP_PAT_ATTR_ELEM = 1068
7557: XML_RNGP_PAT_DATA_EXCEPT_ATTR = 1069
7558: XML_RNGP_PAT_DATA_EXCEPT_ELEM = 1070
7559: XML_RNGP_PAT_DATA_EXCEPT_EMPTY = 1071
7560: XML_RNGP_PAT_DATA_EXCEPT_GROUP = 1072
7561: XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE = 1073
7562: XML_RNGP_PAT_DATA_EXCEPT_LIST = 1074
7563: XML_RNGP_PAT_DATA_EXCEPT_ONEMORE = 1075
7564: XML_RNGP_PAT_DATA_EXCEPT_REF = 1076
7565: XML_RNGP_PAT_DATA_EXCEPT_TEXT = 1077
7566: XML_RNGP_PAT_LIST_ATTR = 1078
7567: XML_RNGP_PAT_LIST_ELEM = 1079
7568: XML_RNGP_PAT_LIST_INTERLEAVE = 1080
7569: XML_RNGP_PAT_LIST_LIST = 1081
7570: XML_RNGP_PAT_LIST_REF = 1082
7571: XML_RNGP_PAT_LIST_TEXT = 1083
7572: XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME = 1084
7573: XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME = 1085
7574: XML_RNGP_PAT_ONEMORE_GROUP_ATTR = 1086
7575: XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR = 1087
7576: XML_RNGP_PAT_START_ATTR = 1088
7577: XML_RNGP_PAT_START_DATA = 1089
7578: XML_RNGP_PAT_START_EMPTY = 1090
7579: XML_RNGP_PAT_START_GROUP = 1091
7580: XML_RNGP_PAT_START_INTERLEAVE = 1092
7581: XML_RNGP_PAT_START_LIST = 1093
7582: XML_RNGP_PAT_START_ONEMORE = 1094
7583: XML_RNGP_PAT_START_TEXT = 1095
7584: XML_RNGP_PAT_START_VALUE = 1096
7585: XML_RNGP_PREFIX_UNDEFINED = 1097
7586: XML_RNGP_REF_CREATE_FAILED = 1098
7587: XML_RNGP_REF_CYCLE = 1099
7588: XML_RNGP_REF_NAME_INVALID = 1100
7589: XML_RNGP_REF_NO_DEF = 1101
7590: XML_RNGP_REF_NO_NAME = 1102
7591: XML_RNGP_REF_NOT_EMPTY = 1103
7592: XML_RNGP_START_CHOICE_AND_INTERLEAVE = 1104
7593: XML_RNGP_START_CONTENT = 1105
7594: XML_RNGP_START_EMPTY = 1106
7595: XML_RNGP_START_MISSING = 1107
7596: XML_RNGP_TEXT_EXPECTED = 1108
7597: XML_RNGP_TEXT_HAS_CHILD = 1109
7598: XML_RNGP_TYPE_MISSING = 1110
7599: XML_RNGP_TYPE_NOT_FOUND = 1111
7600: XML_RNGP_TYPE_VALUE = 1112
7601: XML_RNGP_UNKNOWN_ATTRIBUTE = 1113
7602: XML_RNGP_UNKNOWN_COMBINE = 1114
7603: XML_RNGP_UNKNOWN_CONSTRUCT = 1115
7604: XML_RNGP_UNKNOWN_TYPE_LIB = 1116
7605: XML_RNGP_URI_FRAGMENT = 1117
7606: XML_RNGP_URI_NOT_ABSOLUTE = 1118
7607: XML_RNGP_VALUE_EMPTY = 1119
7608: XML_RNGP_VALUE_NO_CONTENT = 1120
7609: XML_RNGP_XMLNS_NAME = 1121
7610: XML_RNGP_XML_NS = 1122
7611: XML_XPATH_EXPRESSION_OK = 1200
7612: XML_XPATH_NUMBER_ERROR = 1201
7613: XML_XPATH_UNFINISHED_LITERAL_ERROR = 1202
7614: XML_XPATH_START_LITERAL_ERROR = 1203
7615: XML_XPATH_VARIABLE_REF_ERROR = 1204
7616: XML_XPATH_UNDEF_VARIABLE_ERROR = 1205
7617: XML_XPATH_INVALID_PREDICATE_ERROR = 1206
7618: XML_XPATH_EXPR_ERROR = 1207
7619: XML_XPATH_UNCLOSED_ERROR = 1208
7620: XML_XPATH_UNKNOWN_FUNC_ERROR = 1209
7621: XML_XPATH_INVALID_OPERAND = 1210
7622: XML_XPATH_INVALID_TYPE = 1211
7623: XML_XPATH_INVALID_ARITY = 1212
7624: XML_XPATH_INVALID_CTXT_SIZE = 1213
7625: XML_XPATH_INVALID_CTXT_POSITION = 1214
7626: XML_XPATH_MEMORY_ERROR = 1215
7627: XML_XPTR_SYNTAX_ERROR = 1216
7628: XML_XPTR_RESOURCE_ERROR = 1217
7629: XML_XPTR_SUB_RESOURCE_ERROR = 1218
7630: XML_XPATH_UNDEF_PREFIX_ERROR = 1219
7631: XML_XPATH_ENCODING_ERROR = 1220
7632: XML_XPATH_INVALID_CHAR_ERROR = 1221
7633: XML_TREE_INVALID_HEX = 1300
7634: XML_TREE_INVALID_DEC = 1301
7635: XML_TREE_UNTERMINATED_ENTITY = 1302
7636: XML_TREE_NOT_UTF8 = 1303
7637: XML_SAVE_NOT_UTF8 = 1400
7638: XML_SAVE_CHAR_INVALID = 1401
7639: XML_SAVE_NO_DOCTYPE = 1402
7640: XML_SAVE_UNKNOWN_ENCODING = 1403
7641: XML_REGEXP_COMPILE_ERROR = 1450
7642: XML_IO_UNKNOWN = 1500
7643: XML_IO_EACCES = 1501
7644: XML_IO_EAGAIN = 1502
7645: XML_IO_EBADF = 1503
7646: XML_IO_EBADMSG = 1504
7647: XML_IO_EBUSY = 1505
7648: XML_IO_ECANCELED = 1506
7649: XML_IO_ECHILD = 1507
7650: XML_IO_EDEADLK = 1508
7651: XML_IO_EDOM = 1509
7652: XML_IO_EEXIST = 1510
7653: XML_IO_EFAULT = 1511
7654: XML_IO_EFBIG = 1512
7655: XML_IO_EINPROGRESS = 1513
7656: XML_IO_EINTR = 1514
7657: XML_IO_EINVAL = 1515
7658: XML_IO_EIO = 1516
7659: XML_IO_EISDIR = 1517
7660: XML_IO_EMFILE = 1518
7661: XML_IO_EMLINK = 1519
7662: XML_IO_EMSGSIZE = 1520
7663: XML_IO_ENAMETOOLONG = 1521
7664: XML_IO_ENFILE = 1522
7665: XML_IO_ENODEV = 1523
7666: XML_IO_ENOENT = 1524
7667: XML_IO_ENOEXEC = 1525
7668: XML_IO_ENOLCK = 1526
7669: XML_IO_ENOMEM = 1527
7670: XML_IO_ENOSPC = 1528
7671: XML_IO_ENOSYS = 1529
7672: XML_IO_ENOTDIR = 1530
7673: XML_IO_ENOTEMPTY = 1531
7674: XML_IO_ENOTSUP = 1532
7675: XML_IO_ENOTTY = 1533
7676: XML_IO_ENXIO = 1534
7677: XML_IO_EPERM = 1535
7678: XML_IO_EPIPE = 1536
7679: XML_IO_ERANGE = 1537
7680: XML_IO_EROFS = 1538
7681: XML_IO_ESPIPE = 1539
7682: XML_IO_ESRCH = 1540
7683: XML_IO_ETIMEDOUT = 1541
7684: XML_IO_EXDEV = 1542
7685: XML_IO_NETWORK_ATTEMPT = 1543
7686: XML_IO_ENCODER = 1544
7687: XML_IO_FLUSH = 1545
7688: XML_IO_WRITE = 1546
7689: XML_IO_NO_INPUT = 1547
7690: XML_IO_BUFFER_FULL = 1548
7691: XML_IO_LOAD_ERROR = 1549
7692: XML_IO_ENOTSOCK = 1550
7693: XML_IO_EISCONN = 1551
7694: XML_IO_ECONNREFUSED = 1552
7695: XML_IO_ENETUNREACH = 1553
7696: XML_IO_EADDRINUSE = 1554
7697: XML_IO_EALREADY = 1555
7698: XML_IO_EAFNOSUPPORT = 1556
7699: XML_XINCLUDE_RECURSION = 1600
7700: XML_XINCLUDE_PARSE_VALUE = 1601
7701: XML_XINCLUDE_ENTITY_DEF_MISMATCH = 1602
7702: XML_XINCLUDE_NO_HREF = 1603
7703: XML_XINCLUDE_NO_FALLBACK = 1604
7704: XML_XINCLUDE_HREF_URI = 1605
7705: XML_XINCLUDE_TEXT_FRAGMENT = 1606
7706: XML_XINCLUDE_TEXT_DOCUMENT = 1607
7707: XML_XINCLUDE_INVALID_CHAR = 1608
7708: XML_XINCLUDE_BUILD_FAILED = 1609
7709: XML_XINCLUDE_UNKNOWN_ENCODING = 1610
7710: XML_XINCLUDE_MULTIPLE_ROOT = 1611
7711: XML_XINCLUDE_XPTR_FAILED = 1612
7712: XML_XINCLUDE_XPTR_RESULT = 1613
7713: XML_XINCLUDE_INCLUDE_IN_INCLUDE = 1614
7714: XML_XINCLUDE_FALLBACKS_IN_INCLUDE = 1615
7715: XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE = 1616
7716: XML_XINCLUDE_DEPRECATED_NS = 1617
7717: XML_XINCLUDE_FRAGMENT_ID = 1618
7718: XML_CATALOG_MISSING_ATTR = 1650
7719: XML_CATALOG_ENTRY_BROKEN = 1651
7720: XML_CATALOG_PREFER_VALUE = 1652
7721: XML_CATALOG_NOT_CATALOG = 1653
7722: XML_CATALOG_RECURSION = 1654
7723: XML_SCHEMAP_PREFIX_UNDEFINED = 1700
7724: XML_SCHEMAP_ATTRFORMDEFAULT_VALUE = 1701
7725: XML_SCHEMAP_ATTRGRP_NONAME_NOREF = 1702
7726: XML_SCHEMAP_ATTR_NONAME_NOREF = 1703
7727: XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF = 1704
7728: XML_SCHEMAP_ELEMFORMDEFAULT_VALUE = 1705
7729: XML_SCHEMAP_ELEM_NONAME_NOREF = 1706
7730: XML_SCHEMAP_EXTENSION_NO_BASE = 1707
7731: XML_SCHEMAP_FACET_NO_VALUE = 1708
7732: XML_SCHEMAP_FAILED_BUILD_IMPORT = 1709
7733: XML_SCHEMAP_GROUP_NONAME_NOREF = 1710
7734: XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI = 1711
7735: XML_SCHEMAP_IMPORT_REDEFINE_NSNAME = 1712
7736: XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI = 1713
7737: XML_SCHEMAP_INVALID_BOOLEAN = 1714
7738: XML_SCHEMAP_INVALID_ENUM = 1715
7739: XML_SCHEMAP_INVALID_FACET = 1716
7740: XML_SCHEMAP_INVALID_FACET_VALUE = 1717
7741: XML_SCHEMAP_INVALID_MAXOCCURS = 1718
7742: XML_SCHEMAP_INVALID_MINOCCURS = 1719
7743: XML_SCHEMAP_INVALID_REF_AND_SUBTYPE = 1720
7744: XML_SCHEMAP_INVALID_WHITE_SPACE = 1721
7745: XML_SCHEMAP_NOATTR_NOREF = 1722
7746: XML_SCHEMAP_NOTATION_NO_NAME = 1723
7747: XML_SCHEMAP_NOTYPE_NOREF = 1724
7748: XML_SCHEMAP_REF_AND_SUBTYPE = 1725
7749: XML_SCHEMAP_RESTRICTION_NONAME_NOREF = 1726
7750: XML_SCHEMAP_SIMPLETYPE_NONAME = 1727
7751: XML_SCHEMAP_TYPE_AND_SUBTYPE = 1728
7752: XML_SCHEMAP_UNKNOWN_ALL_CHILD = 1729
7753: XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD = 1730
7754: XML_SCHEMAP_UNKNOWN_ATTR_CHILD = 1731
7755: XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD = 1732
7756: XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP = 1733
7757: XML_SCHEMAP_UNKNOWN_BASE_TYPE = 1734
7758: XML_SCHEMAP_UNKNOWN_CHOICE_CHILD = 1735
7759: XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD = 1736
7760: XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD = 1737
7761: XML_SCHEMAP_UNKNOWN_ELEM_CHILD = 1738
7762: XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD = 1739
7763: XML_SCHEMAP_UNKNOWN_FACET_CHILD = 1740
7764: XML_SCHEMAP_UNKNOWN_FACET_TYPE = 1741
7765: XML_SCHEMAP_UNKNOWN_GROUP_CHILD = 1742
7766: XML_SCHEMAP_UNKNOWN_IMPORT_CHILD = 1743
7767: XML_SCHEMAP_UNKNOWN_LIST_CHILD = 1744
7768: XML_SCHEMAP_UNKNOWN_NOTATION_CHILD = 1745
7769: XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD = 1746
7770: XML_SCHEMAP_UNKNOWN_REF = 1747
7771: XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD = 1748
7772: XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD = 1749
7773: XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD = 1750
7774: XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD = 1751
7775: XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD = 1752
7776: XML_SCHEMAP_UNKNOWN_TYPE = 1753
7777: XML_SCHEMAP_UNKNOWN_UNION_CHILD = 1754
7778: XML_SCHEMAP_ELEM_DEFAULT_FIXED = 1755
7779: XML_SCHEMAP_REGEXP_INVALID = 1756
7780: XML_SCHEMAP_FAILED_LOAD = 1757
7781: XML_SCHEMAP_NOTHING_TO_PARSE = 1758
7782: XML_SCHEMAP_NOROOT = 1759
7783: XML_SCHEMAP_REDEFINED_GROUP = 1760
7784: XML_SCHEMAP_REDEFINED_TYPE = 1761
7785: XML_SCHEMAP_REDEFINED_ELEMENT = 1762
7786: XML_SCHEMAP_REDEFINED_ATTRGROUP = 1763
7787: XML_SCHEMAP_REDEFINED_ATTR = 1764
7788: XML_SCHEMAP_REDEFINED_NOTATION = 1765
7789: XML_SCHEMAP_FAILED_PARSE = 1766
7790: XML_SCHEMAP_UNKNOWN_PREFIX = 1767
7791: XML_SCHEMAP_DEF_AND_PREFIX = 1768
7792: XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD = 1769
7793: XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI = 1770
7794: XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI = 1771
7795: XML_SCHEMAP_NOT_SCHEMA = 1772
7796: XML_SCHEMAP_UNKNOWN_MEMBER_TYPE = 1773
7797: XML_SCHEMAP_INVALID_ATTR_USE = 1774
7798: XML_SCHEMAP_RECURSIVE = 1775
7799: XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE = 1776
7800: XML_SCHEMAP_INVALID_ATTR_COMBINATION = 1777
7801: XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION = 1778
7802: XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD = 1779
7803: XML_SCHEMAP_INVALID_ATTR_NAME = 1780
7804: XML_SCHEMAP_REF_AND_CONTENT = 1781
7805: XML_SCHEMAP_CT_PROPS_CORRECT_1 = 1782
7806: XML_SCHEMAP_CT_PROPS_CORRECT_2 = 1783
7807: XML_SCHEMAP_CT_PROPS_CORRECT_3 = 1784
7808: XML_SCHEMAP_CT_PROPS_CORRECT_4 = 1785
7809: XML_SCHEMAP_CT_PROPS_CORRECT_5 = 1786
7810: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1 = 1787
7811: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1 = 1788
7812: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2 = 1789
7813: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2 = 1790
7814: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3 = 1791
7815: XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER = 1792
7816: XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE = 1793
7817: XML_SCHEMAP_UNION_NOT_EXPRESSIBLE = 1794
7818: XML_SCHEMAP_SRC_IMPORT_3_1 = 1795
7819: XML_SCHEMAP_SRC_IMPORT_3_2 = 1796
7820: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1 = 1797
7821: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2 = 1798
7822: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3 = 1799
7823: XML_SCHEMAP_COS_CT_EXTENDS_1_3 = 1800
7824: XML_SCHEMAV_NOROOT = 1801
7825: XML_SCHEMAV_UNDECLAREDELEM = 1802
7826: XML_SCHEMAV_NOTTOPLEVEL = 1803
7827: XML_SCHEMAV_MISSING = 1804
7828: XML_SCHEMAV_WRONGELEM = 1805
7829: XML_SCHEMAV_NOTYPE = 1806
7830: XML_SCHEMAV_NOROLLBACK = 1807
7831: XML_SCHEMAV_ISABSTRACT = 1808
7832: XML_SCHEMAV_NOTEMPTY = 1809
7833: XML_SCHEMAV_ELEMCONT = 1810
7834: XML_SCHEMAV_HAVEDEFAULT = 1811
7835: XML_SCHEMAV_NOTNILLABLE = 1812
7836: XML_SCHEMAV_EXTRACONTENT = 1813
7837: XML_SCHEMAV_INVALIDATTR = 1814
7838: XML_SCHEMAV_INVALIDELEM = 1815
7839: XML_SCHEMAV_NOTDETERMINIST = 1816
7840: XML_SCHEMAV_CONSTRUCT = 1817
7841: XML_SCHEMAV_INTERNAL = 1818
7842: XML_SCHEMAV_NOTSIMPLE = 1819
7843: XML_SCHEMAV_ATTRUNKNOWN = 1820
7844: XML_SCHEMAV_ATTRINVALID = 1821
7845: XML_SCHEMAV_VALUE = 1822
7846: XML_SCHEMAV_FACET = 1823
7847: XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1 = 1824
7848: XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2 = 1825
7849: XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3 = 1826
7850: XML_SCHEMAV_CVC_TYPE_3_1_1 = 1827
7851: XML_SCHEMAV_CVC_TYPE_3_1_2 = 1828
7852: XML_SCHEMAV_CVC_FACET_VALID = 1829
7853: XML_SCHEMAV_CVC_LENGTH_VALID = 1830
7854: XML_SCHEMAV_CVC_MINLENGTH_VALID = 1831
7855: XML_SCHEMAV_CVC_MAXLENGTH_VALID = 1832
7856: XML_SCHEMAV_CVC_MININCLUSIVE_VALID = 1833
7857: XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID = 1834
7858: XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID = 1835
7859: XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID = 1836
7860: XML_SCHEMAV_CVC_TOTALDIGITS_VALID = 1837
7861: XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID = 1838
7862: XML_SCHEMAV_CVC_PATTERN_VALID = 1839
7863: XML_SCHEMAV_CVC_ENUMERATION_VALID = 1840
7864: XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1 = 1841
7865: XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2 = 1842
7866: XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3 = 1843
7867: XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4 = 1844
7868: XML_SCHEMAV_CVC_ELT_1 = 1845
7869: XML_SCHEMAV_CVC_ELT_2 = 1846
7870: XML_SCHEMAV_CVC_ELT_3_1 = 1847
7871: XML_SCHEMAV_CVC_ELT_3_2_1 = 1848
7872: XML_SCHEMAV_CVC_ELT_3_2_2 = 1849
7873: XML_SCHEMAV_CVC_ELT_4_1 = 1850
7874: XML_SCHEMAV_CVC_ELT_4_2 = 1851
7875: XML_SCHEMAV_CVC_ELT_4_3 = 1852
7876: XML_SCHEMAV_CVC_ELT_5_1_1 = 1853
7877: XML_SCHEMAV_CVC_ELT_5_1_2 = 1854
7878: XML_SCHEMAV_CVC_ELT_5_2_1 = 1855
7879: XML_SCHEMAV_CVC_ELT_5_2_2_1 = 1856
7880: XML_SCHEMAV_CVC_ELT_5_2_2_2_1 = 1857
7881: XML_SCHEMAV_CVC_ELT_5_2_2_2_2 = 1858
7882: XML_SCHEMAV_CVC_ELT_6 = 1859
7883: XML_SCHEMAV_CVC_ELT_7 = 1860
7884: XML_SCHEMAV_CVC_ATTRIBUTE_1 = 1861
7885: XML_SCHEMAV_CVC_ATTRIBUTE_2 = 1862
7886: XML_SCHEMAV_CVC_ATTRIBUTE_3 = 1863
7887: XML_SCHEMAV_CVC_ATTRIBUTE_4 = 1864
7888: XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1 = 1865
7889: XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1 = 1866
7890: XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2 = 1867
7891: XML_SCHEMAV_CVC_COMPLEX_TYPE_4 = 1868
7892: XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1 = 1869
7893: XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2 = 1870
7894: XML_SCHEMAV_ELEMENT_CONTENT = 1871
7895: XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING = 1872
7896: XML_SCHEMAV_CVC_COMPLEX_TYPE_1 = 1873
7897: XML_SCHEMAV_CVC_AU = 1874
7898: XML_SCHEMAV_CVC_TYPE_1 = 1875
7899: XML_SCHEMAV_CVC_TYPE_2 = 1876
7900: XML_SCHEMAV_CVC_IDC = 1877
7901: XML_SCHEMAV_CVC_WILDCARD = 1878
7902: XML_SCHEMAV_MISC = 1879
7903: XML_XPTR_UNKNOWN_SCHEME = 1900
7904: XML_XPTR_CHILDSEQ_START = 1901
7905: XML_XPTR_EVAL_FAILED = 1902
7906: XML_XPTR_EXTRA_OBJECTS = 1903
7907: XML_C14N_CREATE_CTXT = 1950
7908: XML_C14N_REQUIRES_UTF8 = 1951
7909: XML_C14N_CREATE_STACK = 1952
7910: XML_C14N_INVALID_NODE = 1953
7911: XML_C14N_UNKNOW_NODE = 1954
7912: XML_C14N_RELATIVE_NAMESPACE = 1955
7913: XML_FTP_PASV_ANSWER = 2000
7914: XML_FTP_EPSV_ANSWER = 2001
7915: XML_FTP_ACCNT = 2002
7916: XML_FTP_URL_SYNTAX = 2003
7917: XML_HTTP_URL_SYNTAX = 2020
7918: XML_HTTP_USE_IP = 2021
7919: XML_HTTP_UNKNOWN_HOST = 2022
7920: XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000
7921: XML_SCHEMAP_SRC_SIMPLE_TYPE_2 = 3001
7922: XML_SCHEMAP_SRC_SIMPLE_TYPE_3 = 3002
7923: XML_SCHEMAP_SRC_SIMPLE_TYPE_4 = 3003
7924: XML_SCHEMAP_SRC_RESOLVE = 3004
7925: XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE = 3005
7926: XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE = 3006
7927: XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES = 3007
7928: XML_SCHEMAP_ST_PROPS_CORRECT_1 = 3008
7929: XML_SCHEMAP_ST_PROPS_CORRECT_2 = 3009
7930: XML_SCHEMAP_ST_PROPS_CORRECT_3 = 3010
7931: XML_SCHEMAP_COS_ST_RESTRICTS_1_1 = 3011
7932: XML_SCHEMAP_COS_ST_RESTRICTS_1_2 = 3012
7933: XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1 = 3013
7934: XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2 = 3014
7935: XML_SCHEMAP_COS_ST_RESTRICTS_2_1 = 3015
7936: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1 = 3016
7937: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2 = 3017
7938: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1 = 3018
7939: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2 = 3019
7940: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3 = 3020
7941: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4 = 3021
7942: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5 = 3022
7943: XML_SCHEMAP_COS_ST_RESTRICTS_3_1 = 3023
7944: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1 = 3024
7945: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2 = 3025
7946: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2 = 3026
7947: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1 = 3027
7948: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3 = 3028
7949: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4 = 3029
7950: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5 = 3030
7951: XML_SCHEMAP_COS_ST_DERIVED_OK_2_1 = 3031
7952: XML_SCHEMAP_COS_ST_DERIVED_OK_2_2 = 3032
7953: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED = 3033
7954: XML_SCHEMAP_S4S_ELEM_MISSING = 3034
7955: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED = 3035
7956: XML_SCHEMAP_S4S_ATTR_MISSING = 3036
7957: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE = 3037
7958: XML_SCHEMAP_SRC_ELEMENT_1 = 3038
7959: XML_SCHEMAP_SRC_ELEMENT_2_1 = 3039
7960: XML_SCHEMAP_SRC_ELEMENT_2_2 = 3040
7961: XML_SCHEMAP_SRC_ELEMENT_3 = 3041
7962: XML_SCHEMAP_P_PROPS_CORRECT_1 = 3042
7963: XML_SCHEMAP_P_PROPS_CORRECT_2_1 = 3043
7964: XML_SCHEMAP_P_PROPS_CORRECT_2_2 = 3044
7965: XML_SCHEMAP_E_PROPS_CORRECT_2 = 3045
7966: XML_SCHEMAP_E_PROPS_CORRECT_3 = 3046
7967: XML_SCHEMAP_E_PROPS_CORRECT_4 = 3047
7968: XML_SCHEMAP_E_PROPS_CORRECT_5 = 3048
7969: XML_SCHEMAP_E_PROPS_CORRECT_6 = 3049
7970: XML_SCHEMAP_SRC_INCLUDE = 3050
7971: XML_SCHEMAP_SRC_ATTRIBUTE_1 = 3051
7972: XML_SCHEMAP_SRC_ATTRIBUTE_2 = 3052
7973: XML_SCHEMAP_SRC_ATTRIBUTE_3_1 = 3053
7974: XML_SCHEMAP_SRC_ATTRIBUTE_3_2 = 3054
7975: XML_SCHEMAP_SRC_ATTRIBUTE_4 = 3055
7976: XML_SCHEMAP_NO_XMLNS = 3056
7977: XML_SCHEMAP_NO_XSI = 3057
7978: XML_SCHEMAP_COS_VALID_DEFAULT_1 = 3058
7979: XML_SCHEMAP_COS_VALID_DEFAULT_2_1 = 3059
7980: XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1 = 3060
7981: XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2 = 3061
7982: XML_SCHEMAP_CVC_SIMPLE_TYPE = 3062
7983: XML_SCHEMAP_COS_CT_EXTENDS_1_1 = 3063
7984: XML_SCHEMAP_SRC_IMPORT_1_1 = 3064
7985: XML_SCHEMAP_SRC_IMPORT_1_2 = 3065
7986: XML_SCHEMAP_SRC_IMPORT_2 = 3066
7987: XML_SCHEMAP_SRC_IMPORT_2_1 = 3067
7988: XML_SCHEMAP_SRC_IMPORT_2_2 = 3068
7989: XML_SCHEMAP_INTERNAL = 3069
7990: XML_SCHEMAP_NOT_DETERMINISTIC = 3070
7991: XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1 = 3071
7992: XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2 = 3072
7993: XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3 = 3073
7994: XML_SCHEMAP_MG_PROPS_CORRECT_1 = 3074
7995: XML_SCHEMAP_MG_PROPS_CORRECT_2 = 3075
7996: XML_SCHEMAP_SRC_CT_1 = 3076
7997: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3 = 3077
7998: XML_SCHEMAP_AU_PROPS_CORRECT_2 = 3078
7999: XML_SCHEMAP_A_PROPS_CORRECT_2 = 3079
8000: XML_SCHEMAP_C_PROPS_CORRECT = 3080
8001: XML_SCHEMAP_SRC_REDEFINE = 3081
8002: XML_SCHEMAP_SRC_IMPORT = 3082
8003: XML_SCHEMAP_WARN_SKIP_SCHEMA = 3083
8004: XML_SCHEMAP_WARN_UNLOCATED_SCHEMA = 3084
8005: XML_SCHEMAP_WARN_ATTR_REDECL_PROH = 3085
8006: XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH = 3086
8007: XML_SCHEMAP_AG_PROPS_CORRECT = 3087
8008: XML_SCHEMAP_COS_CT_EXTENDS_1_2 = 3088
8009: XML_SCHEMAP_AU_PROPS_CORRECT = 3089
8010: XML_SCHEMAP_A_PROPS_CORRECT_3 = 3090
8011: XML_SCHEMAP_COS_ALL_LIMITED = 3091
8012: XML_SCHEMATRONV_ASSERT = 4000
8013: XML_SCHEMATRONV_REPORT = 4001
8014: XML_MODULE_OPEN = 4900
8015: XML_MODULE_CLOSE = 4901
8016: XML_CHECK_FOUND_ELEMENT = 5000
8017: XML_CHECK_FOUND_ATTRIBUTE = 5001
8018: XML_CHECK_FOUND_TEXT = 5002
8019: XML_CHECK_FOUND_CDATA = 5003
8020: XML_CHECK_FOUND_ENTITYREF = 5004
8021: XML_CHECK_FOUND_ENTITY = 5005
8022: XML_CHECK_FOUND_PI = 5006
8023: XML_CHECK_FOUND_COMMENT = 5007
8024: XML_CHECK_FOUND_DOCTYPE = 5008
8025: XML_CHECK_FOUND_FRAGMENT = 5009
8026: XML_CHECK_FOUND_NOTATION = 5010
8027: XML_CHECK_UNKNOWN_NODE = 5011
8028: XML_CHECK_ENTITY_TYPE = 5012
8029: XML_CHECK_NO_PARENT = 5013
8030: XML_CHECK_NO_DOC = 5014
8031: XML_CHECK_NO_NAME = 5015
8032: XML_CHECK_NO_ELEM = 5016
8033: XML_CHECK_WRONG_DOC = 5017
8034: XML_CHECK_NO_PREV = 5018
8035: XML_CHECK_WRONG_PREV = 5019
8036: XML_CHECK_NO_NEXT = 5020
8037: XML_CHECK_WRONG_NEXT = 5021
8038: XML_CHECK_NOT_DTD = 5022
8039: XML_CHECK_NOT_ATTR = 5023
8040: XML_CHECK_NOT_ATTR_DECL = 5024
8041: XML_CHECK_NOT_ELEM_DECL = 5025
8042: XML_CHECK_NOT_ENTITY_DECL = 5026
8043: XML_CHECK_NOT_NS_DECL = 5027
8044: XML_CHECK_NO_HREF = 5028
8045: XML_CHECK_WRONG_PARENT = 5029
8046: XML_CHECK_NS_SCOPE = 5030
8047: XML_CHECK_NS_ANCESTOR = 5031
8048: XML_CHECK_NOT_UTF8 = 5032
8049: XML_CHECK_NO_DICT = 5033
8050: XML_CHECK_NOT_NCNAME = 5034
8051: XML_CHECK_OUTSIDE_DICT = 5035
8052: XML_CHECK_WRONG_NAME = 5036
8053: XML_CHECK_NAME_NOT_NULL = 5037
8054: XML_I18N_NO_NAME = 6000
8055: XML_I18N_NO_HANDLER = 6001
8056: XML_I18N_EXCESS_HANDLER = 6002
8057: XML_I18N_CONV_FAILED = 6003
8058: XML_I18N_NO_OUTPUT = 6004
8059: XML_BUF_OVERFLOW = 7000
8060:
8061: # xmlExpNodeType
8062: XML_EXP_EMPTY = 0
8063: XML_EXP_FORBID = 1
8064: XML_EXP_ATOM = 2
8065: XML_EXP_SEQ = 3
8066: XML_EXP_OR = 4
8067: XML_EXP_COUNT = 5
8068:
8069: # xmlElementContentType
8070: XML_ELEMENT_CONTENT_PCDATA = 1
8071: XML_ELEMENT_CONTENT_ELEMENT = 2
8072: XML_ELEMENT_CONTENT_SEQ = 3
8073: XML_ELEMENT_CONTENT_OR = 4
8074:
8075: # xmlParserProperties
8076: XML_PARSER_LOADDTD = 1
8077: XML_PARSER_DEFAULTATTRS = 2
8078: XML_PARSER_VALIDATE = 3
8079: XML_PARSER_SUBST_ENTITIES = 4
8080:
8081: # xmlReaderTypes
8082: XML_READER_TYPE_NONE = 0
8083: XML_READER_TYPE_ELEMENT = 1
8084: XML_READER_TYPE_ATTRIBUTE = 2
8085: XML_READER_TYPE_TEXT = 3
8086: XML_READER_TYPE_CDATA = 4
8087: XML_READER_TYPE_ENTITY_REFERENCE = 5
8088: XML_READER_TYPE_ENTITY = 6
8089: XML_READER_TYPE_PROCESSING_INSTRUCTION = 7
8090: XML_READER_TYPE_COMMENT = 8
8091: XML_READER_TYPE_DOCUMENT = 9
8092: XML_READER_TYPE_DOCUMENT_TYPE = 10
8093: XML_READER_TYPE_DOCUMENT_FRAGMENT = 11
8094: XML_READER_TYPE_NOTATION = 12
8095: XML_READER_TYPE_WHITESPACE = 13
8096: XML_READER_TYPE_SIGNIFICANT_WHITESPACE = 14
8097: XML_READER_TYPE_END_ELEMENT = 15
8098: XML_READER_TYPE_END_ENTITY = 16
8099: XML_READER_TYPE_XML_DECLARATION = 17
8100:
8101: # xmlCatalogPrefer
8102: XML_CATA_PREFER_NONE = 0
8103: XML_CATA_PREFER_PUBLIC = 1
8104: XML_CATA_PREFER_SYSTEM = 2
8105:
8106: # xmlElementType
8107: XML_ELEMENT_NODE = 1
8108: XML_ATTRIBUTE_NODE = 2
8109: XML_TEXT_NODE = 3
8110: XML_CDATA_SECTION_NODE = 4
8111: XML_ENTITY_REF_NODE = 5
8112: XML_ENTITY_NODE = 6
8113: XML_PI_NODE = 7
8114: XML_COMMENT_NODE = 8
8115: XML_DOCUMENT_NODE = 9
8116: XML_DOCUMENT_TYPE_NODE = 10
8117: XML_DOCUMENT_FRAG_NODE = 11
8118: XML_NOTATION_NODE = 12
8119: XML_HTML_DOCUMENT_NODE = 13
8120: XML_DTD_NODE = 14
8121: XML_ELEMENT_DECL = 15
8122: XML_ATTRIBUTE_DECL = 16
8123: XML_ENTITY_DECL = 17
8124: XML_NAMESPACE_DECL = 18
8125: XML_XINCLUDE_START = 19
8126: XML_XINCLUDE_END = 20
8127: XML_DOCB_DOCUMENT_NODE = 21
8128:
8129: # xlinkActuate
8130: XLINK_ACTUATE_NONE = 0
8131: XLINK_ACTUATE_AUTO = 1
8132: XLINK_ACTUATE_ONREQUEST = 2
8133:
8134: # xmlFeature
8135: XML_WITH_THREAD = 1
8136: XML_WITH_TREE = 2
8137: XML_WITH_OUTPUT = 3
8138: XML_WITH_PUSH = 4
8139: XML_WITH_READER = 5
8140: XML_WITH_PATTERN = 6
8141: XML_WITH_WRITER = 7
8142: XML_WITH_SAX1 = 8
8143: XML_WITH_FTP = 9
8144: XML_WITH_HTTP = 10
8145: XML_WITH_VALID = 11
8146: XML_WITH_HTML = 12
8147: XML_WITH_LEGACY = 13
8148: XML_WITH_C14N = 14
8149: XML_WITH_CATALOG = 15
8150: XML_WITH_XPATH = 16
8151: XML_WITH_XPTR = 17
8152: XML_WITH_XINCLUDE = 18
8153: XML_WITH_ICONV = 19
8154: XML_WITH_ISO8859X = 20
8155: XML_WITH_UNICODE = 21
8156: XML_WITH_REGEXP = 22
8157: XML_WITH_AUTOMATA = 23
8158: XML_WITH_EXPR = 24
8159: XML_WITH_SCHEMAS = 25
8160: XML_WITH_SCHEMATRON = 26
8161: XML_WITH_MODULES = 27
8162: XML_WITH_DEBUG = 28
8163: XML_WITH_DEBUG_MEM = 29
8164: XML_WITH_DEBUG_RUN = 30
8165: XML_WITH_ZLIB = 31
8166: XML_WITH_ICU = 32
8167: XML_WITH_LZMA = 33
8168: XML_WITH_NONE = 99999
8169:
8170: # xmlElementContentOccur
8171: XML_ELEMENT_CONTENT_ONCE = 1
8172: XML_ELEMENT_CONTENT_OPT = 2
8173: XML_ELEMENT_CONTENT_MULT = 3
8174: XML_ELEMENT_CONTENT_PLUS = 4
8175:
8176: # xmlXPathError
8177: XPATH_EXPRESSION_OK = 0
8178: XPATH_NUMBER_ERROR = 1
8179: XPATH_UNFINISHED_LITERAL_ERROR = 2
8180: XPATH_START_LITERAL_ERROR = 3
8181: XPATH_VARIABLE_REF_ERROR = 4
8182: XPATH_UNDEF_VARIABLE_ERROR = 5
8183: XPATH_INVALID_PREDICATE_ERROR = 6
8184: XPATH_EXPR_ERROR = 7
8185: XPATH_UNCLOSED_ERROR = 8
8186: XPATH_UNKNOWN_FUNC_ERROR = 9
8187: XPATH_INVALID_OPERAND = 10
8188: XPATH_INVALID_TYPE = 11
8189: XPATH_INVALID_ARITY = 12
8190: XPATH_INVALID_CTXT_SIZE = 13
8191: XPATH_INVALID_CTXT_POSITION = 14
8192: XPATH_MEMORY_ERROR = 15
8193: XPTR_SYNTAX_ERROR = 16
8194: XPTR_RESOURCE_ERROR = 17
8195: XPTR_SUB_RESOURCE_ERROR = 18
8196: XPATH_UNDEF_PREFIX_ERROR = 19
8197: XPATH_ENCODING_ERROR = 20
8198: XPATH_INVALID_CHAR_ERROR = 21
8199: XPATH_INVALID_CTXT = 22
8200: XPATH_STACK_ERROR = 23
8201: XPATH_FORBID_VARIABLE_ERROR = 24
8202:
8203: # xmlTextReaderMode
8204: XML_TEXTREADER_MODE_INITIAL = 0
8205: XML_TEXTREADER_MODE_INTERACTIVE = 1
8206: XML_TEXTREADER_MODE_ERROR = 2
8207: XML_TEXTREADER_MODE_EOF = 3
8208: XML_TEXTREADER_MODE_CLOSED = 4
8209: XML_TEXTREADER_MODE_READING = 5
8210:
8211: # xmlErrorLevel
8212: XML_ERR_NONE = 0
8213: XML_ERR_WARNING = 1
8214: XML_ERR_ERROR = 2
8215: XML_ERR_FATAL = 3
8216:
8217: # xmlCharEncoding
8218: XML_CHAR_ENCODING_ERROR = -1
8219: XML_CHAR_ENCODING_NONE = 0
8220: XML_CHAR_ENCODING_UTF8 = 1
8221: XML_CHAR_ENCODING_UTF16LE = 2
8222: XML_CHAR_ENCODING_UTF16BE = 3
8223: XML_CHAR_ENCODING_UCS4LE = 4
8224: XML_CHAR_ENCODING_UCS4BE = 5
8225: XML_CHAR_ENCODING_EBCDIC = 6
8226: XML_CHAR_ENCODING_UCS4_2143 = 7
8227: XML_CHAR_ENCODING_UCS4_3412 = 8
8228: XML_CHAR_ENCODING_UCS2 = 9
8229: XML_CHAR_ENCODING_8859_1 = 10
8230: XML_CHAR_ENCODING_8859_2 = 11
8231: XML_CHAR_ENCODING_8859_3 = 12
8232: XML_CHAR_ENCODING_8859_4 = 13
8233: XML_CHAR_ENCODING_8859_5 = 14
8234: XML_CHAR_ENCODING_8859_6 = 15
8235: XML_CHAR_ENCODING_8859_7 = 16
8236: XML_CHAR_ENCODING_8859_8 = 17
8237: XML_CHAR_ENCODING_8859_9 = 18
8238: XML_CHAR_ENCODING_2022_JP = 19
8239: XML_CHAR_ENCODING_SHIFT_JIS = 20
8240: XML_CHAR_ENCODING_EUC_JP = 21
8241: XML_CHAR_ENCODING_ASCII = 22
8242:
8243: # xmlErrorDomain
8244: XML_FROM_NONE = 0
8245: XML_FROM_PARSER = 1
8246: XML_FROM_TREE = 2
8247: XML_FROM_NAMESPACE = 3
8248: XML_FROM_DTD = 4
8249: XML_FROM_HTML = 5
8250: XML_FROM_MEMORY = 6
8251: XML_FROM_OUTPUT = 7
8252: XML_FROM_IO = 8
8253: XML_FROM_FTP = 9
8254: XML_FROM_HTTP = 10
8255: XML_FROM_XINCLUDE = 11
8256: XML_FROM_XPATH = 12
8257: XML_FROM_XPOINTER = 13
8258: XML_FROM_REGEXP = 14
8259: XML_FROM_DATATYPE = 15
8260: XML_FROM_SCHEMASP = 16
8261: XML_FROM_SCHEMASV = 17
8262: XML_FROM_RELAXNGP = 18
8263: XML_FROM_RELAXNGV = 19
8264: XML_FROM_CATALOG = 20
8265: XML_FROM_C14N = 21
8266: XML_FROM_XSLT = 22
8267: XML_FROM_VALID = 23
8268: XML_FROM_CHECK = 24
8269: XML_FROM_WRITER = 25
8270: XML_FROM_MODULE = 26
8271: XML_FROM_I18N = 27
8272: XML_FROM_SCHEMATRONV = 28
8273: XML_FROM_BUFFER = 29
8274: XML_FROM_URI = 30
8275:
8276: # htmlStatus
8277: HTML_NA = 0
8278: HTML_INVALID = 1
8279: HTML_DEPRECATED = 2
8280: HTML_VALID = 4
8281: HTML_REQUIRED = 12
8282:
8283: # xmlSchemaValidOption
8284: XML_SCHEMA_VAL_VC_I_CREATE = 1
8285:
8286: # xmlSchemaWhitespaceValueType
8287: XML_SCHEMA_WHITESPACE_UNKNOWN = 0
8288: XML_SCHEMA_WHITESPACE_PRESERVE = 1
8289: XML_SCHEMA_WHITESPACE_REPLACE = 2
8290: XML_SCHEMA_WHITESPACE_COLLAPSE = 3
8291:
8292: # htmlParserOption
8293: HTML_PARSE_RECOVER = 1
8294: HTML_PARSE_NODEFDTD = 4
8295: HTML_PARSE_NOERROR = 32
8296: HTML_PARSE_NOWARNING = 64
8297: HTML_PARSE_PEDANTIC = 128
8298: HTML_PARSE_NOBLANKS = 256
8299: HTML_PARSE_NONET = 2048
8300: HTML_PARSE_NOIMPLIED = 8192
8301: HTML_PARSE_COMPACT = 65536
8302: HTML_PARSE_IGNORE_ENC = 2097152
8303:
8304: # xmlRelaxNGValidErr
8305: XML_RELAXNG_OK = 0
8306: XML_RELAXNG_ERR_MEMORY = 1
8307: XML_RELAXNG_ERR_TYPE = 2
8308: XML_RELAXNG_ERR_TYPEVAL = 3
8309: XML_RELAXNG_ERR_DUPID = 4
8310: XML_RELAXNG_ERR_TYPECMP = 5
8311: XML_RELAXNG_ERR_NOSTATE = 6
8312: XML_RELAXNG_ERR_NODEFINE = 7
8313: XML_RELAXNG_ERR_LISTEXTRA = 8
8314: XML_RELAXNG_ERR_LISTEMPTY = 9
8315: XML_RELAXNG_ERR_INTERNODATA = 10
8316: XML_RELAXNG_ERR_INTERSEQ = 11
8317: XML_RELAXNG_ERR_INTEREXTRA = 12
8318: XML_RELAXNG_ERR_ELEMNAME = 13
8319: XML_RELAXNG_ERR_ATTRNAME = 14
8320: XML_RELAXNG_ERR_ELEMNONS = 15
8321: XML_RELAXNG_ERR_ATTRNONS = 16
8322: XML_RELAXNG_ERR_ELEMWRONGNS = 17
8323: XML_RELAXNG_ERR_ATTRWRONGNS = 18
8324: XML_RELAXNG_ERR_ELEMEXTRANS = 19
8325: XML_RELAXNG_ERR_ATTREXTRANS = 20
8326: XML_RELAXNG_ERR_ELEMNOTEMPTY = 21
8327: XML_RELAXNG_ERR_NOELEM = 22
8328: XML_RELAXNG_ERR_NOTELEM = 23
8329: XML_RELAXNG_ERR_ATTRVALID = 24
8330: XML_RELAXNG_ERR_CONTENTVALID = 25
8331: XML_RELAXNG_ERR_EXTRACONTENT = 26
8332: XML_RELAXNG_ERR_INVALIDATTR = 27
8333: XML_RELAXNG_ERR_DATAELEM = 28
8334: XML_RELAXNG_ERR_VALELEM = 29
8335: XML_RELAXNG_ERR_LISTELEM = 30
8336: XML_RELAXNG_ERR_DATATYPE = 31
8337: XML_RELAXNG_ERR_VALUE = 32
8338: XML_RELAXNG_ERR_LIST = 33
8339: XML_RELAXNG_ERR_NOGRAMMAR = 34
8340: XML_RELAXNG_ERR_EXTRADATA = 35
8341: XML_RELAXNG_ERR_LACKDATA = 36
8342: XML_RELAXNG_ERR_INTERNAL = 37
8343: XML_RELAXNG_ERR_ELEMWRONG = 38
8344: XML_RELAXNG_ERR_TEXTWRONG = 39
8345:
8346: # xmlCatalogAllow
8347: XML_CATA_ALLOW_NONE = 0
8348: XML_CATA_ALLOW_GLOBAL = 1
8349: XML_CATA_ALLOW_DOCUMENT = 2
8350: XML_CATA_ALLOW_ALL = 3
8351:
8352: # xmlAttributeType
8353: XML_ATTRIBUTE_CDATA = 1
8354: XML_ATTRIBUTE_ID = 2
8355: XML_ATTRIBUTE_IDREF = 3
8356: XML_ATTRIBUTE_IDREFS = 4
8357: XML_ATTRIBUTE_ENTITY = 5
8358: XML_ATTRIBUTE_ENTITIES = 6
8359: XML_ATTRIBUTE_NMTOKEN = 7
8360: XML_ATTRIBUTE_NMTOKENS = 8
8361: XML_ATTRIBUTE_ENUMERATION = 9
8362: XML_ATTRIBUTE_NOTATION = 10
8363:
8364: # xmlSchematronValidOptions
8365: XML_SCHEMATRON_OUT_QUIET = 1
8366: XML_SCHEMATRON_OUT_TEXT = 2
8367: XML_SCHEMATRON_OUT_XML = 4
8368: XML_SCHEMATRON_OUT_ERROR = 8
8369: XML_SCHEMATRON_OUT_FILE = 256
8370: XML_SCHEMATRON_OUT_BUFFER = 512
8371: XML_SCHEMATRON_OUT_IO = 1024
8372:
8373: # xmlSchemaContentType
8374: XML_SCHEMA_CONTENT_UNKNOWN = 0
8375: XML_SCHEMA_CONTENT_EMPTY = 1
8376: XML_SCHEMA_CONTENT_ELEMENTS = 2
8377: XML_SCHEMA_CONTENT_MIXED = 3
8378: XML_SCHEMA_CONTENT_SIMPLE = 4
8379: XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS = 5
8380: XML_SCHEMA_CONTENT_BASIC = 6
8381: XML_SCHEMA_CONTENT_ANY = 7
8382:
8383: # xmlSchemaTypeType
8384: XML_SCHEMA_TYPE_BASIC = 1
8385: XML_SCHEMA_TYPE_ANY = 2
8386: XML_SCHEMA_TYPE_FACET = 3
8387: XML_SCHEMA_TYPE_SIMPLE = 4
8388: XML_SCHEMA_TYPE_COMPLEX = 5
8389: XML_SCHEMA_TYPE_SEQUENCE = 6
8390: XML_SCHEMA_TYPE_CHOICE = 7
8391: XML_SCHEMA_TYPE_ALL = 8
8392: XML_SCHEMA_TYPE_SIMPLE_CONTENT = 9
8393: XML_SCHEMA_TYPE_COMPLEX_CONTENT = 10
8394: XML_SCHEMA_TYPE_UR = 11
8395: XML_SCHEMA_TYPE_RESTRICTION = 12
8396: XML_SCHEMA_TYPE_EXTENSION = 13
8397: XML_SCHEMA_TYPE_ELEMENT = 14
8398: XML_SCHEMA_TYPE_ATTRIBUTE = 15
8399: XML_SCHEMA_TYPE_ATTRIBUTEGROUP = 16
8400: XML_SCHEMA_TYPE_GROUP = 17
8401: XML_SCHEMA_TYPE_NOTATION = 18
8402: XML_SCHEMA_TYPE_LIST = 19
8403: XML_SCHEMA_TYPE_UNION = 20
8404: XML_SCHEMA_TYPE_ANY_ATTRIBUTE = 21
8405: XML_SCHEMA_TYPE_IDC_UNIQUE = 22
8406: XML_SCHEMA_TYPE_IDC_KEY = 23
8407: XML_SCHEMA_TYPE_IDC_KEYREF = 24
8408: XML_SCHEMA_TYPE_PARTICLE = 25
8409: XML_SCHEMA_TYPE_ATTRIBUTE_USE = 26
8410: XML_SCHEMA_FACET_MININCLUSIVE = 1000
8411: XML_SCHEMA_FACET_MINEXCLUSIVE = 1001
8412: XML_SCHEMA_FACET_MAXINCLUSIVE = 1002
8413: XML_SCHEMA_FACET_MAXEXCLUSIVE = 1003
8414: XML_SCHEMA_FACET_TOTALDIGITS = 1004
8415: XML_SCHEMA_FACET_FRACTIONDIGITS = 1005
8416: XML_SCHEMA_FACET_PATTERN = 1006
8417: XML_SCHEMA_FACET_ENUMERATION = 1007
8418: XML_SCHEMA_FACET_WHITESPACE = 1008
8419: XML_SCHEMA_FACET_LENGTH = 1009
8420: XML_SCHEMA_FACET_MAXLENGTH = 1010
8421: XML_SCHEMA_FACET_MINLENGTH = 1011
8422: XML_SCHEMA_EXTRA_QNAMEREF = 2000
8423: XML_SCHEMA_EXTRA_ATTR_USE_PROHIB = 2001
8424:
8425: # xmlModuleOption
8426: XML_MODULE_LAZY = 1
8427: XML_MODULE_LOCAL = 2
8428:
8429: # xmlParserMode
8430: XML_PARSE_UNKNOWN = 0
8431: XML_PARSE_DOM = 1
8432: XML_PARSE_SAX = 2
8433: XML_PARSE_PUSH_DOM = 3
8434: XML_PARSE_PUSH_SAX = 4
8435: XML_PARSE_READER = 5
8436:
8437: # xmlC14NMode
8438: XML_C14N_1_0 = 0
8439: XML_C14N_EXCLUSIVE_1_0 = 1
8440: XML_C14N_1_1 = 2
8441:
8442: # xmlParserOption
8443: XML_PARSE_RECOVER = 1
8444: XML_PARSE_NOENT = 2
8445: XML_PARSE_DTDLOAD = 4
8446: XML_PARSE_DTDATTR = 8
8447: XML_PARSE_DTDVALID = 16
8448: XML_PARSE_NOERROR = 32
8449: XML_PARSE_NOWARNING = 64
8450: XML_PARSE_PEDANTIC = 128
8451: XML_PARSE_NOBLANKS = 256
8452: XML_PARSE_SAX1 = 512
8453: XML_PARSE_XINCLUDE = 1024
8454: XML_PARSE_NONET = 2048
8455: XML_PARSE_NODICT = 4096
8456: XML_PARSE_NSCLEAN = 8192
8457: XML_PARSE_NOCDATA = 16384
8458: XML_PARSE_NOXINCNODE = 32768
8459: XML_PARSE_COMPACT = 65536
8460: XML_PARSE_OLD10 = 131072
8461: XML_PARSE_NOBASEFIX = 262144
8462: XML_PARSE_HUGE = 524288
8463: XML_PARSE_OLDSAX = 1048576
8464: XML_PARSE_IGNORE_ENC = 2097152
8465: XML_PARSE_BIG_LINES = 4194304
8466:
8467: # xmlElementTypeVal
8468: XML_ELEMENT_TYPE_UNDEFINED = 0
8469: XML_ELEMENT_TYPE_EMPTY = 1
8470: XML_ELEMENT_TYPE_ANY = 2
8471: XML_ELEMENT_TYPE_MIXED = 3
8472: XML_ELEMENT_TYPE_ELEMENT = 4
8473:
8474: # xmlDocProperties
8475: XML_DOC_WELLFORMED = 1
8476: XML_DOC_NSVALID = 2
8477: XML_DOC_OLD10 = 4
8478: XML_DOC_DTDVALID = 8
8479: XML_DOC_XINCLUDE = 16
8480: XML_DOC_USERBUILT = 32
8481: XML_DOC_INTERNAL = 64
8482: XML_DOC_HTML = 128
8483:
8484: # xlinkType
8485: XLINK_TYPE_NONE = 0
8486: XLINK_TYPE_SIMPLE = 1
8487: XLINK_TYPE_EXTENDED = 2
8488: XLINK_TYPE_EXTENDED_SET = 3
8489:
8490: # xmlXPathObjectType
8491: XPATH_UNDEFINED = 0
8492: XPATH_NODESET = 1
8493: XPATH_BOOLEAN = 2
8494: XPATH_NUMBER = 3
8495: XPATH_STRING = 4
8496: XPATH_POINT = 5
8497: XPATH_RANGE = 6
8498: XPATH_LOCATIONSET = 7
8499: XPATH_USERS = 8
8500: XPATH_XSLT_TREE = 9
8501:
8502: # xmlSchemaValidError
8503: XML_SCHEMAS_ERR_OK = 0
8504: XML_SCHEMAS_ERR_NOROOT = 1
8505: XML_SCHEMAS_ERR_UNDECLAREDELEM = 2
8506: XML_SCHEMAS_ERR_NOTTOPLEVEL = 3
8507: XML_SCHEMAS_ERR_MISSING = 4
8508: XML_SCHEMAS_ERR_WRONGELEM = 5
8509: XML_SCHEMAS_ERR_NOTYPE = 6
8510: XML_SCHEMAS_ERR_NOROLLBACK = 7
8511: XML_SCHEMAS_ERR_ISABSTRACT = 8
8512: XML_SCHEMAS_ERR_NOTEMPTY = 9
8513: XML_SCHEMAS_ERR_ELEMCONT = 10
8514: XML_SCHEMAS_ERR_HAVEDEFAULT = 11
8515: XML_SCHEMAS_ERR_NOTNILLABLE = 12
8516: XML_SCHEMAS_ERR_EXTRACONTENT = 13
8517: XML_SCHEMAS_ERR_INVALIDATTR = 14
8518: XML_SCHEMAS_ERR_INVALIDELEM = 15
8519: XML_SCHEMAS_ERR_NOTDETERMINIST = 16
8520: XML_SCHEMAS_ERR_CONSTRUCT = 17
8521: XML_SCHEMAS_ERR_INTERNAL = 18
8522: XML_SCHEMAS_ERR_NOTSIMPLE = 19
8523: XML_SCHEMAS_ERR_ATTRUNKNOWN = 20
8524: XML_SCHEMAS_ERR_ATTRINVALID = 21
8525: XML_SCHEMAS_ERR_VALUE = 22
8526: XML_SCHEMAS_ERR_FACET = 23
8527: XML_SCHEMAS_ERR_ = 24
8528: XML_SCHEMAS_ERR_XXX = 25
8529:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to libxml2class.py CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2 / python