5 # The root of all libxml2 errors.
6 class libxmlError(Exception): pass
8 # Type of the wrapper class for the C objects wrappers
11 n = type(_obj).__name__
12 if n != 'PyCObject' and n != 'PyCapsule':
19 # id() is sometimes negative ...
24 return (sys.maxsize - i)
28 # Errors raised by the wrappers when some tree handling failed.
30 class treeError(libxmlError):
31 def __init__(self, msg):
36 class parserError(libxmlError):
37 def __init__(self, msg):
42 class uriError(libxmlError):
43 def __init__(self, msg):
48 class xpathError(libxmlError):
49 def __init__(self, msg):
55 def __init__(self, _obj):
72 def io_read(self, len = -1):
77 ret = self.__io.read()
79 ret = self.__io.read(len)
83 print("failed to read from Python:", type(e))
84 print("on IO:", self.__io)
90 def io_write(self, str, len = -1):
94 return(self.__io.write(str))
95 return(self.__io.write(str, len))
97 class ioReadWrapper(ioWrapper):
98 def __init__(self, _obj, enc = ""):
99 ioWrapper.__init__(self, _obj)
100 self._o = libxml2mod.xmlCreateInputBuffer(self, enc)
106 libxml2mod.xmlFreeParserInputBuffer(self._o)
112 libxml2mod.xmlFreeParserInputBuffer(self._o)
115 class ioWriteWrapper(ioWrapper):
116 def __init__(self, _obj, enc = ""):
117 # print "ioWriteWrapper.__init__", _obj
118 if type(_obj) == type(''):
119 print("write io from a string")
121 elif type(_obj).__name__ == 'PyCapsule':
122 file = libxml2mod.outputBufferGetPythonFile(_obj)
124 ioWrapper.__init__(self, file)
126 ioWrapper.__init__(self, _obj)
128 # elif type(_obj) == types.InstanceType:
129 # print(("write io from instance of %s" % (_obj.__class__)))
130 # ioWrapper.__init__(self, _obj)
131 # self._o = libxml2mod.xmlCreateOutputBuffer(self, enc)
133 file = libxml2mod.outputBufferGetPythonFile(_obj)
135 ioWrapper.__init__(self, file)
137 ioWrapper.__init__(self, _obj)
144 libxml2mod.xmlOutputBufferClose(self._o)
150 libxml2mod.xmlOutputBufferClose(self._o)
156 libxml2mod.xmlOutputBufferClose(self._o)
160 # Example of a class to handle SAX events
163 """Base class for SAX handlers"""
164 def startDocument(self):
165 """called at the start of the document"""
168 def endDocument(self):
169 """called at the end of the document"""
172 def startElement(self, tag, attrs):
173 """called at the start of every element, tag is the name of
174 the element, attrs is a dictionary of the element's attributes"""
177 def endElement(self, tag):
178 """called at the start of every element, tag is the name of
182 def characters(self, data):
183 """called when character data have been read, data is the string
184 containing the data, multiple consecutive characters() callback
188 def cdataBlock(self, data):
189 """called when CDATA section have been read, data is the string
190 containing the data, multiple consecutive cdataBlock() callback
194 def reference(self, name):
195 """called when an entity reference has been found"""
198 def ignorableWhitespace(self, data):
199 """called when potentially ignorable white spaces have been found"""
202 def processingInstruction(self, target, data):
203 """called when a PI has been found, target contains the PI name and
204 data is the associated data in the PI"""
207 def comment(self, content):
208 """called when a comment has been found, content contains the comment"""
211 def externalSubset(self, name, externalID, systemID):
212 """called when a DOCTYPE declaration has been found, name is the
213 DTD name and externalID, systemID are the DTD public and system
214 identifier for that DTd if available"""
217 def internalSubset(self, name, externalID, systemID):
218 """called when a DOCTYPE declaration has been found, name is the
219 DTD name and externalID, systemID are the DTD public and system
220 identifier for that DTD if available"""
223 def entityDecl(self, name, type, externalID, systemID, content):
224 """called when an ENTITY declaration has been found, name is the
225 entity name and externalID, systemID are the entity public and
226 system identifier for that entity if available, type indicates
227 the entity type, and content reports it's string content"""
230 def notationDecl(self, name, externalID, systemID):
231 """called when an NOTATION declaration has been found, name is the
232 notation name and externalID, systemID are the notation public and
233 system identifier for that notation if available"""
236 def attributeDecl(self, elem, name, type, defi, defaultValue, nameList):
237 """called when an ATTRIBUTE definition has been found"""
240 def elementDecl(self, name, type, content):
241 """called when an ELEMENT definition has been found"""
244 def entityDecl(self, name, publicId, systemID, notationName):
245 """called when an unparsed ENTITY declaration has been found,
246 name is the entity name and publicId,, systemID are the entity
247 public and system identifier for that entity if available,
248 and notationName indicate the associated NOTATION"""
251 def warning(self, msg):
255 def error(self, msg):
256 raise parserError(msg)
258 def fatalError(self, msg):
259 raise parserError(msg)
262 # This class is the ancestor of all the Node classes. It provides
263 # the basic functionalities shared by all nodes (and handle
264 # gracefylly the exception), like name, navigation in the tree,
265 # doc reference, content access and serializing to a string or URI
268 def __init__(self, _obj=None):
274 def __eq__(self, other):
277 ret = libxml2mod.compareNodesEqual(self._o, other._o)
281 def __ne__(self, other):
284 ret = libxml2mod.compareNodesEqual(self._o, other._o)
287 ret = libxml2mod.nodeHash(self._o)
291 return self.serialize()
292 def get_parent(self):
293 ret = libxml2mod.parent(self._o)
297 def get_children(self):
298 ret = libxml2mod.children(self._o)
303 ret = libxml2mod.last(self._o)
308 ret = libxml2mod.next(self._o)
312 def get_properties(self):
313 ret = libxml2mod.properties(self._o)
316 return xmlAttr(_obj=ret)
318 ret = libxml2mod.prev(self._o)
322 def get_content(self):
323 return libxml2mod.xmlNodeGetContent(self._o)
324 getContent = get_content # why is this duplicate naming needed ?
326 return libxml2mod.name(self._o)
328 return libxml2mod.type(self._o)
330 ret = libxml2mod.doc(self._o)
332 if self.type in ["document_xml", "document_html"]:
333 return xmlDoc(_obj=self._o)
336 return xmlDoc(_obj=ret)
338 # Those are common attributes to nearly all type of nodes
339 # defined as python2 properties
342 if float(sys.version[0:3]) < 2.2:
343 def __getattr__(self, attr):
345 ret = libxml2mod.parent(self._o)
349 elif attr == "properties":
350 ret = libxml2mod.properties(self._o)
353 return xmlAttr(_obj=ret)
354 elif attr == "children":
355 ret = libxml2mod.children(self._o)
360 ret = libxml2mod.last(self._o)
365 ret = libxml2mod.next(self._o)
370 ret = libxml2mod.prev(self._o)
374 elif attr == "content":
375 return libxml2mod.xmlNodeGetContent(self._o)
377 return libxml2mod.name(self._o)
379 return libxml2mod.type(self._o)
381 ret = libxml2mod.doc(self._o)
383 if self.type == "document_xml" or self.type == "document_html":
384 return xmlDoc(_obj=self._o)
387 return xmlDoc(_obj=ret)
388 raise AttributeError(attr)
390 parent = property(get_parent, None, None, "Parent node")
391 children = property(get_children, None, None, "First child node")
392 last = property(get_last, None, None, "Last sibling node")
393 next = property(get_next, None, None, "Next sibling node")
394 prev = property(get_prev, None, None, "Previous sibling node")
395 properties = property(get_properties, None, None, "List of properies")
396 content = property(get_content, None, None, "Content of this node")
397 name = property(get_name, None, None, "Node name")
398 type = property(get_type, None, None, "Node type")
399 doc = property(get_doc, None, None, "The document this node belongs to")
402 # Serialization routines, the optional arguments have the following
404 # encoding: string to ask saving in a specific encoding
405 # indent: if 1 the serializer is asked to indent the output
407 def serialize(self, encoding = None, format = 0):
408 return libxml2mod.serializeNode(self._o, encoding, format)
409 def saveTo(self, file, encoding = None, format = 0):
410 return libxml2mod.saveNodeTo(self._o, file, encoding, format)
413 # Canonicalization routines:
415 # nodes: the node set (tuple or list) to be included in the
416 # canonized image or None if all document nodes should be
418 # exclusive: the exclusive flag (0 - non-exclusive
419 # canonicalization; otherwise - exclusive canonicalization)
420 # prefixes: the list of inclusive namespace prefixes (strings),
421 # or None if there is no inclusive namespaces (only for
422 # exclusive canonicalization, ignored otherwise)
423 # with_comments: include comments in the result (!=0) or not
431 nodes = [n._o for n in nodes]
432 return libxml2mod.xmlC14NDocDumpMemory(
445 nodes = [n._o for n in nodes]
446 return libxml2mod.xmlC14NDocSaveTo(
455 # Selecting nodes using XPath, a bit slow because the context
456 # is allocated/freed every time but convenient.
458 def xpathEval(self, expr):
462 ctxt = doc.xpathNewContext()
463 ctxt.setContextNode(self)
464 res = ctxt.xpathEval(expr)
465 ctxt.xpathFreeContext()
469 # # Selecting nodes using XPath, faster because the context
470 # # is allocated just once per xmlDoc.
472 # # Removed: DV memleaks c.f. #126735
474 # def xpathEval2(self, expr):
479 # doc._ctxt.setContextNode(self)
481 # doc._ctxt = doc.xpathNewContext()
482 # doc._ctxt.setContextNode(self)
483 # res = doc._ctxt.xpathEval(expr)
485 def xpathEval2(self, expr):
486 return self.xpathEval(expr)
489 def removeNsDef(self, href):
491 Remove a namespace definition from a node. If href is None,
492 remove all of the ns definitions on that node. The removed
493 namespaces are returned as a linked list.
495 Note: If any child nodes referred to the removed namespaces,
496 they will be left with dangling links. You should call
497 renconciliateNs() to fix those pointers.
499 Note: This method does not free memory taken by the ns
500 definitions. You will need to free it manually with the
501 freeNsList() method on the returns xmlNs object.
504 ret = libxml2mod.xmlNodeRemoveNsDef(self._o, href)
505 if ret is None:return None
506 __tmp = xmlNs(_obj=ret)
509 # support for python2 iterators
510 def walk_depth_first(self):
511 return xmlCoreDepthFirstItertor(self)
512 def walk_breadth_first(self):
513 return xmlCoreBreadthFirstItertor(self)
514 __iter__ = walk_depth_first
518 self.doc._ctxt.xpathFreeContext()
521 libxml2mod.xmlFreeDoc(self._o)
525 # implements the depth-first iterator for libxml2 DOM tree
527 class xmlCoreDepthFirstItertor:
528 def __init__(self, node):
537 self.parents.append(self.node)
538 self.node = self.node.children
541 parent = self.parents.pop()
544 self.node = parent.next
548 # implements the breadth-first iterator for libxml2 DOM tree
550 class xmlCoreBreadthFirstItertor:
551 def __init__(self, node):
560 self.parents.append(self.node)
561 self.node = self.node.next
564 parent = self.parents.pop()
567 self.node = parent.children
571 # converters to present a nicer view of the XPath returns
574 # TODO try to cast to the most appropriate node class
575 name = libxml2mod.type(o)
576 if name == "element" or name == "text":
577 return xmlNode(_obj=o)
578 if name == "attribute":
579 return xmlAttr(_obj=o)
580 if name[0:8] == "document":
581 return xmlDoc(_obj=o)
582 if name == "namespace":
584 if name == "elem_decl":
585 return xmlElement(_obj=o)
586 if name == "attribute_decl":
587 return xmlAttribute(_obj=o)
588 if name == "entity_decl":
589 return xmlEntity(_obj=o)
591 return xmlDtd(_obj=o)
592 return xmlNode(_obj=o)
594 def xpathObjectRet(o):
596 if otype == type([]):
597 ret = list(map(xpathObjectRet, o))
599 elif otype == type(()):
600 ret = list(map(xpathObjectRet, o))
602 elif otype == type('') or otype == type(0) or otype == type(0.0):
608 # register an XPath function
610 def registerXPathFunction(ctxt, name, ns_uri, f):
611 ret = libxml2mod.xmlRegisterXPathFunction(ctxt, name, ns_uri, f)
614 # For the xmlTextReader parser configuration
617 PARSER_DEFAULTATTRS=2
619 PARSER_SUBST_ENTITIES=4
622 # For the error callback severities
624 PARSER_SEVERITY_VALIDITY_WARNING=1
625 PARSER_SEVERITY_VALIDITY_ERROR=2
626 PARSER_SEVERITY_WARNING=3
627 PARSER_SEVERITY_ERROR=4
630 # register the libxml2 error handler
632 def registerErrorHandler(f, ctx):
633 """Register a Python written function to for error reporting.
634 The function is called back as f(ctx, error). """
636 if 'libxslt' not in sys.modules:
637 # normal behaviour when libxslt is not imported
638 ret = libxml2mod.xmlRegisterErrorHandler(f,ctx)
640 # when libxslt is already imported, one must
641 # use libxst's error handler instead
643 ret = libxslt.registerErrorHandler(f,ctx)
646 class parserCtxtCore:
648 def __init__(self, _obj=None):
656 libxml2mod.xmlFreeParserCtxt(self._o)
659 def setErrorHandler(self,f,arg):
660 """Register an error handler that will be called back as
661 f(arg,msg,severity,reserved).
663 @reserved is currently always None."""
664 libxml2mod.xmlParserCtxtSetErrorHandler(self._o,f,arg)
666 def getErrorHandler(self):
667 """Return (f,arg) as previously registered with setErrorHandler
669 return libxml2mod.xmlParserCtxtGetErrorHandler(self._o)
671 def addLocalCatalog(self, uri):
672 """Register a local catalog with the parser"""
673 return libxml2mod.addLocalCatalog(self._o, uri)
678 def __init__(self, *args, **kw):
681 def setValidityErrorHandler(self, err_func, warn_func, arg=None):
683 Register error and warning handlers for DTD validation.
684 These will be called back as f(msg,arg)
686 libxml2mod.xmlSetValidErrors(self._o, err_func, warn_func, arg)
689 class SchemaValidCtxtCore:
691 def __init__(self, *args, **kw):
694 def setValidityErrorHandler(self, err_func, warn_func, arg=None):
696 Register error and warning handlers for Schema validation.
697 These will be called back as f(msg,arg)
699 libxml2mod.xmlSchemaSetValidErrors(self._o, err_func, warn_func, arg)
702 class relaxNgValidCtxtCore:
704 def __init__(self, *args, **kw):
707 def setValidityErrorHandler(self, err_func, warn_func, arg=None):
709 Register error and warning handlers for RelaxNG validation.
710 These will be called back as f(msg,arg)
712 libxml2mod.xmlRelaxNGSetValidErrors(self._o, err_func, warn_func, arg)
715 def _xmlTextReaderErrorFunc(xxx_todo_changeme,msg,severity,locator):
716 """Intermediate callback to wrap the locator"""
717 (f,arg) = xxx_todo_changeme
718 return f(arg,msg,severity,xmlTextReaderLocator(locator))
720 class xmlTextReaderCore:
722 def __init__(self, _obj=None):
724 if _obj != None:self._o = _obj;return
729 libxml2mod.xmlFreeTextReader(self._o)
732 def SetErrorHandler(self,f,arg):
733 """Register an error handler that will be called back as
734 f(arg,msg,severity,locator)."""
736 libxml2mod.xmlTextReaderSetErrorHandler(\
739 libxml2mod.xmlTextReaderSetErrorHandler(\
740 self._o,_xmlTextReaderErrorFunc,(f,arg))
742 def GetErrorHandler(self):
743 """Return (f,arg) as previously registered with setErrorHandler
745 f,arg = libxml2mod.xmlTextReaderGetErrorHandler(self._o)
749 # assert f is _xmlTextReaderErrorFunc
753 # The cleanup now goes though a wrapper in libxml.c
756 libxml2mod.xmlPythonCleanupParser()
759 # The interface to xmlRegisterInputCallbacks.
760 # Since this API does not allow to pass a data object along with
761 # match/open callbacks, it is necessary to maintain a list of all
764 __input_callbacks = []
765 def registerInputCallback(func):
766 def findOpenCallback(URI):
767 for cb in reversed(__input_callbacks):
771 libxml2mod.xmlRegisterInputCallback(findOpenCallback)
772 __input_callbacks.append(func)
774 def popInputCallbacks():
775 # First pop python-level callbacks, when no more available - start
776 # popping built-in ones.
777 if len(__input_callbacks) > 0:
778 __input_callbacks.pop()
779 if len(__input_callbacks) == 0:
780 libxml2mod.xmlUnregisterInputCallback()
782 # WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
784 # Everything before this line comes from libxml.py
785 # Everything after this line is automatically generated
787 # WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
790 # Functions from module HTMLparser
793 def htmlCreateMemoryParserCtxt(buffer, size):
794 """Create a parser context for an HTML in-memory document. """
795 ret = libxml2mod.htmlCreateMemoryParserCtxt(buffer, size)
796 if ret is None:raise parserError('htmlCreateMemoryParserCtxt() failed')
797 return parserCtxt(_obj=ret)
799 def htmlHandleOmittedElem(val):
800 """Set and return the previous value for handling HTML omitted
802 ret = libxml2mod.htmlHandleOmittedElem(val)
805 def htmlIsScriptAttribute(name):
806 """Check if an attribute is of content type Script """
807 ret = libxml2mod.htmlIsScriptAttribute(name)
810 def htmlNewParserCtxt():
811 """Allocate and initialize a new parser context. """
812 ret = libxml2mod.htmlNewParserCtxt()
813 if ret is None:raise parserError('htmlNewParserCtxt() failed')
814 return parserCtxt(_obj=ret)
816 def htmlParseDoc(cur, encoding):
817 """parse an HTML in-memory document and build a tree. """
818 ret = libxml2mod.htmlParseDoc(cur, encoding)
819 if ret is None:raise parserError('htmlParseDoc() failed')
820 return xmlDoc(_obj=ret)
822 def htmlParseFile(filename, encoding):
823 """parse an HTML file and build a tree. Automatic support for
824 ZLIB/Compress compressed document is provided by default if
825 found at compile-time. """
826 ret = libxml2mod.htmlParseFile(filename, encoding)
827 if ret is None:raise parserError('htmlParseFile() failed')
828 return xmlDoc(_obj=ret)
830 def htmlReadDoc(cur, URL, encoding, options):
831 """parse an XML in-memory document and build a tree. """
832 ret = libxml2mod.htmlReadDoc(cur, URL, encoding, options)
833 if ret is None:raise treeError('htmlReadDoc() failed')
834 return xmlDoc(_obj=ret)
836 def htmlReadFd(fd, URL, encoding, options):
837 """parse an XML from a file descriptor and build a tree. """
838 ret = libxml2mod.htmlReadFd(fd, URL, encoding, options)
839 if ret is None:raise treeError('htmlReadFd() failed')
840 return xmlDoc(_obj=ret)
842 def htmlReadFile(filename, encoding, options):
843 """parse an XML file from the filesystem or the network. """
844 ret = libxml2mod.htmlReadFile(filename, encoding, options)
845 if ret is None:raise treeError('htmlReadFile() failed')
846 return xmlDoc(_obj=ret)
848 def htmlReadMemory(buffer, size, URL, encoding, options):
849 """parse an XML in-memory document and build a tree. """
850 ret = libxml2mod.htmlReadMemory(buffer, size, URL, encoding, options)
851 if ret is None:raise treeError('htmlReadMemory() failed')
852 return xmlDoc(_obj=ret)
855 # Functions from module HTMLtree
858 def htmlIsBooleanAttr(name):
859 """Determine if a given attribute is a boolean attribute. """
860 ret = libxml2mod.htmlIsBooleanAttr(name)
863 def htmlNewDoc(URI, ExternalID):
864 """Creates a new HTML document """
865 ret = libxml2mod.htmlNewDoc(URI, ExternalID)
866 if ret is None:raise treeError('htmlNewDoc() failed')
867 return xmlDoc(_obj=ret)
869 def htmlNewDocNoDtD(URI, ExternalID):
870 """Creates a new HTML document without a DTD node if @URI and
871 @ExternalID are None """
872 ret = libxml2mod.htmlNewDocNoDtD(URI, ExternalID)
873 if ret is None:raise treeError('htmlNewDocNoDtD() failed')
874 return xmlDoc(_obj=ret)
877 # Functions from module SAX2
880 def SAXDefaultVersion(version):
881 """Set the default version of SAX used globally by the
882 library. By default, during initialization the default is
883 set to 2. Note that it is generally a better coding style
884 to use xmlSAXVersion() to set up the version explicitly for
885 a given parsing context. """
886 ret = libxml2mod.xmlSAXDefaultVersion(version)
889 def defaultSAXHandlerInit():
890 """Initialize the default SAX2 handler """
891 libxml2mod.xmlDefaultSAXHandlerInit()
893 def docbDefaultSAXHandlerInit():
894 """Initialize the default SAX handler """
895 libxml2mod.docbDefaultSAXHandlerInit()
897 def htmlDefaultSAXHandlerInit():
898 """Initialize the default SAX handler """
899 libxml2mod.htmlDefaultSAXHandlerInit()
902 # Functions from module catalog
905 def catalogAdd(type, orig, replace):
906 """Add an entry in the catalog, it may overwrite existing but
907 different entries. If called before any other catalog
908 routine, allows to override the default shared catalog put
909 in place by xmlInitializeCatalog(); """
910 ret = libxml2mod.xmlCatalogAdd(type, orig, replace)
913 def catalogCleanup():
914 """Free up all the memory associated with catalogs """
915 libxml2mod.xmlCatalogCleanup()
917 def catalogConvert():
918 """Convert all the SGML catalog entries as XML ones """
919 ret = libxml2mod.xmlCatalogConvert()
922 def catalogDump(out):
923 """Dump all the global catalog content to the given file. """
924 if out is not None: out.flush()
925 libxml2mod.xmlCatalogDump(out)
927 def catalogGetPublic(pubID):
928 """Try to lookup the catalog reference associated to a public
929 ID DEPRECATED, use xmlCatalogResolvePublic() """
930 ret = libxml2mod.xmlCatalogGetPublic(pubID)
933 def catalogGetSystem(sysID):
934 """Try to lookup the catalog reference associated to a system
935 ID DEPRECATED, use xmlCatalogResolveSystem() """
936 ret = libxml2mod.xmlCatalogGetSystem(sysID)
939 def catalogRemove(value):
940 """Remove an entry from the catalog """
941 ret = libxml2mod.xmlCatalogRemove(value)
944 def catalogResolve(pubID, sysID):
945 """Do a complete resolution lookup of an External Identifier """
946 ret = libxml2mod.xmlCatalogResolve(pubID, sysID)
949 def catalogResolvePublic(pubID):
950 """Try to lookup the catalog reference associated to a public
952 ret = libxml2mod.xmlCatalogResolvePublic(pubID)
955 def catalogResolveSystem(sysID):
956 """Try to lookup the catalog resource for a system ID """
957 ret = libxml2mod.xmlCatalogResolveSystem(sysID)
960 def catalogResolveURI(URI):
961 """Do a complete resolution lookup of an URI """
962 ret = libxml2mod.xmlCatalogResolveURI(URI)
965 def catalogSetDebug(level):
966 """Used to set the debug level for catalog operation, 0
967 disable debugging, 1 enable it """
968 ret = libxml2mod.xmlCatalogSetDebug(level)
971 def initializeCatalog():
972 """Do the catalog initialization. this function is not thread
973 safe, catalog initialization should preferably be done once
975 libxml2mod.xmlInitializeCatalog()
977 def loadACatalog(filename):
978 """Load the catalog and build the associated data structures.
979 This can be either an XML Catalog or an SGML Catalog It
980 will recurse in SGML CATALOG entries. On the other hand XML
981 Catalogs are not handled recursively. """
982 ret = libxml2mod.xmlLoadACatalog(filename)
983 if ret is None:raise treeError('xmlLoadACatalog() failed')
984 return catalog(_obj=ret)
986 def loadCatalog(filename):
987 """Load the catalog and makes its definitions effective for
988 the default external entity loader. It will recurse in SGML
989 CATALOG entries. this function is not thread safe, catalog
990 initialization should preferably be done once at startup """
991 ret = libxml2mod.xmlLoadCatalog(filename)
994 def loadCatalogs(pathss):
995 """Load the catalogs and makes their definitions effective for
996 the default external entity loader. this function is not
997 thread safe, catalog initialization should preferably be
998 done once at startup """
999 libxml2mod.xmlLoadCatalogs(pathss)
1001 def loadSGMLSuperCatalog(filename):
1002 """Load an SGML super catalog. It won't expand CATALOG or
1003 DELEGATE references. This is only needed for manipulating
1004 SGML Super Catalogs like adding and removing CATALOG or
1005 DELEGATE entries. """
1006 ret = libxml2mod.xmlLoadSGMLSuperCatalog(filename)
1007 if ret is None:raise treeError('xmlLoadSGMLSuperCatalog() failed')
1008 return catalog(_obj=ret)
1010 def newCatalog(sgml):
1011 """create a new Catalog. """
1012 ret = libxml2mod.xmlNewCatalog(sgml)
1013 if ret is None:raise treeError('xmlNewCatalog() failed')
1014 return catalog(_obj=ret)
1016 def parseCatalogFile(filename):
1017 """parse an XML file and build a tree. It's like
1018 xmlParseFile() except it bypass all catalog lookups. """
1019 ret = libxml2mod.xmlParseCatalogFile(filename)
1020 if ret is None:raise parserError('xmlParseCatalogFile() failed')
1021 return xmlDoc(_obj=ret)
1024 # Functions from module chvalid
1028 """This function is DEPRECATED. Use xmlIsBaseChar_ch or
1029 xmlIsBaseCharQ instead """
1030 ret = libxml2mod.xmlIsBaseChar(ch)
1034 """This function is DEPRECATED. Use xmlIsBlank_ch or
1035 xmlIsBlankQ instead """
1036 ret = libxml2mod.xmlIsBlank(ch)
1040 """This function is DEPRECATED. Use xmlIsChar_ch or xmlIsCharQ
1042 ret = libxml2mod.xmlIsChar(ch)
1045 def isCombining(ch):
1046 """This function is DEPRECATED. Use xmlIsCombiningQ instead """
1047 ret = libxml2mod.xmlIsCombining(ch)
1051 """This function is DEPRECATED. Use xmlIsDigit_ch or
1052 xmlIsDigitQ instead """
1053 ret = libxml2mod.xmlIsDigit(ch)
1057 """This function is DEPRECATED. Use xmlIsExtender_ch or
1058 xmlIsExtenderQ instead """
1059 ret = libxml2mod.xmlIsExtender(ch)
1062 def isIdeographic(ch):
1063 """This function is DEPRECATED. Use xmlIsIdeographicQ instead """
1064 ret = libxml2mod.xmlIsIdeographic(ch)
1067 def isPubidChar(ch):
1068 """This function is DEPRECATED. Use xmlIsPubidChar_ch or
1069 xmlIsPubidCharQ instead """
1070 ret = libxml2mod.xmlIsPubidChar(ch)
1074 # Functions from module debugXML
1077 def boolToText(boolval):
1078 """Convenient way to turn bool into text """
1079 ret = libxml2mod.xmlBoolToText(boolval)
1082 def debugDumpString(output, str):
1083 """Dumps informations about the string, shorten it if necessary """
1084 if output is not None: output.flush()
1085 libxml2mod.xmlDebugDumpString(output, str)
1087 def shellPrintXPathError(errorType, arg):
1088 """Print the xpath error to libxml default error channel """
1089 libxml2mod.xmlShellPrintXPathError(errorType, arg)
1092 # Functions from module dict
1096 """Free the dictionary mutex. Do not call unless sure the
1097 library is not in use anymore ! """
1098 libxml2mod.xmlDictCleanup()
1100 def initializeDict():
1101 """Do the dictionary mutex initialization. this function is
1103 ret = libxml2mod.xmlInitializeDict()
1107 # Functions from module encoding
1110 def addEncodingAlias(name, alias):
1111 """Registers an alias @alias for an encoding named @name.
1112 Existing alias will be overwritten. """
1113 ret = libxml2mod.xmlAddEncodingAlias(name, alias)
1116 def cleanupCharEncodingHandlers():
1117 """Cleanup the memory allocated for the char encoding support,
1118 it unregisters all the encoding handlers and the aliases. """
1119 libxml2mod.xmlCleanupCharEncodingHandlers()
1121 def cleanupEncodingAliases():
1122 """Unregisters all aliases """
1123 libxml2mod.xmlCleanupEncodingAliases()
1125 def delEncodingAlias(alias):
1126 """Unregisters an encoding alias @alias """
1127 ret = libxml2mod.xmlDelEncodingAlias(alias)
1130 def encodingAlias(alias):
1131 """Lookup an encoding name for the given alias. """
1132 ret = libxml2mod.xmlGetEncodingAlias(alias)
1135 def initCharEncodingHandlers():
1136 """Initialize the char encoding support, it registers the
1137 default encoding supported. NOTE: while public, this
1138 function usually doesn't need to be called in normal
1140 libxml2mod.xmlInitCharEncodingHandlers()
1143 # Functions from module entities
1146 def cleanupPredefinedEntities():
1147 """Cleanup up the predefined entities table. Deprecated call """
1148 libxml2mod.xmlCleanupPredefinedEntities()
1150 def initializePredefinedEntities():
1151 """Set up the predefined entities. Deprecated call """
1152 libxml2mod.xmlInitializePredefinedEntities()
1154 def predefinedEntity(name):
1155 """Check whether this name is an predefined entity. """
1156 ret = libxml2mod.xmlGetPredefinedEntity(name)
1157 if ret is None:raise treeError('xmlGetPredefinedEntity() failed')
1158 return xmlEntity(_obj=ret)
1161 # Functions from module globals
1164 def cleanupGlobals():
1165 """Additional cleanup for multi-threading """
1166 libxml2mod.xmlCleanupGlobals()
1169 """Additional initialisation for multi-threading """
1170 libxml2mod.xmlInitGlobals()
1172 def thrDefDefaultBufferSize(v):
1173 ret = libxml2mod.xmlThrDefDefaultBufferSize(v)
1176 def thrDefDoValidityCheckingDefaultValue(v):
1177 ret = libxml2mod.xmlThrDefDoValidityCheckingDefaultValue(v)
1180 def thrDefGetWarningsDefaultValue(v):
1181 ret = libxml2mod.xmlThrDefGetWarningsDefaultValue(v)
1184 def thrDefIndentTreeOutput(v):
1185 ret = libxml2mod.xmlThrDefIndentTreeOutput(v)
1188 def thrDefKeepBlanksDefaultValue(v):
1189 ret = libxml2mod.xmlThrDefKeepBlanksDefaultValue(v)
1192 def thrDefLineNumbersDefaultValue(v):
1193 ret = libxml2mod.xmlThrDefLineNumbersDefaultValue(v)
1196 def thrDefLoadExtDtdDefaultValue(v):
1197 ret = libxml2mod.xmlThrDefLoadExtDtdDefaultValue(v)
1200 def thrDefParserDebugEntities(v):
1201 ret = libxml2mod.xmlThrDefParserDebugEntities(v)
1204 def thrDefPedanticParserDefaultValue(v):
1205 ret = libxml2mod.xmlThrDefPedanticParserDefaultValue(v)
1208 def thrDefSaveNoEmptyTags(v):
1209 ret = libxml2mod.xmlThrDefSaveNoEmptyTags(v)
1212 def thrDefSubstituteEntitiesDefaultValue(v):
1213 ret = libxml2mod.xmlThrDefSubstituteEntitiesDefaultValue(v)
1216 def thrDefTreeIndentString(v):
1217 ret = libxml2mod.xmlThrDefTreeIndentString(v)
1221 # Functions from module nanoftp
1224 def nanoFTPCleanup():
1225 """Cleanup the FTP protocol layer. This cleanup proxy
1227 libxml2mod.xmlNanoFTPCleanup()
1230 """Initialize the FTP protocol layer. Currently it just checks
1231 for proxy informations, and get the hostname """
1232 libxml2mod.xmlNanoFTPInit()
1234 def nanoFTPProxy(host, port, user, passwd, type):
1235 """Setup the FTP proxy informations. This can also be done by
1236 using ftp_proxy ftp_proxy_user and ftp_proxy_password
1237 environment variables. """
1238 libxml2mod.xmlNanoFTPProxy(host, port, user, passwd, type)
1240 def nanoFTPScanProxy(URL):
1241 """(Re)Initialize the FTP Proxy context by parsing the URL and
1242 finding the protocol host port it indicates. Should be like
1243 ftp://myproxy/ or ftp://myproxy:3128/ A None URL cleans up
1244 proxy informations. """
1245 libxml2mod.xmlNanoFTPScanProxy(URL)
1248 # Functions from module nanohttp
1251 def nanoHTTPCleanup():
1252 """Cleanup the HTTP protocol layer. """
1253 libxml2mod.xmlNanoHTTPCleanup()
1256 """Initialize the HTTP protocol layer. Currently it just
1257 checks for proxy informations """
1258 libxml2mod.xmlNanoHTTPInit()
1260 def nanoHTTPScanProxy(URL):
1261 """(Re)Initialize the HTTP Proxy context by parsing the URL
1262 and finding the protocol host port it indicates. Should be
1263 like http://myproxy/ or http://myproxy:3128/ A None URL
1264 cleans up proxy informations. """
1265 libxml2mod.xmlNanoHTTPScanProxy(URL)
1268 # Functions from module parser
1271 def createDocParserCtxt(cur):
1272 """Creates a parser context for an XML in-memory document. """
1273 ret = libxml2mod.xmlCreateDocParserCtxt(cur)
1274 if ret is None:raise parserError('xmlCreateDocParserCtxt() failed')
1275 return parserCtxt(_obj=ret)
1278 """Initialization function for the XML parser. This is not
1279 reentrant. Call once before processing in case of use in
1280 multithreaded programs. """
1281 libxml2mod.xmlInitParser()
1283 def keepBlanksDefault(val):
1284 """Set and return the previous value for default blanks text
1285 nodes support. The 1.x version of the parser used an
1286 heuristic to try to detect ignorable white spaces. As a
1287 result the SAX callback was generating
1288 xmlSAX2IgnorableWhitespace() callbacks instead of
1289 characters() one, and when using the DOM output text nodes
1290 containing those blanks were not generated. The 2.x and
1291 later version will switch to the XML standard way and
1292 ignorableWhitespace() are only generated when running the
1293 parser in validating mode and when the current element
1294 doesn't allow CDATA or mixed content. This function is
1295 provided as a way to force the standard behavior on 1.X
1296 libs and to switch back to the old mode for compatibility
1297 when running 1.X client code on 2.X . Upgrade of 1.X code
1298 should be done by using xmlIsBlankNode() commodity function
1299 to detect the "empty" nodes generated. This value also
1300 affect autogeneration of indentation when saving code if
1301 blanks sections are kept, indentation is not generated. """
1302 ret = libxml2mod.xmlKeepBlanksDefault(val)
1305 def lineNumbersDefault(val):
1306 """Set and return the previous value for enabling line numbers
1307 in elements contents. This may break on old application and
1308 is turned off by default. """
1309 ret = libxml2mod.xmlLineNumbersDefault(val)
1312 def newParserCtxt():
1313 """Allocate and initialize a new parser context. """
1314 ret = libxml2mod.xmlNewParserCtxt()
1315 if ret is None:raise parserError('xmlNewParserCtxt() failed')
1316 return parserCtxt(_obj=ret)
1318 def parseDTD(ExternalID, SystemID):
1319 """Load and parse an external subset. """
1320 ret = libxml2mod.xmlParseDTD(ExternalID, SystemID)
1321 if ret is None:raise parserError('xmlParseDTD() failed')
1322 return xmlDtd(_obj=ret)
1325 """parse an XML in-memory document and build a tree. """
1326 ret = libxml2mod.xmlParseDoc(cur)
1327 if ret is None:raise parserError('xmlParseDoc() failed')
1328 return xmlDoc(_obj=ret)
1330 def parseEntity(filename):
1331 """parse an XML external entity out of context and build a
1332 tree. [78] extParsedEnt ::= TextDecl? content This
1333 correspond to a "Well Balanced" chunk """
1334 ret = libxml2mod.xmlParseEntity(filename)
1335 if ret is None:raise parserError('xmlParseEntity() failed')
1336 return xmlDoc(_obj=ret)
1338 def parseFile(filename):
1339 """parse an XML file and build a tree. Automatic support for
1340 ZLIB/Compress compressed document is provided by default if
1341 found at compile-time. """
1342 ret = libxml2mod.xmlParseFile(filename)
1343 if ret is None:raise parserError('xmlParseFile() failed')
1344 return xmlDoc(_obj=ret)
1346 def parseMemory(buffer, size):
1347 """parse an XML in-memory block and build a tree. """
1348 ret = libxml2mod.xmlParseMemory(buffer, size)
1349 if ret is None:raise parserError('xmlParseMemory() failed')
1350 return xmlDoc(_obj=ret)
1352 def pedanticParserDefault(val):
1353 """Set and return the previous value for enabling pedantic
1355 ret = libxml2mod.xmlPedanticParserDefault(val)
1358 def readDoc(cur, URL, encoding, options):
1359 """parse an XML in-memory document and build a tree. """
1360 ret = libxml2mod.xmlReadDoc(cur, URL, encoding, options)
1361 if ret is None:raise treeError('xmlReadDoc() failed')
1362 return xmlDoc(_obj=ret)
1364 def readFd(fd, URL, encoding, options):
1365 """parse an XML from a file descriptor and build a tree. NOTE
1366 that the file descriptor will not be closed when the reader
1367 is closed or reset. """
1368 ret = libxml2mod.xmlReadFd(fd, URL, encoding, options)
1369 if ret is None:raise treeError('xmlReadFd() failed')
1370 return xmlDoc(_obj=ret)
1372 def readFile(filename, encoding, options):
1373 """parse an XML file from the filesystem or the network. """
1374 ret = libxml2mod.xmlReadFile(filename, encoding, options)
1375 if ret is None:raise treeError('xmlReadFile() failed')
1376 return xmlDoc(_obj=ret)
1378 def readMemory(buffer, size, URL, encoding, options):
1379 """parse an XML in-memory document and build a tree. """
1380 ret = libxml2mod.xmlReadMemory(buffer, size, URL, encoding, options)
1381 if ret is None:raise treeError('xmlReadMemory() failed')
1382 return xmlDoc(_obj=ret)
1384 def recoverDoc(cur):
1385 """parse an XML in-memory document and build a tree. In the
1386 case the document is not Well Formed, a attempt to build a
1387 tree is tried anyway """
1388 ret = libxml2mod.xmlRecoverDoc(cur)
1389 if ret is None:raise treeError('xmlRecoverDoc() failed')
1390 return xmlDoc(_obj=ret)
1392 def recoverFile(filename):
1393 """parse an XML file and build a tree. Automatic support for
1394 ZLIB/Compress compressed document is provided by default if
1395 found at compile-time. In the case the document is not Well
1396 Formed, it attempts to build a tree anyway """
1397 ret = libxml2mod.xmlRecoverFile(filename)
1398 if ret is None:raise treeError('xmlRecoverFile() failed')
1399 return xmlDoc(_obj=ret)
1401 def recoverMemory(buffer, size):
1402 """parse an XML in-memory block and build a tree. In the case
1403 the document is not Well Formed, an attempt to build a tree
1405 ret = libxml2mod.xmlRecoverMemory(buffer, size)
1406 if ret is None:raise treeError('xmlRecoverMemory() failed')
1407 return xmlDoc(_obj=ret)
1409 def substituteEntitiesDefault(val):
1410 """Set and return the previous value for default entity
1411 support. Initially the parser always keep entity references
1412 instead of substituting entity values in the output. This
1413 function has to be used to change the default parser
1414 behavior SAX::substituteEntities() has to be used for
1415 changing that on a file by file basis. """
1416 ret = libxml2mod.xmlSubstituteEntitiesDefault(val)
1420 # Functions from module parserInternals
1423 def checkLanguageID(lang):
1424 """Checks that the value conforms to the LanguageID
1425 production: NOTE: this is somewhat deprecated, those
1426 productions were removed from the XML Second edition. [33]
1427 LanguageID ::= Langcode ('-' Subcode)* [34] Langcode ::=
1428 ISO639Code | IanaCode | UserCode [35] ISO639Code ::=
1429 ([a-z] | [A-Z]) ([a-z] | [A-Z]) [36] IanaCode ::= ('i' |
1430 'I') '-' ([a-z] | [A-Z])+ [37] UserCode ::= ('x' | 'X') '-'
1431 ([a-z] | [A-Z])+ [38] Subcode ::= ([a-z] | [A-Z])+ The
1432 current REC reference the sucessors of RFC 1766, currently
1433 5646 http://www.rfc-editor.org/rfc/rfc5646.txt langtag
1434 = language ["-" script] ["-" region] *("-" variant) *("-"
1435 extension) ["-" privateuse] language = 2*3ALPHA
1436 ; shortest ISO 639 code ["-" extlang] ; sometimes
1437 followed by ; extended language subtags / 4ALPHA
1438 ; or reserved for future use / 5*8ALPHA ; or
1439 registered language subtag extlang = 3ALPHA
1440 ; selected ISO 639 codes *2("-" 3ALPHA) ; permanently
1441 reserved script = 4ALPHA ; ISO 15924
1442 code region = 2ALPHA ; ISO 3166-1 code
1443 / 3DIGIT ; UN M.49 code variant =
1444 5*8alphanum ; registered variants / (DIGIT
1445 3alphanum) extension = singleton 1*("-" (2*8alphanum))
1446 ; Single alphanumerics ; "x" reserved for private use
1447 singleton = DIGIT ; 0 - 9 / %x41-57
1448 ; A - W / %x59-5A ; Y - Z / %x61-77
1449 ; a - w / %x79-7A ; y - z it sounds right to
1450 still allow Irregular i-xxx IANA and user codes too The
1451 parser below doesn't try to cope with extension or
1452 privateuse that could be added but that's not interoperable
1454 ret = libxml2mod.xmlCheckLanguageID(lang)
1457 def copyChar(len, out, val):
1458 """append the char value in the array """
1459 ret = libxml2mod.xmlCopyChar(len, out, val)
1462 def copyCharMultiByte(out, val):
1463 """append the char value in the array """
1464 ret = libxml2mod.xmlCopyCharMultiByte(out, val)
1467 def createEntityParserCtxt(URL, ID, base):
1468 """Create a parser context for an external entity Automatic
1469 support for ZLIB/Compress compressed document is provided
1470 by default if found at compile-time. """
1471 ret = libxml2mod.xmlCreateEntityParserCtxt(URL, ID, base)
1472 if ret is None:raise parserError('xmlCreateEntityParserCtxt() failed')
1473 return parserCtxt(_obj=ret)
1475 def createFileParserCtxt(filename):
1476 """Create a parser context for a file content. Automatic
1477 support for ZLIB/Compress compressed document is provided
1478 by default if found at compile-time. """
1479 ret = libxml2mod.xmlCreateFileParserCtxt(filename)
1480 if ret is None:raise parserError('xmlCreateFileParserCtxt() failed')
1481 return parserCtxt(_obj=ret)
1483 def createMemoryParserCtxt(buffer, size):
1484 """Create a parser context for an XML in-memory document. """
1485 ret = libxml2mod.xmlCreateMemoryParserCtxt(buffer, size)
1486 if ret is None:raise parserError('xmlCreateMemoryParserCtxt() failed')
1487 return parserCtxt(_obj=ret)
1489 def createURLParserCtxt(filename, options):
1490 """Create a parser context for a file or URL content.
1491 Automatic support for ZLIB/Compress compressed document is
1492 provided by default if found at compile-time and for file
1494 ret = libxml2mod.xmlCreateURLParserCtxt(filename, options)
1495 if ret is None:raise parserError('xmlCreateURLParserCtxt() failed')
1496 return parserCtxt(_obj=ret)
1498 def htmlCreateFileParserCtxt(filename, encoding):
1499 """Create a parser context for a file content. Automatic
1500 support for ZLIB/Compress compressed document is provided
1501 by default if found at compile-time. """
1502 ret = libxml2mod.htmlCreateFileParserCtxt(filename, encoding)
1503 if ret is None:raise parserError('htmlCreateFileParserCtxt() failed')
1504 return parserCtxt(_obj=ret)
1506 def htmlInitAutoClose():
1507 """Initialize the htmlStartCloseIndex for fast lookup of
1508 closing tags names. This is not reentrant. Call
1509 xmlInitParser() once before processing in case of use in
1510 multithreaded programs. """
1511 libxml2mod.htmlInitAutoClose()
1514 """Check whether the character is allowed by the production
1515 [84] Letter ::= BaseChar | Ideographic """
1516 ret = libxml2mod.xmlIsLetter(c)
1520 """Pops the top element name from the name stack """
1521 if ctxt is None: ctxt__o = None
1522 else: ctxt__o = ctxt._o
1523 ret = libxml2mod.namePop(ctxt__o)
1526 def namePush(ctxt, value):
1527 """Pushes a new element name on top of the name stack """
1528 if ctxt is None: ctxt__o = None
1529 else: ctxt__o = ctxt._o
1530 ret = libxml2mod.namePush(ctxt__o, value)
1534 """Pops the top element node from the node stack """
1535 if ctxt is None: ctxt__o = None
1536 else: ctxt__o = ctxt._o
1537 ret = libxml2mod.nodePop(ctxt__o)
1538 if ret is None:raise treeError('nodePop() failed')
1539 return xmlNode(_obj=ret)
1541 def nodePush(ctxt, value):
1542 """Pushes a new element node on top of the node stack """
1543 if ctxt is None: ctxt__o = None
1544 else: ctxt__o = ctxt._o
1545 if value is None: value__o = None
1546 else: value__o = value._o
1547 ret = libxml2mod.nodePush(ctxt__o, value__o)
1551 # Functions from module python
1554 def SAXParseFile(SAX, URI, recover):
1555 """Interface to parse an XML file or resource pointed by an
1556 URI to build an event flow to the SAX object """
1557 libxml2mod.xmlSAXParseFile(SAX, URI, recover)
1559 def createInputBuffer(file, encoding):
1560 """Create a libxml2 input buffer from a Python file """
1561 ret = libxml2mod.xmlCreateInputBuffer(file, encoding)
1562 if ret is None:raise treeError('xmlCreateInputBuffer() failed')
1563 return inputBuffer(_obj=ret)
1565 def createOutputBuffer(file, encoding):
1566 """Create a libxml2 output buffer from a Python file """
1567 ret = libxml2mod.xmlCreateOutputBuffer(file, encoding)
1568 if ret is None:raise treeError('xmlCreateOutputBuffer() failed')
1569 return outputBuffer(_obj=ret)
1571 def createPushParser(SAX, chunk, size, URI):
1572 """Create a progressive XML parser context to build either an
1573 event flow if the SAX object is not None, or a DOM tree
1575 ret = libxml2mod.xmlCreatePushParser(SAX, chunk, size, URI)
1576 if ret is None:raise parserError('xmlCreatePushParser() failed')
1577 return parserCtxt(_obj=ret)
1579 def debugMemory(activate):
1580 """Switch on the generation of line number for elements nodes.
1581 Also returns the number of bytes allocated and not freed by
1582 libxml2 since memory debugging was switched on. """
1583 ret = libxml2mod.xmlDebugMemory(activate)
1587 """dump the memory allocated in the file .memdump """
1588 libxml2mod.xmlDumpMemory()
1590 def htmlCreatePushParser(SAX, chunk, size, URI):
1591 """Create a progressive HTML parser context to build either an
1592 event flow if the SAX object is not None, or a DOM tree
1594 ret = libxml2mod.htmlCreatePushParser(SAX, chunk, size, URI)
1595 if ret is None:raise parserError('htmlCreatePushParser() failed')
1596 return parserCtxt(_obj=ret)
1598 def htmlSAXParseFile(SAX, URI, encoding):
1599 """Interface to parse an HTML file or resource pointed by an
1600 URI to build an event flow to the SAX object """
1601 libxml2mod.htmlSAXParseFile(SAX, URI, encoding)
1604 """Returns the total amount of memory allocated by libxml2 """
1605 ret = libxml2mod.xmlMemoryUsed()
1609 """Create a new Node """
1610 ret = libxml2mod.xmlNewNode(name)
1611 if ret is None:raise treeError('xmlNewNode() failed')
1612 return xmlNode(_obj=ret)
1614 def pythonCleanupParser():
1615 """Cleanup function for the XML library. It tries to reclaim
1616 all parsing related global memory allocated for the library
1617 processing. It doesn't deallocate any document related
1618 memory. Calling this function should not prevent reusing
1619 the library but one should call xmlCleanupParser() only
1620 when the process has finished using the library or XML
1621 document built with it. """
1622 libxml2mod.xmlPythonCleanupParser()
1624 def setEntityLoader(resolver):
1625 """Set the entity resolver as a python function """
1626 ret = libxml2mod.xmlSetEntityLoader(resolver)
1630 # Functions from module relaxng
1633 def relaxNGCleanupTypes():
1634 """Cleanup the default Schemas type library associated to
1636 libxml2mod.xmlRelaxNGCleanupTypes()
1638 def relaxNGInitTypes():
1639 """Initilize the default type libraries. """
1640 ret = libxml2mod.xmlRelaxNGInitTypes()
1643 def relaxNGNewMemParserCtxt(buffer, size):
1644 """Create an XML RelaxNGs parse context for that memory buffer
1645 expected to contain an XML RelaxNGs file. """
1646 ret = libxml2mod.xmlRelaxNGNewMemParserCtxt(buffer, size)
1647 if ret is None:raise parserError('xmlRelaxNGNewMemParserCtxt() failed')
1648 return relaxNgParserCtxt(_obj=ret)
1650 def relaxNGNewParserCtxt(URL):
1651 """Create an XML RelaxNGs parse context for that file/resource
1652 expected to contain an XML RelaxNGs file. """
1653 ret = libxml2mod.xmlRelaxNGNewParserCtxt(URL)
1654 if ret is None:raise parserError('xmlRelaxNGNewParserCtxt() failed')
1655 return relaxNgParserCtxt(_obj=ret)
1658 # Functions from module tree
1661 def buildQName(ncname, prefix, memory, len):
1662 """Builds the QName @prefix:@ncname in @memory if there is
1663 enough space and prefix is not None nor empty, otherwise
1664 allocate a new string. If prefix is None or empty it
1666 ret = libxml2mod.xmlBuildQName(ncname, prefix, memory, len)
1670 """get the default compression mode used, ZLIB based. """
1671 ret = libxml2mod.xmlGetCompressMode()
1674 def isXHTML(systemID, publicID):
1675 """Try to find if the document correspond to an XHTML DTD """
1676 ret = libxml2mod.xmlIsXHTML(systemID, publicID)
1679 def newComment(content):
1680 """Creation of a new node containing a comment. """
1681 ret = libxml2mod.xmlNewComment(content)
1682 if ret is None:raise treeError('xmlNewComment() failed')
1683 return xmlNode(_obj=ret)
1685 def newDoc(version):
1686 """Creates a new XML document """
1687 ret = libxml2mod.xmlNewDoc(version)
1688 if ret is None:raise treeError('xmlNewDoc() failed')
1689 return xmlDoc(_obj=ret)
1691 def newPI(name, content):
1692 """Creation of a processing instruction element. Use
1693 xmlDocNewPI preferably to get string interning """
1694 ret = libxml2mod.xmlNewPI(name, content)
1695 if ret is None:raise treeError('xmlNewPI() failed')
1696 return xmlNode(_obj=ret)
1698 def newText(content):
1699 """Creation of a new text node. """
1700 ret = libxml2mod.xmlNewText(content)
1701 if ret is None:raise treeError('xmlNewText() failed')
1702 return xmlNode(_obj=ret)
1704 def newTextLen(content, len):
1705 """Creation of a new text node with an extra parameter for the
1706 content's length """
1707 ret = libxml2mod.xmlNewTextLen(content, len)
1708 if ret is None:raise treeError('xmlNewTextLen() failed')
1709 return xmlNode(_obj=ret)
1711 def setCompressMode(mode):
1712 """set the default compression mode used, ZLIB based Correct
1713 values: 0 (uncompressed) to 9 (max compression) """
1714 libxml2mod.xmlSetCompressMode(mode)
1716 def validateNCName(value, space):
1717 """Check that a value conforms to the lexical space of NCName """
1718 ret = libxml2mod.xmlValidateNCName(value, space)
1721 def validateNMToken(value, space):
1722 """Check that a value conforms to the lexical space of NMToken """
1723 ret = libxml2mod.xmlValidateNMToken(value, space)
1726 def validateName(value, space):
1727 """Check that a value conforms to the lexical space of Name """
1728 ret = libxml2mod.xmlValidateName(value, space)
1731 def validateQName(value, space):
1732 """Check that a value conforms to the lexical space of QName """
1733 ret = libxml2mod.xmlValidateQName(value, space)
1737 # Functions from module uri
1741 """Escaping routine, does not do validity checks ! It will try
1742 to escape the chars needing this, but this is heuristic
1743 based it's impossible to be sure. """
1744 ret = libxml2mod.xmlURIEscape(str)
1747 def URIEscapeStr(str, list):
1748 """This routine escapes a string to hex, ignoring reserved
1749 characters (a-z) and the characters in the exception list. """
1750 ret = libxml2mod.xmlURIEscapeStr(str, list)
1753 def URIUnescapeString(str, len, target):
1754 """Unescaping routine, but does not check that the string is
1755 an URI. The output is a direct unsigned char translation of
1756 %XX values (no encoding) Note that the length of the result
1757 can only be smaller or same size as the input string. """
1758 ret = libxml2mod.xmlURIUnescapeString(str, len, target)
1761 def buildRelativeURI(URI, base):
1762 """Expresses the URI of the reference in terms relative to the
1763 base. Some examples of this operation include: base =
1764 "http://site1.com/docs/book1.html" URI input
1765 URI returned docs/pic1.gif pic1.gif
1766 docs/img/pic1.gif img/pic1.gif img/pic1.gif
1767 ../img/pic1.gif http://site1.com/docs/pic1.gif pic1.gif
1768 http://site2.com/docs/pic1.gif
1769 http://site2.com/docs/pic1.gif base = "docs/book1.html"
1770 URI input URI returned docs/pic1.gif
1771 pic1.gif docs/img/pic1.gif img/pic1.gif
1772 img/pic1.gif ../img/pic1.gif
1773 http://site1.com/docs/pic1.gif
1774 http://site1.com/docs/pic1.gif Note: if the URI reference
1775 is really wierd or complicated, it may be worthwhile to
1776 first convert it into a "nice" one by calling xmlBuildURI
1777 (using 'base') before calling this routine, since this
1778 routine (for reasonable efficiency) assumes URI has already
1779 been through some validation. """
1780 ret = libxml2mod.xmlBuildRelativeURI(URI, base)
1783 def buildURI(URI, base):
1784 """Computes he final URI of the reference done by checking
1785 that the given URI is valid, and building the final URI
1786 using the base URI. This is processed according to section
1787 5.2 of the RFC 2396 5.2. Resolving Relative References to
1789 ret = libxml2mod.xmlBuildURI(URI, base)
1792 def canonicPath(path):
1793 """Constructs a canonic path from the specified path. """
1794 ret = libxml2mod.xmlCanonicPath(path)
1798 """Simply creates an empty xmlURI """
1799 ret = libxml2mod.xmlCreateURI()
1800 if ret is None:raise uriError('xmlCreateURI() failed')
1801 return URI(_obj=ret)
1803 def normalizeURIPath(path):
1804 """Applies the 5 normalization steps to a path string--that
1805 is, RFC 2396 Section 5.2, steps 6.c through 6.g.
1806 Normalization occurs directly on the string, no new
1807 allocation is done """
1808 ret = libxml2mod.xmlNormalizeURIPath(path)
1812 """Parse an URI based on RFC 3986 URI-reference = [
1813 absoluteURI | relativeURI ] [ "#" fragment ] """
1814 ret = libxml2mod.xmlParseURI(str)
1815 if ret is None:raise uriError('xmlParseURI() failed')
1816 return URI(_obj=ret)
1818 def parseURIRaw(str, raw):
1819 """Parse an URI but allows to keep intact the original
1820 fragments. URI-reference = URI / relative-ref """
1821 ret = libxml2mod.xmlParseURIRaw(str, raw)
1822 if ret is None:raise uriError('xmlParseURIRaw() failed')
1823 return URI(_obj=ret)
1825 def pathToURI(path):
1826 """Constructs an URI expressing the existing path """
1827 ret = libxml2mod.xmlPathToURI(path)
1831 # Functions from module valid
1835 """Allocate a validation context structure. """
1836 ret = libxml2mod.xmlNewValidCtxt()
1837 if ret is None:raise treeError('xmlNewValidCtxt() failed')
1838 return ValidCtxt(_obj=ret)
1840 def validateNameValue(value):
1841 """Validate that the given value match Name production """
1842 ret = libxml2mod.xmlValidateNameValue(value)
1845 def validateNamesValue(value):
1846 """Validate that the given value match Names production """
1847 ret = libxml2mod.xmlValidateNamesValue(value)
1850 def validateNmtokenValue(value):
1851 """Validate that the given value match Nmtoken production [
1852 VC: Name Token ] """
1853 ret = libxml2mod.xmlValidateNmtokenValue(value)
1856 def validateNmtokensValue(value):
1857 """Validate that the given value match Nmtokens production [
1858 VC: Name Token ] """
1859 ret = libxml2mod.xmlValidateNmtokensValue(value)
1863 # Functions from module xmlIO
1866 def checkFilename(path):
1867 """function checks to see if @path is a valid source (file,
1868 socket...) for XML. if stat is not available on the target
1870 ret = libxml2mod.xmlCheckFilename(path)
1873 def cleanupInputCallbacks():
1874 """clears the entire input callback table. this includes the
1875 compiled-in I/O. """
1876 libxml2mod.xmlCleanupInputCallbacks()
1878 def cleanupOutputCallbacks():
1879 """clears the entire output callback table. this includes the
1880 compiled-in I/O callbacks. """
1881 libxml2mod.xmlCleanupOutputCallbacks()
1883 def fileMatch(filename):
1884 """input from FILE * """
1885 ret = libxml2mod.xmlFileMatch(filename)
1888 def iOFTPMatch(filename):
1889 """check if the URI matches an FTP one """
1890 ret = libxml2mod.xmlIOFTPMatch(filename)
1893 def iOHTTPMatch(filename):
1894 """check if the URI matches an HTTP one """
1895 ret = libxml2mod.xmlIOHTTPMatch(filename)
1898 def normalizeWindowsPath(path):
1899 """This function is obsolete. Please see xmlURIFromPath in
1900 uri.c for a better solution. """
1901 ret = libxml2mod.xmlNormalizeWindowsPath(path)
1904 def parserGetDirectory(filename):
1905 """lookup the directory for that file """
1906 ret = libxml2mod.xmlParserGetDirectory(filename)
1909 def registerDefaultInputCallbacks():
1910 """Registers the default compiled-in I/O handlers. """
1911 libxml2mod.xmlRegisterDefaultInputCallbacks()
1913 def registerDefaultOutputCallbacks():
1914 """Registers the default compiled-in I/O handlers. """
1915 libxml2mod.xmlRegisterDefaultOutputCallbacks()
1917 def registerHTTPPostCallbacks():
1918 """By default, libxml submits HTTP output requests using the
1919 "PUT" method. Calling this method changes the HTTP output
1920 method to use the "POST" method instead. """
1921 libxml2mod.xmlRegisterHTTPPostCallbacks()
1924 # Functions from module xmlerror
1928 """Get the last global error registered. This is per thread if
1929 compiled with thread support. """
1930 ret = libxml2mod.xmlGetLastError()
1931 if ret is None:raise treeError('xmlGetLastError() failed')
1932 return Error(_obj=ret)
1934 def resetLastError():
1935 """Cleanup the last global error registered. For parsing error
1936 this does not change the well-formedness result. """
1937 libxml2mod.xmlResetLastError()
1940 # Functions from module xmlreader
1943 def newTextReaderFilename(URI):
1944 """Create an xmlTextReader structure fed with the resource at
1946 ret = libxml2mod.xmlNewTextReaderFilename(URI)
1947 if ret is None:raise treeError('xmlNewTextReaderFilename() failed')
1948 return xmlTextReader(_obj=ret)
1950 def readerForDoc(cur, URL, encoding, options):
1951 """Create an xmltextReader for an XML in-memory document. The
1952 parsing flags @options are a combination of xmlParserOption. """
1953 ret = libxml2mod.xmlReaderForDoc(cur, URL, encoding, options)
1954 if ret is None:raise treeError('xmlReaderForDoc() failed')
1955 return xmlTextReader(_obj=ret)
1957 def readerForFd(fd, URL, encoding, options):
1958 """Create an xmltextReader for an XML from a file descriptor.
1959 The parsing flags @options are a combination of
1960 xmlParserOption. NOTE that the file descriptor will not be
1961 closed when the reader is closed or reset. """
1962 ret = libxml2mod.xmlReaderForFd(fd, URL, encoding, options)
1963 if ret is None:raise treeError('xmlReaderForFd() failed')
1964 return xmlTextReader(_obj=ret)
1966 def readerForFile(filename, encoding, options):
1967 """parse an XML file from the filesystem or the network. The
1968 parsing flags @options are a combination of xmlParserOption. """
1969 ret = libxml2mod.xmlReaderForFile(filename, encoding, options)
1970 if ret is None:raise treeError('xmlReaderForFile() failed')
1971 return xmlTextReader(_obj=ret)
1973 def readerForMemory(buffer, size, URL, encoding, options):
1974 """Create an xmltextReader for an XML in-memory document. The
1975 parsing flags @options are a combination of xmlParserOption. """
1976 ret = libxml2mod.xmlReaderForMemory(buffer, size, URL, encoding, options)
1977 if ret is None:raise treeError('xmlReaderForMemory() failed')
1978 return xmlTextReader(_obj=ret)
1981 # Functions from module xmlregexp
1984 def regexpCompile(regexp):
1985 """Parses a regular expression conforming to XML Schemas Part
1986 2 Datatype Appendix F and builds an automata suitable for
1987 testing strings against that regular expression """
1988 ret = libxml2mod.xmlRegexpCompile(regexp)
1989 if ret is None:raise treeError('xmlRegexpCompile() failed')
1990 return xmlReg(_obj=ret)
1993 # Functions from module xmlschemas
1996 def schemaNewMemParserCtxt(buffer, size):
1997 """Create an XML Schemas parse context for that memory buffer
1998 expected to contain an XML Schemas file. """
1999 ret = libxml2mod.xmlSchemaNewMemParserCtxt(buffer, size)
2000 if ret is None:raise parserError('xmlSchemaNewMemParserCtxt() failed')
2001 return SchemaParserCtxt(_obj=ret)
2003 def schemaNewParserCtxt(URL):
2004 """Create an XML Schemas parse context for that file/resource
2005 expected to contain an XML Schemas file. """
2006 ret = libxml2mod.xmlSchemaNewParserCtxt(URL)
2007 if ret is None:raise parserError('xmlSchemaNewParserCtxt() failed')
2008 return SchemaParserCtxt(_obj=ret)
2011 # Functions from module xmlschemastypes
2014 def schemaCleanupTypes():
2015 """Cleanup the default XML Schemas type library """
2016 libxml2mod.xmlSchemaCleanupTypes()
2018 def schemaCollapseString(value):
2019 """Removes and normalize white spaces in the string """
2020 ret = libxml2mod.xmlSchemaCollapseString(value)
2023 def schemaInitTypes():
2024 """Initialize the default XML Schemas type library """
2025 libxml2mod.xmlSchemaInitTypes()
2027 def schemaWhiteSpaceReplace(value):
2028 """Replaces 0xd, 0x9 and 0xa with a space. """
2029 ret = libxml2mod.xmlSchemaWhiteSpaceReplace(value)
2033 # Functions from module xmlstring
2036 def UTF8Charcmp(utf1, utf2):
2037 """compares the two UCS4 values """
2038 ret = libxml2mod.xmlUTF8Charcmp(utf1, utf2)
2042 """calculates the internal size of a UTF8 character """
2043 ret = libxml2mod.xmlUTF8Size(utf)
2046 def UTF8Strlen(utf):
2047 """compute the length of an UTF8 string, it doesn't do a full
2048 UTF8 checking of the content of the string. """
2049 ret = libxml2mod.xmlUTF8Strlen(utf)
2052 def UTF8Strloc(utf, utfchar):
2053 """a function to provide the relative location of a UTF8 char """
2054 ret = libxml2mod.xmlUTF8Strloc(utf, utfchar)
2057 def UTF8Strndup(utf, len):
2058 """a strndup for array of UTF8's """
2059 ret = libxml2mod.xmlUTF8Strndup(utf, len)
2062 def UTF8Strpos(utf, pos):
2063 """a function to provide the equivalent of fetching a
2064 character from a string array """
2065 ret = libxml2mod.xmlUTF8Strpos(utf, pos)
2068 def UTF8Strsize(utf, len):
2069 """storage size of an UTF8 string the behaviour is not
2070 garanteed if the input string is not UTF-8 """
2071 ret = libxml2mod.xmlUTF8Strsize(utf, len)
2074 def UTF8Strsub(utf, start, len):
2075 """Create a substring from a given UTF-8 string Note:
2076 positions are given in units of UTF-8 chars """
2077 ret = libxml2mod.xmlUTF8Strsub(utf, start, len)
2081 """Checks @utf for being valid UTF-8. @utf is assumed to be
2082 null-terminated. This function is not super-strict, as it
2083 will allow longer UTF-8 sequences than necessary. Note that
2084 Java is capable of producing these sequences if provoked.
2085 Also note, this routine checks for the 4-byte maximum size,
2086 but does not check for 0x10ffff maximum value. """
2087 ret = libxml2mod.xmlCheckUTF8(utf)
2091 # Functions from module xmlunicode
2094 def uCSIsAegeanNumbers(code):
2095 """Check whether the character is part of AegeanNumbers UCS
2097 ret = libxml2mod.xmlUCSIsAegeanNumbers(code)
2100 def uCSIsAlphabeticPresentationForms(code):
2101 """Check whether the character is part of
2102 AlphabeticPresentationForms UCS Block """
2103 ret = libxml2mod.xmlUCSIsAlphabeticPresentationForms(code)
2106 def uCSIsArabic(code):
2107 """Check whether the character is part of Arabic UCS Block """
2108 ret = libxml2mod.xmlUCSIsArabic(code)
2111 def uCSIsArabicPresentationFormsA(code):
2112 """Check whether the character is part of
2113 ArabicPresentationForms-A UCS Block """
2114 ret = libxml2mod.xmlUCSIsArabicPresentationFormsA(code)
2117 def uCSIsArabicPresentationFormsB(code):
2118 """Check whether the character is part of
2119 ArabicPresentationForms-B UCS Block """
2120 ret = libxml2mod.xmlUCSIsArabicPresentationFormsB(code)
2123 def uCSIsArmenian(code):
2124 """Check whether the character is part of Armenian UCS Block """
2125 ret = libxml2mod.xmlUCSIsArmenian(code)
2128 def uCSIsArrows(code):
2129 """Check whether the character is part of Arrows UCS Block """
2130 ret = libxml2mod.xmlUCSIsArrows(code)
2133 def uCSIsBasicLatin(code):
2134 """Check whether the character is part of BasicLatin UCS Block """
2135 ret = libxml2mod.xmlUCSIsBasicLatin(code)
2138 def uCSIsBengali(code):
2139 """Check whether the character is part of Bengali UCS Block """
2140 ret = libxml2mod.xmlUCSIsBengali(code)
2143 def uCSIsBlock(code, block):
2144 """Check whether the character is part of the UCS Block """
2145 ret = libxml2mod.xmlUCSIsBlock(code, block)
2148 def uCSIsBlockElements(code):
2149 """Check whether the character is part of BlockElements UCS
2151 ret = libxml2mod.xmlUCSIsBlockElements(code)
2154 def uCSIsBopomofo(code):
2155 """Check whether the character is part of Bopomofo UCS Block """
2156 ret = libxml2mod.xmlUCSIsBopomofo(code)
2159 def uCSIsBopomofoExtended(code):
2160 """Check whether the character is part of BopomofoExtended UCS
2162 ret = libxml2mod.xmlUCSIsBopomofoExtended(code)
2165 def uCSIsBoxDrawing(code):
2166 """Check whether the character is part of BoxDrawing UCS Block """
2167 ret = libxml2mod.xmlUCSIsBoxDrawing(code)
2170 def uCSIsBraillePatterns(code):
2171 """Check whether the character is part of BraillePatterns UCS
2173 ret = libxml2mod.xmlUCSIsBraillePatterns(code)
2176 def uCSIsBuhid(code):
2177 """Check whether the character is part of Buhid UCS Block """
2178 ret = libxml2mod.xmlUCSIsBuhid(code)
2181 def uCSIsByzantineMusicalSymbols(code):
2182 """Check whether the character is part of
2183 ByzantineMusicalSymbols UCS Block """
2184 ret = libxml2mod.xmlUCSIsByzantineMusicalSymbols(code)
2187 def uCSIsCJKCompatibility(code):
2188 """Check whether the character is part of CJKCompatibility UCS
2190 ret = libxml2mod.xmlUCSIsCJKCompatibility(code)
2193 def uCSIsCJKCompatibilityForms(code):
2194 """Check whether the character is part of
2195 CJKCompatibilityForms UCS Block """
2196 ret = libxml2mod.xmlUCSIsCJKCompatibilityForms(code)
2199 def uCSIsCJKCompatibilityIdeographs(code):
2200 """Check whether the character is part of
2201 CJKCompatibilityIdeographs UCS Block """
2202 ret = libxml2mod.xmlUCSIsCJKCompatibilityIdeographs(code)
2205 def uCSIsCJKCompatibilityIdeographsSupplement(code):
2206 """Check whether the character is part of
2207 CJKCompatibilityIdeographsSupplement UCS Block """
2208 ret = libxml2mod.xmlUCSIsCJKCompatibilityIdeographsSupplement(code)
2211 def uCSIsCJKRadicalsSupplement(code):
2212 """Check whether the character is part of
2213 CJKRadicalsSupplement UCS Block """
2214 ret = libxml2mod.xmlUCSIsCJKRadicalsSupplement(code)
2217 def uCSIsCJKSymbolsandPunctuation(code):
2218 """Check whether the character is part of
2219 CJKSymbolsandPunctuation UCS Block """
2220 ret = libxml2mod.xmlUCSIsCJKSymbolsandPunctuation(code)
2223 def uCSIsCJKUnifiedIdeographs(code):
2224 """Check whether the character is part of CJKUnifiedIdeographs
2226 ret = libxml2mod.xmlUCSIsCJKUnifiedIdeographs(code)
2229 def uCSIsCJKUnifiedIdeographsExtensionA(code):
2230 """Check whether the character is part of
2231 CJKUnifiedIdeographsExtensionA UCS Block """
2232 ret = libxml2mod.xmlUCSIsCJKUnifiedIdeographsExtensionA(code)
2235 def uCSIsCJKUnifiedIdeographsExtensionB(code):
2236 """Check whether the character is part of
2237 CJKUnifiedIdeographsExtensionB UCS Block """
2238 ret = libxml2mod.xmlUCSIsCJKUnifiedIdeographsExtensionB(code)
2241 def uCSIsCat(code, cat):
2242 """Check whether the character is part of the UCS Category """
2243 ret = libxml2mod.xmlUCSIsCat(code, cat)
2246 def uCSIsCatC(code):
2247 """Check whether the character is part of C UCS Category """
2248 ret = libxml2mod.xmlUCSIsCatC(code)
2251 def uCSIsCatCc(code):
2252 """Check whether the character is part of Cc UCS Category """
2253 ret = libxml2mod.xmlUCSIsCatCc(code)
2256 def uCSIsCatCf(code):
2257 """Check whether the character is part of Cf UCS Category """
2258 ret = libxml2mod.xmlUCSIsCatCf(code)
2261 def uCSIsCatCo(code):
2262 """Check whether the character is part of Co UCS Category """
2263 ret = libxml2mod.xmlUCSIsCatCo(code)
2266 def uCSIsCatCs(code):
2267 """Check whether the character is part of Cs UCS Category """
2268 ret = libxml2mod.xmlUCSIsCatCs(code)
2271 def uCSIsCatL(code):
2272 """Check whether the character is part of L UCS Category """
2273 ret = libxml2mod.xmlUCSIsCatL(code)
2276 def uCSIsCatLl(code):
2277 """Check whether the character is part of Ll UCS Category """
2278 ret = libxml2mod.xmlUCSIsCatLl(code)
2281 def uCSIsCatLm(code):
2282 """Check whether the character is part of Lm UCS Category """
2283 ret = libxml2mod.xmlUCSIsCatLm(code)
2286 def uCSIsCatLo(code):
2287 """Check whether the character is part of Lo UCS Category """
2288 ret = libxml2mod.xmlUCSIsCatLo(code)
2291 def uCSIsCatLt(code):
2292 """Check whether the character is part of Lt UCS Category """
2293 ret = libxml2mod.xmlUCSIsCatLt(code)
2296 def uCSIsCatLu(code):
2297 """Check whether the character is part of Lu UCS Category """
2298 ret = libxml2mod.xmlUCSIsCatLu(code)
2301 def uCSIsCatM(code):
2302 """Check whether the character is part of M UCS Category """
2303 ret = libxml2mod.xmlUCSIsCatM(code)
2306 def uCSIsCatMc(code):
2307 """Check whether the character is part of Mc UCS Category """
2308 ret = libxml2mod.xmlUCSIsCatMc(code)
2311 def uCSIsCatMe(code):
2312 """Check whether the character is part of Me UCS Category """
2313 ret = libxml2mod.xmlUCSIsCatMe(code)
2316 def uCSIsCatMn(code):
2317 """Check whether the character is part of Mn UCS Category """
2318 ret = libxml2mod.xmlUCSIsCatMn(code)
2321 def uCSIsCatN(code):
2322 """Check whether the character is part of N UCS Category """
2323 ret = libxml2mod.xmlUCSIsCatN(code)
2326 def uCSIsCatNd(code):
2327 """Check whether the character is part of Nd UCS Category """
2328 ret = libxml2mod.xmlUCSIsCatNd(code)
2331 def uCSIsCatNl(code):
2332 """Check whether the character is part of Nl UCS Category """
2333 ret = libxml2mod.xmlUCSIsCatNl(code)
2336 def uCSIsCatNo(code):
2337 """Check whether the character is part of No UCS Category """
2338 ret = libxml2mod.xmlUCSIsCatNo(code)
2341 def uCSIsCatP(code):
2342 """Check whether the character is part of P UCS Category """
2343 ret = libxml2mod.xmlUCSIsCatP(code)
2346 def uCSIsCatPc(code):
2347 """Check whether the character is part of Pc UCS Category """
2348 ret = libxml2mod.xmlUCSIsCatPc(code)
2351 def uCSIsCatPd(code):
2352 """Check whether the character is part of Pd UCS Category """
2353 ret = libxml2mod.xmlUCSIsCatPd(code)
2356 def uCSIsCatPe(code):
2357 """Check whether the character is part of Pe UCS Category """
2358 ret = libxml2mod.xmlUCSIsCatPe(code)
2361 def uCSIsCatPf(code):
2362 """Check whether the character is part of Pf UCS Category """
2363 ret = libxml2mod.xmlUCSIsCatPf(code)
2366 def uCSIsCatPi(code):
2367 """Check whether the character is part of Pi UCS Category """
2368 ret = libxml2mod.xmlUCSIsCatPi(code)
2371 def uCSIsCatPo(code):
2372 """Check whether the character is part of Po UCS Category """
2373 ret = libxml2mod.xmlUCSIsCatPo(code)
2376 def uCSIsCatPs(code):
2377 """Check whether the character is part of Ps UCS Category """
2378 ret = libxml2mod.xmlUCSIsCatPs(code)
2381 def uCSIsCatS(code):
2382 """Check whether the character is part of S UCS Category """
2383 ret = libxml2mod.xmlUCSIsCatS(code)
2386 def uCSIsCatSc(code):
2387 """Check whether the character is part of Sc UCS Category """
2388 ret = libxml2mod.xmlUCSIsCatSc(code)
2391 def uCSIsCatSk(code):
2392 """Check whether the character is part of Sk UCS Category """
2393 ret = libxml2mod.xmlUCSIsCatSk(code)
2396 def uCSIsCatSm(code):
2397 """Check whether the character is part of Sm UCS Category """
2398 ret = libxml2mod.xmlUCSIsCatSm(code)
2401 def uCSIsCatSo(code):
2402 """Check whether the character is part of So UCS Category """
2403 ret = libxml2mod.xmlUCSIsCatSo(code)
2406 def uCSIsCatZ(code):
2407 """Check whether the character is part of Z UCS Category """
2408 ret = libxml2mod.xmlUCSIsCatZ(code)
2411 def uCSIsCatZl(code):
2412 """Check whether the character is part of Zl UCS Category """
2413 ret = libxml2mod.xmlUCSIsCatZl(code)
2416 def uCSIsCatZp(code):
2417 """Check whether the character is part of Zp UCS Category """
2418 ret = libxml2mod.xmlUCSIsCatZp(code)
2421 def uCSIsCatZs(code):
2422 """Check whether the character is part of Zs UCS Category """
2423 ret = libxml2mod.xmlUCSIsCatZs(code)
2426 def uCSIsCherokee(code):
2427 """Check whether the character is part of Cherokee UCS Block """
2428 ret = libxml2mod.xmlUCSIsCherokee(code)
2431 def uCSIsCombiningDiacriticalMarks(code):
2432 """Check whether the character is part of
2433 CombiningDiacriticalMarks UCS Block """
2434 ret = libxml2mod.xmlUCSIsCombiningDiacriticalMarks(code)
2437 def uCSIsCombiningDiacriticalMarksforSymbols(code):
2438 """Check whether the character is part of
2439 CombiningDiacriticalMarksforSymbols UCS Block """
2440 ret = libxml2mod.xmlUCSIsCombiningDiacriticalMarksforSymbols(code)
2443 def uCSIsCombiningHalfMarks(code):
2444 """Check whether the character is part of CombiningHalfMarks
2446 ret = libxml2mod.xmlUCSIsCombiningHalfMarks(code)
2449 def uCSIsCombiningMarksforSymbols(code):
2450 """Check whether the character is part of
2451 CombiningMarksforSymbols UCS Block """
2452 ret = libxml2mod.xmlUCSIsCombiningMarksforSymbols(code)
2455 def uCSIsControlPictures(code):
2456 """Check whether the character is part of ControlPictures UCS
2458 ret = libxml2mod.xmlUCSIsControlPictures(code)
2461 def uCSIsCurrencySymbols(code):
2462 """Check whether the character is part of CurrencySymbols UCS
2464 ret = libxml2mod.xmlUCSIsCurrencySymbols(code)
2467 def uCSIsCypriotSyllabary(code):
2468 """Check whether the character is part of CypriotSyllabary UCS
2470 ret = libxml2mod.xmlUCSIsCypriotSyllabary(code)
2473 def uCSIsCyrillic(code):
2474 """Check whether the character is part of Cyrillic UCS Block """
2475 ret = libxml2mod.xmlUCSIsCyrillic(code)
2478 def uCSIsCyrillicSupplement(code):
2479 """Check whether the character is part of CyrillicSupplement
2481 ret = libxml2mod.xmlUCSIsCyrillicSupplement(code)
2484 def uCSIsDeseret(code):
2485 """Check whether the character is part of Deseret UCS Block """
2486 ret = libxml2mod.xmlUCSIsDeseret(code)
2489 def uCSIsDevanagari(code):
2490 """Check whether the character is part of Devanagari UCS Block """
2491 ret = libxml2mod.xmlUCSIsDevanagari(code)
2494 def uCSIsDingbats(code):
2495 """Check whether the character is part of Dingbats UCS Block """
2496 ret = libxml2mod.xmlUCSIsDingbats(code)
2499 def uCSIsEnclosedAlphanumerics(code):
2500 """Check whether the character is part of
2501 EnclosedAlphanumerics UCS Block """
2502 ret = libxml2mod.xmlUCSIsEnclosedAlphanumerics(code)
2505 def uCSIsEnclosedCJKLettersandMonths(code):
2506 """Check whether the character is part of
2507 EnclosedCJKLettersandMonths UCS Block """
2508 ret = libxml2mod.xmlUCSIsEnclosedCJKLettersandMonths(code)
2511 def uCSIsEthiopic(code):
2512 """Check whether the character is part of Ethiopic UCS Block """
2513 ret = libxml2mod.xmlUCSIsEthiopic(code)
2516 def uCSIsGeneralPunctuation(code):
2517 """Check whether the character is part of GeneralPunctuation
2519 ret = libxml2mod.xmlUCSIsGeneralPunctuation(code)
2522 def uCSIsGeometricShapes(code):
2523 """Check whether the character is part of GeometricShapes UCS
2525 ret = libxml2mod.xmlUCSIsGeometricShapes(code)
2528 def uCSIsGeorgian(code):
2529 """Check whether the character is part of Georgian UCS Block """
2530 ret = libxml2mod.xmlUCSIsGeorgian(code)
2533 def uCSIsGothic(code):
2534 """Check whether the character is part of Gothic UCS Block """
2535 ret = libxml2mod.xmlUCSIsGothic(code)
2538 def uCSIsGreek(code):
2539 """Check whether the character is part of Greek UCS Block """
2540 ret = libxml2mod.xmlUCSIsGreek(code)
2543 def uCSIsGreekExtended(code):
2544 """Check whether the character is part of GreekExtended UCS
2546 ret = libxml2mod.xmlUCSIsGreekExtended(code)
2549 def uCSIsGreekandCoptic(code):
2550 """Check whether the character is part of GreekandCoptic UCS
2552 ret = libxml2mod.xmlUCSIsGreekandCoptic(code)
2555 def uCSIsGujarati(code):
2556 """Check whether the character is part of Gujarati UCS Block """
2557 ret = libxml2mod.xmlUCSIsGujarati(code)
2560 def uCSIsGurmukhi(code):
2561 """Check whether the character is part of Gurmukhi UCS Block """
2562 ret = libxml2mod.xmlUCSIsGurmukhi(code)
2565 def uCSIsHalfwidthandFullwidthForms(code):
2566 """Check whether the character is part of
2567 HalfwidthandFullwidthForms UCS Block """
2568 ret = libxml2mod.xmlUCSIsHalfwidthandFullwidthForms(code)
2571 def uCSIsHangulCompatibilityJamo(code):
2572 """Check whether the character is part of
2573 HangulCompatibilityJamo UCS Block """
2574 ret = libxml2mod.xmlUCSIsHangulCompatibilityJamo(code)
2577 def uCSIsHangulJamo(code):
2578 """Check whether the character is part of HangulJamo UCS Block """
2579 ret = libxml2mod.xmlUCSIsHangulJamo(code)
2582 def uCSIsHangulSyllables(code):
2583 """Check whether the character is part of HangulSyllables UCS
2585 ret = libxml2mod.xmlUCSIsHangulSyllables(code)
2588 def uCSIsHanunoo(code):
2589 """Check whether the character is part of Hanunoo UCS Block """
2590 ret = libxml2mod.xmlUCSIsHanunoo(code)
2593 def uCSIsHebrew(code):
2594 """Check whether the character is part of Hebrew UCS Block """
2595 ret = libxml2mod.xmlUCSIsHebrew(code)
2598 def uCSIsHighPrivateUseSurrogates(code):
2599 """Check whether the character is part of
2600 HighPrivateUseSurrogates UCS Block """
2601 ret = libxml2mod.xmlUCSIsHighPrivateUseSurrogates(code)
2604 def uCSIsHighSurrogates(code):
2605 """Check whether the character is part of HighSurrogates UCS
2607 ret = libxml2mod.xmlUCSIsHighSurrogates(code)
2610 def uCSIsHiragana(code):
2611 """Check whether the character is part of Hiragana UCS Block """
2612 ret = libxml2mod.xmlUCSIsHiragana(code)
2615 def uCSIsIPAExtensions(code):
2616 """Check whether the character is part of IPAExtensions UCS
2618 ret = libxml2mod.xmlUCSIsIPAExtensions(code)
2621 def uCSIsIdeographicDescriptionCharacters(code):
2622 """Check whether the character is part of
2623 IdeographicDescriptionCharacters UCS Block """
2624 ret = libxml2mod.xmlUCSIsIdeographicDescriptionCharacters(code)
2627 def uCSIsKanbun(code):
2628 """Check whether the character is part of Kanbun UCS Block """
2629 ret = libxml2mod.xmlUCSIsKanbun(code)
2632 def uCSIsKangxiRadicals(code):
2633 """Check whether the character is part of KangxiRadicals UCS
2635 ret = libxml2mod.xmlUCSIsKangxiRadicals(code)
2638 def uCSIsKannada(code):
2639 """Check whether the character is part of Kannada UCS Block """
2640 ret = libxml2mod.xmlUCSIsKannada(code)
2643 def uCSIsKatakana(code):
2644 """Check whether the character is part of Katakana UCS Block """
2645 ret = libxml2mod.xmlUCSIsKatakana(code)
2648 def uCSIsKatakanaPhoneticExtensions(code):
2649 """Check whether the character is part of
2650 KatakanaPhoneticExtensions UCS Block """
2651 ret = libxml2mod.xmlUCSIsKatakanaPhoneticExtensions(code)
2654 def uCSIsKhmer(code):
2655 """Check whether the character is part of Khmer UCS Block """
2656 ret = libxml2mod.xmlUCSIsKhmer(code)
2659 def uCSIsKhmerSymbols(code):
2660 """Check whether the character is part of KhmerSymbols UCS
2662 ret = libxml2mod.xmlUCSIsKhmerSymbols(code)
2666 """Check whether the character is part of Lao UCS Block """
2667 ret = libxml2mod.xmlUCSIsLao(code)
2670 def uCSIsLatin1Supplement(code):
2671 """Check whether the character is part of Latin-1Supplement
2673 ret = libxml2mod.xmlUCSIsLatin1Supplement(code)
2676 def uCSIsLatinExtendedA(code):
2677 """Check whether the character is part of LatinExtended-A UCS
2679 ret = libxml2mod.xmlUCSIsLatinExtendedA(code)
2682 def uCSIsLatinExtendedAdditional(code):
2683 """Check whether the character is part of
2684 LatinExtendedAdditional UCS Block """
2685 ret = libxml2mod.xmlUCSIsLatinExtendedAdditional(code)
2688 def uCSIsLatinExtendedB(code):
2689 """Check whether the character is part of LatinExtended-B UCS
2691 ret = libxml2mod.xmlUCSIsLatinExtendedB(code)
2694 def uCSIsLetterlikeSymbols(code):
2695 """Check whether the character is part of LetterlikeSymbols
2697 ret = libxml2mod.xmlUCSIsLetterlikeSymbols(code)
2700 def uCSIsLimbu(code):
2701 """Check whether the character is part of Limbu UCS Block """
2702 ret = libxml2mod.xmlUCSIsLimbu(code)
2705 def uCSIsLinearBIdeograms(code):
2706 """Check whether the character is part of LinearBIdeograms UCS
2708 ret = libxml2mod.xmlUCSIsLinearBIdeograms(code)
2711 def uCSIsLinearBSyllabary(code):
2712 """Check whether the character is part of LinearBSyllabary UCS
2714 ret = libxml2mod.xmlUCSIsLinearBSyllabary(code)
2717 def uCSIsLowSurrogates(code):
2718 """Check whether the character is part of LowSurrogates UCS
2720 ret = libxml2mod.xmlUCSIsLowSurrogates(code)
2723 def uCSIsMalayalam(code):
2724 """Check whether the character is part of Malayalam UCS Block """
2725 ret = libxml2mod.xmlUCSIsMalayalam(code)
2728 def uCSIsMathematicalAlphanumericSymbols(code):
2729 """Check whether the character is part of
2730 MathematicalAlphanumericSymbols UCS Block """
2731 ret = libxml2mod.xmlUCSIsMathematicalAlphanumericSymbols(code)
2734 def uCSIsMathematicalOperators(code):
2735 """Check whether the character is part of
2736 MathematicalOperators UCS Block """
2737 ret = libxml2mod.xmlUCSIsMathematicalOperators(code)
2740 def uCSIsMiscellaneousMathematicalSymbolsA(code):
2741 """Check whether the character is part of
2742 MiscellaneousMathematicalSymbols-A UCS Block """
2743 ret = libxml2mod.xmlUCSIsMiscellaneousMathematicalSymbolsA(code)
2746 def uCSIsMiscellaneousMathematicalSymbolsB(code):
2747 """Check whether the character is part of
2748 MiscellaneousMathematicalSymbols-B UCS Block """
2749 ret = libxml2mod.xmlUCSIsMiscellaneousMathematicalSymbolsB(code)
2752 def uCSIsMiscellaneousSymbols(code):
2753 """Check whether the character is part of MiscellaneousSymbols
2755 ret = libxml2mod.xmlUCSIsMiscellaneousSymbols(code)
2758 def uCSIsMiscellaneousSymbolsandArrows(code):
2759 """Check whether the character is part of
2760 MiscellaneousSymbolsandArrows UCS Block """
2761 ret = libxml2mod.xmlUCSIsMiscellaneousSymbolsandArrows(code)
2764 def uCSIsMiscellaneousTechnical(code):
2765 """Check whether the character is part of
2766 MiscellaneousTechnical UCS Block """
2767 ret = libxml2mod.xmlUCSIsMiscellaneousTechnical(code)
2770 def uCSIsMongolian(code):
2771 """Check whether the character is part of Mongolian UCS Block """
2772 ret = libxml2mod.xmlUCSIsMongolian(code)
2775 def uCSIsMusicalSymbols(code):
2776 """Check whether the character is part of MusicalSymbols UCS
2778 ret = libxml2mod.xmlUCSIsMusicalSymbols(code)
2781 def uCSIsMyanmar(code):
2782 """Check whether the character is part of Myanmar UCS Block """
2783 ret = libxml2mod.xmlUCSIsMyanmar(code)
2786 def uCSIsNumberForms(code):
2787 """Check whether the character is part of NumberForms UCS Block """
2788 ret = libxml2mod.xmlUCSIsNumberForms(code)
2791 def uCSIsOgham(code):
2792 """Check whether the character is part of Ogham UCS Block """
2793 ret = libxml2mod.xmlUCSIsOgham(code)
2796 def uCSIsOldItalic(code):
2797 """Check whether the character is part of OldItalic UCS Block """
2798 ret = libxml2mod.xmlUCSIsOldItalic(code)
2801 def uCSIsOpticalCharacterRecognition(code):
2802 """Check whether the character is part of
2803 OpticalCharacterRecognition UCS Block """
2804 ret = libxml2mod.xmlUCSIsOpticalCharacterRecognition(code)
2807 def uCSIsOriya(code):
2808 """Check whether the character is part of Oriya UCS Block """
2809 ret = libxml2mod.xmlUCSIsOriya(code)
2812 def uCSIsOsmanya(code):
2813 """Check whether the character is part of Osmanya UCS Block """
2814 ret = libxml2mod.xmlUCSIsOsmanya(code)
2817 def uCSIsPhoneticExtensions(code):
2818 """Check whether the character is part of PhoneticExtensions
2820 ret = libxml2mod.xmlUCSIsPhoneticExtensions(code)
2823 def uCSIsPrivateUse(code):
2824 """Check whether the character is part of PrivateUse UCS Block """
2825 ret = libxml2mod.xmlUCSIsPrivateUse(code)
2828 def uCSIsPrivateUseArea(code):
2829 """Check whether the character is part of PrivateUseArea UCS
2831 ret = libxml2mod.xmlUCSIsPrivateUseArea(code)
2834 def uCSIsRunic(code):
2835 """Check whether the character is part of Runic UCS Block """
2836 ret = libxml2mod.xmlUCSIsRunic(code)
2839 def uCSIsShavian(code):
2840 """Check whether the character is part of Shavian UCS Block """
2841 ret = libxml2mod.xmlUCSIsShavian(code)
2844 def uCSIsSinhala(code):
2845 """Check whether the character is part of Sinhala UCS Block """
2846 ret = libxml2mod.xmlUCSIsSinhala(code)
2849 def uCSIsSmallFormVariants(code):
2850 """Check whether the character is part of SmallFormVariants
2852 ret = libxml2mod.xmlUCSIsSmallFormVariants(code)
2855 def uCSIsSpacingModifierLetters(code):
2856 """Check whether the character is part of
2857 SpacingModifierLetters UCS Block """
2858 ret = libxml2mod.xmlUCSIsSpacingModifierLetters(code)
2861 def uCSIsSpecials(code):
2862 """Check whether the character is part of Specials UCS Block """
2863 ret = libxml2mod.xmlUCSIsSpecials(code)
2866 def uCSIsSuperscriptsandSubscripts(code):
2867 """Check whether the character is part of
2868 SuperscriptsandSubscripts UCS Block """
2869 ret = libxml2mod.xmlUCSIsSuperscriptsandSubscripts(code)
2872 def uCSIsSupplementalArrowsA(code):
2873 """Check whether the character is part of SupplementalArrows-A
2875 ret = libxml2mod.xmlUCSIsSupplementalArrowsA(code)
2878 def uCSIsSupplementalArrowsB(code):
2879 """Check whether the character is part of SupplementalArrows-B
2881 ret = libxml2mod.xmlUCSIsSupplementalArrowsB(code)
2884 def uCSIsSupplementalMathematicalOperators(code):
2885 """Check whether the character is part of
2886 SupplementalMathematicalOperators UCS Block """
2887 ret = libxml2mod.xmlUCSIsSupplementalMathematicalOperators(code)
2890 def uCSIsSupplementaryPrivateUseAreaA(code):
2891 """Check whether the character is part of
2892 SupplementaryPrivateUseArea-A UCS Block """
2893 ret = libxml2mod.xmlUCSIsSupplementaryPrivateUseAreaA(code)
2896 def uCSIsSupplementaryPrivateUseAreaB(code):
2897 """Check whether the character is part of
2898 SupplementaryPrivateUseArea-B UCS Block """
2899 ret = libxml2mod.xmlUCSIsSupplementaryPrivateUseAreaB(code)
2902 def uCSIsSyriac(code):
2903 """Check whether the character is part of Syriac UCS Block """
2904 ret = libxml2mod.xmlUCSIsSyriac(code)
2907 def uCSIsTagalog(code):
2908 """Check whether the character is part of Tagalog UCS Block """
2909 ret = libxml2mod.xmlUCSIsTagalog(code)
2912 def uCSIsTagbanwa(code):
2913 """Check whether the character is part of Tagbanwa UCS Block """
2914 ret = libxml2mod.xmlUCSIsTagbanwa(code)
2917 def uCSIsTags(code):
2918 """Check whether the character is part of Tags UCS Block """
2919 ret = libxml2mod.xmlUCSIsTags(code)
2922 def uCSIsTaiLe(code):
2923 """Check whether the character is part of TaiLe UCS Block """
2924 ret = libxml2mod.xmlUCSIsTaiLe(code)
2927 def uCSIsTaiXuanJingSymbols(code):
2928 """Check whether the character is part of TaiXuanJingSymbols
2930 ret = libxml2mod.xmlUCSIsTaiXuanJingSymbols(code)
2933 def uCSIsTamil(code):
2934 """Check whether the character is part of Tamil UCS Block """
2935 ret = libxml2mod.xmlUCSIsTamil(code)
2938 def uCSIsTelugu(code):
2939 """Check whether the character is part of Telugu UCS Block """
2940 ret = libxml2mod.xmlUCSIsTelugu(code)
2943 def uCSIsThaana(code):
2944 """Check whether the character is part of Thaana UCS Block """
2945 ret = libxml2mod.xmlUCSIsThaana(code)
2948 def uCSIsThai(code):
2949 """Check whether the character is part of Thai UCS Block """
2950 ret = libxml2mod.xmlUCSIsThai(code)
2953 def uCSIsTibetan(code):
2954 """Check whether the character is part of Tibetan UCS Block """
2955 ret = libxml2mod.xmlUCSIsTibetan(code)
2958 def uCSIsUgaritic(code):
2959 """Check whether the character is part of Ugaritic UCS Block """
2960 ret = libxml2mod.xmlUCSIsUgaritic(code)
2963 def uCSIsUnifiedCanadianAboriginalSyllabics(code):
2964 """Check whether the character is part of
2965 UnifiedCanadianAboriginalSyllabics UCS Block """
2966 ret = libxml2mod.xmlUCSIsUnifiedCanadianAboriginalSyllabics(code)
2969 def uCSIsVariationSelectors(code):
2970 """Check whether the character is part of VariationSelectors
2972 ret = libxml2mod.xmlUCSIsVariationSelectors(code)
2975 def uCSIsVariationSelectorsSupplement(code):
2976 """Check whether the character is part of
2977 VariationSelectorsSupplement UCS Block """
2978 ret = libxml2mod.xmlUCSIsVariationSelectorsSupplement(code)
2981 def uCSIsYiRadicals(code):
2982 """Check whether the character is part of YiRadicals UCS Block """
2983 ret = libxml2mod.xmlUCSIsYiRadicals(code)
2986 def uCSIsYiSyllables(code):
2987 """Check whether the character is part of YiSyllables UCS Block """
2988 ret = libxml2mod.xmlUCSIsYiSyllables(code)
2991 def uCSIsYijingHexagramSymbols(code):
2992 """Check whether the character is part of
2993 YijingHexagramSymbols UCS Block """
2994 ret = libxml2mod.xmlUCSIsYijingHexagramSymbols(code)
2998 # Functions from module xmlversion
3001 def checkVersion(version):
3002 """check the compiled lib version against the include one.
3003 This can warn or immediately kill the application """
3004 libxml2mod.xmlCheckVersion(version)
3007 # Functions from module xpathInternals
3011 """Pops the top XPath object from the value stack """
3012 if ctxt is None: ctxt__o = None
3013 else: ctxt__o = ctxt._o
3014 ret = libxml2mod.valuePop(ctxt__o)
3017 class xmlNode(xmlCore):
3018 def __init__(self, _obj=None):
3019 if checkWrapper(_obj) != 0: raise TypeError('xmlNode got a wrong wrapper object type')
3021 xmlCore.__init__(self, _obj=_obj)
3024 return "<xmlNode (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
3026 # accessors for xmlNode
3028 """Get the namespace of a node """
3029 ret = libxml2mod.xmlNodeGetNs(self._o)
3030 if ret is None:return None
3031 __tmp = xmlNs(_obj=ret)
3035 """Get the namespace of a node """
3036 ret = libxml2mod.xmlNodeGetNsDefs(self._o)
3037 if ret is None:return None
3038 __tmp = xmlNs(_obj=ret)
3042 # xmlNode functions from module debugXML
3045 def debugDumpNode(self, output, depth):
3046 """Dumps debug information for the element node, it is
3048 libxml2mod.xmlDebugDumpNode(output, self._o, depth)
3050 def debugDumpNodeList(self, output, depth):
3051 """Dumps debug information for the list of element node, it is
3053 libxml2mod.xmlDebugDumpNodeList(output, self._o, depth)
3055 def debugDumpOneNode(self, output, depth):
3056 """Dumps debug information for the element node, it is not
3058 libxml2mod.xmlDebugDumpOneNode(output, self._o, depth)
3060 def lsCountNode(self):
3061 """Count the children of @node. """
3062 ret = libxml2mod.xmlLsCountNode(self._o)
3065 def lsOneNode(self, output):
3066 """Dump to @output the type and name of @node. """
3067 libxml2mod.xmlLsOneNode(output, self._o)
3069 def shellPrintNode(self):
3070 """Print node to the output FILE """
3071 libxml2mod.xmlShellPrintNode(self._o)
3074 # xmlNode functions from module tree
3077 def addChild(self, cur):
3078 """Add a new node to @parent, at the end of the child (or
3079 property) list merging adjacent TEXT nodes (in which case
3080 @cur is freed) If the new node is ATTRIBUTE, it is added
3081 into properties instead of children. If there is an
3082 attribute with equal name, it is first destroyed. """
3083 if cur is None: cur__o = None
3084 else: cur__o = cur._o
3085 ret = libxml2mod.xmlAddChild(self._o, cur__o)
3086 if ret is None:raise treeError('xmlAddChild() failed')
3087 __tmp = xmlNode(_obj=ret)
3090 def addChildList(self, cur):
3091 """Add a list of node at the end of the child list of the
3092 parent merging adjacent TEXT nodes (@cur may be freed) """
3093 if cur is None: cur__o = None
3094 else: cur__o = cur._o
3095 ret = libxml2mod.xmlAddChildList(self._o, cur__o)
3096 if ret is None:raise treeError('xmlAddChildList() failed')
3097 __tmp = xmlNode(_obj=ret)
3100 def addContent(self, content):
3101 """Append the extra substring to the node content. NOTE: In
3102 contrast to xmlNodeSetContent(), @content is supposed to be
3103 raw text, so unescaped XML special chars are allowed,
3104 entity references are not supported. """
3105 libxml2mod.xmlNodeAddContent(self._o, content)
3107 def addContentLen(self, content, len):
3108 """Append the extra substring to the node content. NOTE: In
3109 contrast to xmlNodeSetContentLen(), @content is supposed to
3110 be raw text, so unescaped XML special chars are allowed,
3111 entity references are not supported. """
3112 libxml2mod.xmlNodeAddContentLen(self._o, content, len)
3114 def addNextSibling(self, elem):
3115 """Add a new node @elem as the next sibling of @cur If the new
3116 node was already inserted in a document it is first
3117 unlinked from its existing context. As a result of text
3118 merging @elem may be freed. If the new node is ATTRIBUTE,
3119 it is added into properties instead of children. If there
3120 is an attribute with equal name, it is first destroyed. """
3121 if elem is None: elem__o = None
3122 else: elem__o = elem._o
3123 ret = libxml2mod.xmlAddNextSibling(self._o, elem__o)
3124 if ret is None:raise treeError('xmlAddNextSibling() failed')
3125 __tmp = xmlNode(_obj=ret)
3128 def addPrevSibling(self, elem):
3129 """Add a new node @elem as the previous sibling of @cur
3130 merging adjacent TEXT nodes (@elem may be freed) If the new
3131 node was already inserted in a document it is first
3132 unlinked from its existing context. If the new node is
3133 ATTRIBUTE, it is added into properties instead of children.
3134 If there is an attribute with equal name, it is first
3136 if elem is None: elem__o = None
3137 else: elem__o = elem._o
3138 ret = libxml2mod.xmlAddPrevSibling(self._o, elem__o)
3139 if ret is None:raise treeError('xmlAddPrevSibling() failed')
3140 __tmp = xmlNode(_obj=ret)
3143 def addSibling(self, elem):
3144 """Add a new element @elem to the list of siblings of @cur
3145 merging adjacent TEXT nodes (@elem may be freed) If the new
3146 element was already inserted in a document it is first
3147 unlinked from its existing context. """
3148 if elem is None: elem__o = None
3149 else: elem__o = elem._o
3150 ret = libxml2mod.xmlAddSibling(self._o, elem__o)
3151 if ret is None:raise treeError('xmlAddSibling() failed')
3152 __tmp = xmlNode(_obj=ret)
3155 def copyNode(self, extended):
3156 """Do a copy of the node. """
3157 ret = libxml2mod.xmlCopyNode(self._o, extended)
3158 if ret is None:raise treeError('xmlCopyNode() failed')
3159 __tmp = xmlNode(_obj=ret)
3162 def copyNodeList(self):
3163 """Do a recursive copy of the node list. Use
3164 xmlDocCopyNodeList() if possible to ensure string interning. """
3165 ret = libxml2mod.xmlCopyNodeList(self._o)
3166 if ret is None:raise treeError('xmlCopyNodeList() failed')
3167 __tmp = xmlNode(_obj=ret)
3170 def copyProp(self, cur):
3171 """Do a copy of the attribute. """
3172 if cur is None: cur__o = None
3173 else: cur__o = cur._o
3174 ret = libxml2mod.xmlCopyProp(self._o, cur__o)
3175 if ret is None:raise treeError('xmlCopyProp() failed')
3176 __tmp = xmlAttr(_obj=ret)
3179 def copyPropList(self, cur):
3180 """Do a copy of an attribute list. """
3181 if cur is None: cur__o = None
3182 else: cur__o = cur._o
3183 ret = libxml2mod.xmlCopyPropList(self._o, cur__o)
3184 if ret is None:raise treeError('xmlCopyPropList() failed')
3185 __tmp = xmlAttr(_obj=ret)
3188 def docCopyNode(self, doc, extended):
3189 """Do a copy of the node to a given document. """
3190 if doc is None: doc__o = None
3191 else: doc__o = doc._o
3192 ret = libxml2mod.xmlDocCopyNode(self._o, doc__o, extended)
3193 if ret is None:raise treeError('xmlDocCopyNode() failed')
3194 __tmp = xmlNode(_obj=ret)
3197 def docCopyNodeList(self, doc):
3198 """Do a recursive copy of the node list. """
3199 if doc is None: doc__o = None
3200 else: doc__o = doc._o
3201 ret = libxml2mod.xmlDocCopyNodeList(doc__o, self._o)
3202 if ret is None:raise treeError('xmlDocCopyNodeList() failed')
3203 __tmp = xmlNode(_obj=ret)
3206 def docSetRootElement(self, doc):
3207 """Set the root element of the document (doc->children is a
3208 list containing possibly comments, PIs, etc ...). """
3209 if doc is None: doc__o = None
3210 else: doc__o = doc._o
3211 ret = libxml2mod.xmlDocSetRootElement(doc__o, self._o)
3212 if ret is None:return None
3213 __tmp = xmlNode(_obj=ret)
3216 def firstElementChild(self):
3217 """Finds the first child node of that element which is a
3218 Element node Note the handling of entities references is
3219 different than in the W3C DOM element traversal spec since
3220 we don't have back reference from entities content to
3221 entities references. """
3222 ret = libxml2mod.xmlFirstElementChild(self._o)
3223 if ret is None:return None
3224 __tmp = xmlNode(_obj=ret)
3228 """Free a node, this is a recursive behaviour, all the
3229 children are freed too. This doesn't unlink the child from
3230 the list, use xmlUnlinkNode() first. """
3231 libxml2mod.xmlFreeNode(self._o)
3233 def freeNodeList(self):
3234 """Free a node and all its siblings, this is a recursive
3235 behaviour, all the children are freed too. """
3236 libxml2mod.xmlFreeNodeList(self._o)
3238 def getBase(self, doc):
3239 """Searches for the BASE URL. The code should work on both XML
3240 and HTML document even if base mechanisms are completely
3241 different. It returns the base as defined in RFC 2396
3242 sections 5.1.1. Base URI within Document Content and 5.1.2.
3243 Base URI from the Encapsulating Entity However it does not
3244 return the document base (5.1.3), use doc->URL in this case """
3245 if doc is None: doc__o = None
3246 else: doc__o = doc._o
3247 ret = libxml2mod.xmlNodeGetBase(doc__o, self._o)
3250 def getContent(self):
3251 """Read the value of a node, this can be either the text
3252 carried directly by this node if it's a TEXT node or the
3253 aggregate string of the values carried by this node child's
3254 (TEXT and ENTITY_REF). Entity references are substituted. """
3255 ret = libxml2mod.xmlNodeGetContent(self._o)
3259 """Searches the language of a node, i.e. the values of the
3260 xml:lang attribute or the one carried by the nearest
3262 ret = libxml2mod.xmlNodeGetLang(self._o)
3265 def getSpacePreserve(self):
3266 """Searches the space preserving behaviour of a node, i.e. the
3267 values of the xml:space attribute or the one carried by the
3268 nearest ancestor. """
3269 ret = libxml2mod.xmlNodeGetSpacePreserve(self._o)
3272 def hasNsProp(self, name, nameSpace):
3273 """Search for an attribute associated to a node This attribute
3274 has to be anchored in the namespace specified. This does
3275 the entity substitution. This function looks in DTD
3276 attribute declaration for #FIXED or default declaration
3277 values unless DTD use has been turned off. Note that a
3278 namespace of None indicates to use the default namespace. """
3279 ret = libxml2mod.xmlHasNsProp(self._o, name, nameSpace)
3280 if ret is None:return None
3281 __tmp = xmlAttr(_obj=ret)
3284 def hasProp(self, name):
3285 """Search an attribute associated to a node This function also
3286 looks in DTD attribute declaration for #FIXED or default
3287 declaration values unless DTD use has been turned off. """
3288 ret = libxml2mod.xmlHasProp(self._o, name)
3289 if ret is None:return None
3290 __tmp = xmlAttr(_obj=ret)
3293 def isBlankNode(self):
3294 """Checks whether this node is an empty or whitespace only
3295 (and possibly ignorable) text-node. """
3296 ret = libxml2mod.xmlIsBlankNode(self._o)
3300 """Is this node a Text node ? """
3301 ret = libxml2mod.xmlNodeIsText(self._o)
3304 def lastChild(self):
3305 """Search the last child of a node. """
3306 ret = libxml2mod.xmlGetLastChild(self._o)
3307 if ret is None:raise treeError('xmlGetLastChild() failed')
3308 __tmp = xmlNode(_obj=ret)
3311 def lastElementChild(self):
3312 """Finds the last child node of that element which is a
3313 Element node Note the handling of entities references is
3314 different than in the W3C DOM element traversal spec since
3315 we don't have back reference from entities content to
3316 entities references. """
3317 ret = libxml2mod.xmlLastElementChild(self._o)
3318 if ret is None:return None
3319 __tmp = xmlNode(_obj=ret)
3323 """Get line number of @node. Try to override the limitation of
3324 lines being store in 16 bits ints if XML_PARSE_BIG_LINES
3325 parser option was used """
3326 ret = libxml2mod.xmlGetLineNo(self._o)
3329 def listGetRawString(self, doc, inLine):
3330 """Builds the string equivalent to the text contained in the
3331 Node list made of TEXTs and ENTITY_REFs, contrary to
3332 xmlNodeListGetString() this function doesn't do any
3333 character encoding handling. """
3334 if doc is None: doc__o = None
3335 else: doc__o = doc._o
3336 ret = libxml2mod.xmlNodeListGetRawString(doc__o, self._o, inLine)
3339 def listGetString(self, doc, inLine):
3340 """Build the string equivalent to the text contained in the
3341 Node list made of TEXTs and ENTITY_REFs """
3342 if doc is None: doc__o = None
3343 else: doc__o = doc._o
3344 ret = libxml2mod.xmlNodeListGetString(doc__o, self._o, inLine)
3347 def newChild(self, ns, name, content):
3348 """Creation of a new child element, added at the end of
3349 @parent children list. @ns and @content parameters are
3350 optional (None). If @ns is None, the newly created element
3351 inherits the namespace of @parent. If @content is non None,
3352 a child list containing the TEXTs and ENTITY_REFs node will
3353 be created. NOTE: @content is supposed to be a piece of XML
3354 CDATA, so it allows entity references. XML special chars
3355 must be escaped first by using
3356 xmlEncodeEntitiesReentrant(), or xmlNewTextChild() should
3358 if ns is None: ns__o = None
3360 ret = libxml2mod.xmlNewChild(self._o, ns__o, name, content)
3361 if ret is None:raise treeError('xmlNewChild() failed')
3362 __tmp = xmlNode(_obj=ret)
3365 def newNs(self, href, prefix):
3366 """Creation of a new Namespace. This function will refuse to
3367 create a namespace with a similar prefix than an existing
3368 one present on this node. Note that for a default
3369 namespace, @prefix should be None. We use href==None in
3370 the case of an element creation where the namespace was not
3372 ret = libxml2mod.xmlNewNs(self._o, href, prefix)
3373 if ret is None:raise treeError('xmlNewNs() failed')
3374 __tmp = xmlNs(_obj=ret)
3377 def newNsProp(self, ns, name, value):
3378 """Create a new property tagged with a namespace and carried
3380 if ns is None: ns__o = None
3382 ret = libxml2mod.xmlNewNsProp(self._o, ns__o, name, value)
3383 if ret is None:raise treeError('xmlNewNsProp() failed')
3384 __tmp = xmlAttr(_obj=ret)
3387 def newNsPropEatName(self, ns, name, value):
3388 """Create a new property tagged with a namespace and carried
3390 if ns is None: ns__o = None
3392 ret = libxml2mod.xmlNewNsPropEatName(self._o, ns__o, name, value)
3393 if ret is None:raise treeError('xmlNewNsPropEatName() failed')
3394 __tmp = xmlAttr(_obj=ret)
3397 def newProp(self, name, value):
3398 """Create a new property carried by a node. """
3399 ret = libxml2mod.xmlNewProp(self._o, name, value)
3400 if ret is None:raise treeError('xmlNewProp() failed')
3401 __tmp = xmlAttr(_obj=ret)
3404 def newTextChild(self, ns, name, content):
3405 """Creation of a new child element, added at the end of
3406 @parent children list. @ns and @content parameters are
3407 optional (None). If @ns is None, the newly created element
3408 inherits the namespace of @parent. If @content is non None,
3409 a child TEXT node will be created containing the string
3410 @content. NOTE: Use xmlNewChild() if @content will contain
3411 entities that need to be preserved. Use this function,
3412 xmlNewTextChild(), if you need to ensure that reserved XML
3413 chars that might appear in @content, such as the ampersand,
3414 greater-than or less-than signs, are automatically replaced
3415 by their XML escaped entity representations. """
3416 if ns is None: ns__o = None
3418 ret = libxml2mod.xmlNewTextChild(self._o, ns__o, name, content)
3419 if ret is None:raise treeError('xmlNewTextChild() failed')
3420 __tmp = xmlNode(_obj=ret)
3423 def nextElementSibling(self):
3424 """Finds the first closest next sibling of the node which is
3425 an element node. Note the handling of entities references
3426 is different than in the W3C DOM element traversal spec
3427 since we don't have back reference from entities content to
3428 entities references. """
3429 ret = libxml2mod.xmlNextElementSibling(self._o)
3430 if ret is None:return None
3431 __tmp = xmlNode(_obj=ret)
3434 def noNsProp(self, name):
3435 """Search and get the value of an attribute associated to a
3436 node This does the entity substitution. This function looks
3437 in DTD attribute declaration for #FIXED or default
3438 declaration values unless DTD use has been turned off. This
3439 function is similar to xmlGetProp except it will accept
3440 only an attribute in no namespace. """
3441 ret = libxml2mod.xmlGetNoNsProp(self._o, name)
3445 """Build a structure based Path for the given node """
3446 ret = libxml2mod.xmlGetNodePath(self._o)
3449 def nsProp(self, name, nameSpace):
3450 """Search and get the value of an attribute associated to a
3451 node This attribute has to be anchored in the namespace
3452 specified. This does the entity substitution. This function
3453 looks in DTD attribute declaration for #FIXED or default
3454 declaration values unless DTD use has been turned off. """
3455 ret = libxml2mod.xmlGetNsProp(self._o, name, nameSpace)
3458 def previousElementSibling(self):
3459 """Finds the first closest previous sibling of the node which
3460 is an element node. Note the handling of entities
3461 references is different than in the W3C DOM element
3462 traversal spec since we don't have back reference from
3463 entities content to entities references. """
3464 ret = libxml2mod.xmlPreviousElementSibling(self._o)
3465 if ret is None:return None
3466 __tmp = xmlNode(_obj=ret)
3469 def prop(self, name):
3470 """Search and get the value of an attribute associated to a
3471 node This does the entity substitution. This function looks
3472 in DTD attribute declaration for #FIXED or default
3473 declaration values unless DTD use has been turned off.
3474 NOTE: this function acts independently of namespaces
3475 associated to the attribute. Use xmlGetNsProp() or
3476 xmlGetNoNsProp() for namespace aware processing. """
3477 ret = libxml2mod.xmlGetProp(self._o, name)
3480 def reconciliateNs(self, doc):
3481 """This function checks that all the namespaces declared
3482 within the given tree are properly declared. This is needed
3483 for example after Copy or Cut and then paste operations.
3484 The subtree may still hold pointers to namespace
3485 declarations outside the subtree or invalid/masked. As much
3486 as possible the function try to reuse the existing
3487 namespaces found in the new environment. If not possible
3488 the new namespaces are redeclared on @tree at the top of
3489 the given subtree. """
3490 if doc is None: doc__o = None
3491 else: doc__o = doc._o
3492 ret = libxml2mod.xmlReconciliateNs(doc__o, self._o)
3495 def replaceNode(self, cur):
3496 """Unlink the old node from its current context, prune the new
3497 one at the same place. If @cur was already inserted in a
3498 document it is first unlinked from its existing context. """
3499 if cur is None: cur__o = None
3500 else: cur__o = cur._o
3501 ret = libxml2mod.xmlReplaceNode(self._o, cur__o)
3502 if ret is None:raise treeError('xmlReplaceNode() failed')
3503 __tmp = xmlNode(_obj=ret)
3506 def searchNs(self, doc, nameSpace):
3507 """Search a Ns registered under a given name space for a
3508 document. recurse on the parents until it finds the defined
3509 namespace or return None otherwise. @nameSpace can be None,
3510 this is a search for the default namespace. We don't allow
3511 to cross entities boundaries. If you don't declare the
3512 namespace within those you will be in troubles !!! A
3513 warning is generated to cover this case. """
3514 if doc is None: doc__o = None
3515 else: doc__o = doc._o
3516 ret = libxml2mod.xmlSearchNs(doc__o, self._o, nameSpace)
3517 if ret is None:raise treeError('xmlSearchNs() failed')
3518 __tmp = xmlNs(_obj=ret)
3521 def searchNsByHref(self, doc, href):
3522 """Search a Ns aliasing a given URI. Recurse on the parents
3523 until it finds the defined namespace or return None
3525 if doc is None: doc__o = None
3526 else: doc__o = doc._o
3527 ret = libxml2mod.xmlSearchNsByHref(doc__o, self._o, href)
3528 if ret is None:raise treeError('xmlSearchNsByHref() failed')
3529 __tmp = xmlNs(_obj=ret)
3532 def setBase(self, uri):
3533 """Set (or reset) the base URI of a node, i.e. the value of
3534 the xml:base attribute. """
3535 libxml2mod.xmlNodeSetBase(self._o, uri)
3537 def setContent(self, content):
3538 """Replace the content of a node. NOTE: @content is supposed
3539 to be a piece of XML CDATA, so it allows entity references,
3540 but XML special chars need to be escaped first by using
3541 xmlEncodeEntitiesReentrant() resp. xmlEncodeSpecialChars(). """
3542 libxml2mod.xmlNodeSetContent(self._o, content)
3544 def setContentLen(self, content, len):
3545 """Replace the content of a node. NOTE: @content is supposed
3546 to be a piece of XML CDATA, so it allows entity references,
3547 but XML special chars need to be escaped first by using
3548 xmlEncodeEntitiesReentrant() resp. xmlEncodeSpecialChars(). """
3549 libxml2mod.xmlNodeSetContentLen(self._o, content, len)
3551 def setLang(self, lang):
3552 """Set the language of a node, i.e. the values of the xml:lang
3554 libxml2mod.xmlNodeSetLang(self._o, lang)
3556 def setListDoc(self, doc):
3557 """update all nodes in the list to point to the right document """
3558 if doc is None: doc__o = None
3559 else: doc__o = doc._o
3560 libxml2mod.xmlSetListDoc(self._o, doc__o)
3562 def setName(self, name):
3563 """Set (or reset) the name of a node. """
3564 libxml2mod.xmlNodeSetName(self._o, name)
3566 def setNs(self, ns):
3567 """Associate a namespace to a node, a posteriori. """
3568 if ns is None: ns__o = None
3570 libxml2mod.xmlSetNs(self._o, ns__o)
3572 def setNsProp(self, ns, name, value):
3573 """Set (or reset) an attribute carried by a node. The ns
3574 structure must be in scope, this is not checked """
3575 if ns is None: ns__o = None
3577 ret = libxml2mod.xmlSetNsProp(self._o, ns__o, name, value)
3578 if ret is None:raise treeError('xmlSetNsProp() failed')
3579 __tmp = xmlAttr(_obj=ret)
3582 def setProp(self, name, value):
3583 """Set (or reset) an attribute carried by a node. If @name has
3584 a prefix, then the corresponding namespace-binding will be
3585 used, if in scope; it is an error it there's no such
3586 ns-binding for the prefix in scope. """
3587 ret = libxml2mod.xmlSetProp(self._o, name, value)
3588 if ret is None:raise treeError('xmlSetProp() failed')
3589 __tmp = xmlAttr(_obj=ret)
3592 def setSpacePreserve(self, val):
3593 """Set (or reset) the space preserving behaviour of a node,
3594 i.e. the value of the xml:space attribute. """
3595 libxml2mod.xmlNodeSetSpacePreserve(self._o, val)
3597 def setTreeDoc(self, doc):
3598 """update all nodes under the tree to point to the right
3600 if doc is None: doc__o = None
3601 else: doc__o = doc._o
3602 libxml2mod.xmlSetTreeDoc(self._o, doc__o)
3604 def textConcat(self, content, len):
3605 """Concat the given string at the end of the existing node
3607 ret = libxml2mod.xmlTextConcat(self._o, content, len)
3610 def textMerge(self, second):
3611 """Merge two text nodes into one """
3612 if second is None: second__o = None
3613 else: second__o = second._o
3614 ret = libxml2mod.xmlTextMerge(self._o, second__o)
3615 if ret is None:raise treeError('xmlTextMerge() failed')
3616 __tmp = xmlNode(_obj=ret)
3619 def unlinkNode(self):
3620 """Unlink a node from it's current context, the node is not
3621 freed If one need to free the node, use xmlFreeNode()
3622 routine after the unlink to discard it. Note that namespace
3623 nodes can't be unlinked as they do not have pointer to
3625 libxml2mod.xmlUnlinkNode(self._o)
3627 def unsetNsProp(self, ns, name):
3628 """Remove an attribute carried by a node. """
3629 if ns is None: ns__o = None
3631 ret = libxml2mod.xmlUnsetNsProp(self._o, ns__o, name)
3634 def unsetProp(self, name):
3635 """Remove an attribute carried by a node. This handles only
3636 attributes in no namespace. """
3637 ret = libxml2mod.xmlUnsetProp(self._o, name)
3641 # xmlNode functions from module valid
3644 def isID(self, doc, attr):
3645 """Determine whether an attribute is of type ID. In case we
3646 have DTD(s) then this is done if DTD loading has been
3647 requested. In the case of HTML documents parsed with the
3648 HTML parser, then ID detection is done systematically. """
3649 if doc is None: doc__o = None
3650 else: doc__o = doc._o
3651 if attr is None: attr__o = None
3652 else: attr__o = attr._o
3653 ret = libxml2mod.xmlIsID(doc__o, self._o, attr__o)
3656 def isRef(self, doc, attr):
3657 """Determine whether an attribute is of type Ref. In case we
3658 have DTD(s) then this is simple, otherwise we use an
3659 heuristic: name Ref (upper or lowercase). """
3660 if doc is None: doc__o = None
3661 else: doc__o = doc._o
3662 if attr is None: attr__o = None
3663 else: attr__o = attr._o
3664 ret = libxml2mod.xmlIsRef(doc__o, self._o, attr__o)
3667 def validNormalizeAttributeValue(self, doc, name, value):
3668 """Does the validation related extra step of the normalization
3669 of attribute values: If the declared value is not CDATA,
3670 then the XML processor must further process the normalized
3671 attribute value by discarding any leading and trailing
3672 space (#x20) characters, and by replacing sequences of
3673 space (#x20) characters by single space (#x20) character. """
3674 if doc is None: doc__o = None
3675 else: doc__o = doc._o
3676 ret = libxml2mod.xmlValidNormalizeAttributeValue(doc__o, self._o, name, value)
3680 # xmlNode functions from module xinclude
3683 def xincludeProcessTree(self):
3684 """Implement the XInclude substitution for the given subtree """
3685 ret = libxml2mod.xmlXIncludeProcessTree(self._o)
3688 def xincludeProcessTreeFlags(self, flags):
3689 """Implement the XInclude substitution for the given subtree """
3690 ret = libxml2mod.xmlXIncludeProcessTreeFlags(self._o, flags)
3694 # xmlNode functions from module xmlschemas
3697 def schemaValidateOneElement(self, ctxt):
3698 """Validate a branch of a tree, starting with the given @elem. """
3699 if ctxt is None: ctxt__o = None
3700 else: ctxt__o = ctxt._o
3701 ret = libxml2mod.xmlSchemaValidateOneElement(ctxt__o, self._o)
3705 # xmlNode functions from module xpath
3708 def xpathCastNodeToNumber(self):
3709 """Converts a node to its number value """
3710 ret = libxml2mod.xmlXPathCastNodeToNumber(self._o)
3713 def xpathCastNodeToString(self):
3714 """Converts a node to its string value. """
3715 ret = libxml2mod.xmlXPathCastNodeToString(self._o)
3718 def xpathCmpNodes(self, node2):
3719 """Compare two nodes w.r.t document order """
3720 if node2 is None: node2__o = None
3721 else: node2__o = node2._o
3722 ret = libxml2mod.xmlXPathCmpNodes(self._o, node2__o)
3725 def xpathNodeEval(self, str, ctx):
3726 """Evaluate the XPath Location Path in the given context. The
3727 node 'node' is set as the context node. The context node is
3729 if ctx is None: ctx__o = None
3730 else: ctx__o = ctx._o
3731 ret = libxml2mod.xmlXPathNodeEval(self._o, str, ctx__o)
3732 if ret is None:raise xpathError('xmlXPathNodeEval() failed')
3733 return xpathObjectRet(ret)
3736 # xmlNode functions from module xpathInternals
3739 def xpathNewNodeSet(self):
3740 """Create a new xmlXPathObjectPtr of type NodeSet and
3741 initialize it with the single Node @val """
3742 ret = libxml2mod.xmlXPathNewNodeSet(self._o)
3743 if ret is None:raise xpathError('xmlXPathNewNodeSet() failed')
3744 return xpathObjectRet(ret)
3746 def xpathNewValueTree(self):
3747 """Create a new xmlXPathObjectPtr of type Value Tree (XSLT)
3748 and initialize it with the tree root @val """
3749 ret = libxml2mod.xmlXPathNewValueTree(self._o)
3750 if ret is None:raise xpathError('xmlXPathNewValueTree() failed')
3751 return xpathObjectRet(ret)
3753 def xpathNextAncestor(self, ctxt):
3754 """Traversal function for the "ancestor" direction the
3755 ancestor axis contains the ancestors of the context node;
3756 the ancestors of the context node consist of the parent of
3757 context node and the parent's parent and so on; the nodes
3758 are ordered in reverse document order; thus the parent is
3759 the first node on the axis, and the parent's parent is the
3760 second node on the axis """
3761 if ctxt is None: ctxt__o = None
3762 else: ctxt__o = ctxt._o
3763 ret = libxml2mod.xmlXPathNextAncestor(ctxt__o, self._o)
3764 if ret is None:raise xpathError('xmlXPathNextAncestor() failed')
3765 __tmp = xmlNode(_obj=ret)
3768 def xpathNextAncestorOrSelf(self, ctxt):
3769 """Traversal function for the "ancestor-or-self" direction he
3770 ancestor-or-self axis contains the context node and
3771 ancestors of the context node in reverse document order;
3772 thus the context node is the first node on the axis, and
3773 the context node's parent the second; parent here is
3774 defined the same as with the parent axis. """
3775 if ctxt is None: ctxt__o = None
3776 else: ctxt__o = ctxt._o
3777 ret = libxml2mod.xmlXPathNextAncestorOrSelf(ctxt__o, self._o)
3778 if ret is None:raise xpathError('xmlXPathNextAncestorOrSelf() failed')
3779 __tmp = xmlNode(_obj=ret)
3782 def xpathNextAttribute(self, ctxt):
3783 """Traversal function for the "attribute" direction TODO:
3784 support DTD inherited default attributes """
3785 if ctxt is None: ctxt__o = None
3786 else: ctxt__o = ctxt._o
3787 ret = libxml2mod.xmlXPathNextAttribute(ctxt__o, self._o)
3788 if ret is None:raise xpathError('xmlXPathNextAttribute() failed')
3789 __tmp = xmlNode(_obj=ret)
3792 def xpathNextChild(self, ctxt):
3793 """Traversal function for the "child" direction The child axis
3794 contains the children of the context node in document order. """
3795 if ctxt is None: ctxt__o = None
3796 else: ctxt__o = ctxt._o
3797 ret = libxml2mod.xmlXPathNextChild(ctxt__o, self._o)
3798 if ret is None:raise xpathError('xmlXPathNextChild() failed')
3799 __tmp = xmlNode(_obj=ret)
3802 def xpathNextDescendant(self, ctxt):
3803 """Traversal function for the "descendant" direction the
3804 descendant axis contains the descendants of the context
3805 node in document order; a descendant is a child or a child
3806 of a child and so on. """
3807 if ctxt is None: ctxt__o = None
3808 else: ctxt__o = ctxt._o
3809 ret = libxml2mod.xmlXPathNextDescendant(ctxt__o, self._o)
3810 if ret is None:raise xpathError('xmlXPathNextDescendant() failed')
3811 __tmp = xmlNode(_obj=ret)
3814 def xpathNextDescendantOrSelf(self, ctxt):
3815 """Traversal function for the "descendant-or-self" direction
3816 the descendant-or-self axis contains the context node and
3817 the descendants of the context node in document order; thus
3818 the context node is the first node on the axis, and the
3819 first child of the context node is the second node on the
3821 if ctxt is None: ctxt__o = None
3822 else: ctxt__o = ctxt._o
3823 ret = libxml2mod.xmlXPathNextDescendantOrSelf(ctxt__o, self._o)
3824 if ret is None:raise xpathError('xmlXPathNextDescendantOrSelf() failed')
3825 __tmp = xmlNode(_obj=ret)
3828 def xpathNextFollowing(self, ctxt):
3829 """Traversal function for the "following" direction The
3830 following axis contains all nodes in the same document as
3831 the context node that are after the context node in
3832 document order, excluding any descendants and excluding
3833 attribute nodes and namespace nodes; the nodes are ordered
3834 in document order """
3835 if ctxt is None: ctxt__o = None
3836 else: ctxt__o = ctxt._o
3837 ret = libxml2mod.xmlXPathNextFollowing(ctxt__o, self._o)
3838 if ret is None:raise xpathError('xmlXPathNextFollowing() failed')
3839 __tmp = xmlNode(_obj=ret)
3842 def xpathNextFollowingSibling(self, ctxt):
3843 """Traversal function for the "following-sibling" direction
3844 The following-sibling axis contains the following siblings
3845 of the context node in document order. """
3846 if ctxt is None: ctxt__o = None
3847 else: ctxt__o = ctxt._o
3848 ret = libxml2mod.xmlXPathNextFollowingSibling(ctxt__o, self._o)
3849 if ret is None:raise xpathError('xmlXPathNextFollowingSibling() failed')
3850 __tmp = xmlNode(_obj=ret)
3853 def xpathNextNamespace(self, ctxt):
3854 """Traversal function for the "namespace" direction the
3855 namespace axis contains the namespace nodes of the context
3856 node; the order of nodes on this axis is
3857 implementation-defined; the axis will be empty unless the
3858 context node is an element We keep the XML namespace node
3859 at the end of the list. """
3860 if ctxt is None: ctxt__o = None
3861 else: ctxt__o = ctxt._o
3862 ret = libxml2mod.xmlXPathNextNamespace(ctxt__o, self._o)
3863 if ret is None:raise xpathError('xmlXPathNextNamespace() failed')
3864 __tmp = xmlNode(_obj=ret)
3867 def xpathNextParent(self, ctxt):
3868 """Traversal function for the "parent" direction The parent
3869 axis contains the parent of the context node, if there is
3871 if ctxt is None: ctxt__o = None
3872 else: ctxt__o = ctxt._o
3873 ret = libxml2mod.xmlXPathNextParent(ctxt__o, self._o)
3874 if ret is None:raise xpathError('xmlXPathNextParent() failed')
3875 __tmp = xmlNode(_obj=ret)
3878 def xpathNextPreceding(self, ctxt):
3879 """Traversal function for the "preceding" direction the
3880 preceding axis contains all nodes in the same document as
3881 the context node that are before the context node in
3882 document order, excluding any ancestors and excluding
3883 attribute nodes and namespace nodes; the nodes are ordered
3884 in reverse document order """
3885 if ctxt is None: ctxt__o = None
3886 else: ctxt__o = ctxt._o
3887 ret = libxml2mod.xmlXPathNextPreceding(ctxt__o, self._o)
3888 if ret is None:raise xpathError('xmlXPathNextPreceding() failed')
3889 __tmp = xmlNode(_obj=ret)
3892 def xpathNextPrecedingSibling(self, ctxt):
3893 """Traversal function for the "preceding-sibling" direction
3894 The preceding-sibling axis contains the preceding siblings
3895 of the context node in reverse document order; the first
3896 preceding sibling is first on the axis; the sibling
3897 preceding that node is the second on the axis and so on. """
3898 if ctxt is None: ctxt__o = None
3899 else: ctxt__o = ctxt._o
3900 ret = libxml2mod.xmlXPathNextPrecedingSibling(ctxt__o, self._o)
3901 if ret is None:raise xpathError('xmlXPathNextPrecedingSibling() failed')
3902 __tmp = xmlNode(_obj=ret)
3905 def xpathNextSelf(self, ctxt):
3906 """Traversal function for the "self" direction The self axis
3907 contains just the context node itself """
3908 if ctxt is None: ctxt__o = None
3909 else: ctxt__o = ctxt._o
3910 ret = libxml2mod.xmlXPathNextSelf(ctxt__o, self._o)
3911 if ret is None:raise xpathError('xmlXPathNextSelf() failed')
3912 __tmp = xmlNode(_obj=ret)
3916 # xmlNode functions from module xpointer
3919 def xpointerNewCollapsedRange(self):
3920 """Create a new xmlXPathObjectPtr of type range using a single
3922 ret = libxml2mod.xmlXPtrNewCollapsedRange(self._o)
3923 if ret is None:raise treeError('xmlXPtrNewCollapsedRange() failed')
3924 return xpathObjectRet(ret)
3926 def xpointerNewContext(self, doc, origin):
3927 """Create a new XPointer context """
3928 if doc is None: doc__o = None
3929 else: doc__o = doc._o
3930 if origin is None: origin__o = None
3931 else: origin__o = origin._o
3932 ret = libxml2mod.xmlXPtrNewContext(doc__o, self._o, origin__o)
3933 if ret is None:raise treeError('xmlXPtrNewContext() failed')
3934 __tmp = xpathContext(_obj=ret)
3937 def xpointerNewLocationSetNodes(self, end):
3938 """Create a new xmlXPathObjectPtr of type LocationSet and
3939 initialize it with the single range made of the two nodes
3941 if end is None: end__o = None
3942 else: end__o = end._o
3943 ret = libxml2mod.xmlXPtrNewLocationSetNodes(self._o, end__o)
3944 if ret is None:raise treeError('xmlXPtrNewLocationSetNodes() failed')
3945 return xpathObjectRet(ret)
3947 def xpointerNewRange(self, startindex, end, endindex):
3948 """Create a new xmlXPathObjectPtr of type range """
3949 if end is None: end__o = None
3950 else: end__o = end._o
3951 ret = libxml2mod.xmlXPtrNewRange(self._o, startindex, end__o, endindex)
3952 if ret is None:raise treeError('xmlXPtrNewRange() failed')
3953 return xpathObjectRet(ret)
3955 def xpointerNewRangeNodes(self, end):
3956 """Create a new xmlXPathObjectPtr of type range using 2 nodes """
3957 if end is None: end__o = None
3958 else: end__o = end._o
3959 ret = libxml2mod.xmlXPtrNewRangeNodes(self._o, end__o)
3960 if ret is None:raise treeError('xmlXPtrNewRangeNodes() failed')
3961 return xpathObjectRet(ret)
3963 class xmlDoc(xmlNode):
3964 def __init__(self, _obj=None):
3965 if checkWrapper(_obj) != 0: raise TypeError('xmlDoc got a wrong wrapper object type')
3967 xmlNode.__init__(self, _obj=_obj)
3970 return "<xmlDoc (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
3973 # xmlDoc functions from module HTMLparser
3976 def htmlAutoCloseTag(self, name, elem):
3977 """The HTML DTD allows a tag to implicitly close other tags.
3978 The list is kept in htmlStartClose array. This function
3979 checks if the element or one of it's children would
3980 autoclose the given tag. """
3981 ret = libxml2mod.htmlAutoCloseTag(self._o, name, elem)
3984 def htmlIsAutoClosed(self, elem):
3985 """The HTML DTD allows a tag to implicitly close other tags.
3986 The list is kept in htmlStartClose array. This function
3987 checks if a tag is autoclosed by one of it's child """
3988 ret = libxml2mod.htmlIsAutoClosed(self._o, elem)
3992 # xmlDoc functions from module HTMLtree
3995 def htmlDocContentDumpFormatOutput(self, buf, encoding, format):
3996 """Dump an HTML document. """
3997 if buf is None: buf__o = None
3998 else: buf__o = buf._o
3999 libxml2mod.htmlDocContentDumpFormatOutput(buf__o, self._o, encoding, format)
4001 def htmlDocContentDumpOutput(self, buf, encoding):
4002 """Dump an HTML document. Formating return/spaces are added. """
4003 if buf is None: buf__o = None
4004 else: buf__o = buf._o
4005 libxml2mod.htmlDocContentDumpOutput(buf__o, self._o, encoding)
4007 def htmlDocDump(self, f):
4008 """Dump an HTML document to an open FILE. """
4009 ret = libxml2mod.htmlDocDump(f, self._o)
4012 def htmlGetMetaEncoding(self):
4013 """Encoding definition lookup in the Meta tags """
4014 ret = libxml2mod.htmlGetMetaEncoding(self._o)
4017 def htmlNodeDumpFile(self, out, cur):
4018 """Dump an HTML node, recursive behaviour,children are printed
4019 too, and formatting returns are added. """
4020 if cur is None: cur__o = None
4021 else: cur__o = cur._o
4022 libxml2mod.htmlNodeDumpFile(out, self._o, cur__o)
4024 def htmlNodeDumpFileFormat(self, out, cur, encoding, format):
4025 """Dump an HTML node, recursive behaviour,children are printed
4026 too. TODO: if encoding == None try to save in the doc
4028 if cur is None: cur__o = None
4029 else: cur__o = cur._o
4030 ret = libxml2mod.htmlNodeDumpFileFormat(out, self._o, cur__o, encoding, format)
4033 def htmlNodeDumpFormatOutput(self, buf, cur, encoding, format):
4034 """Dump an HTML node, recursive behaviour,children are printed
4036 if buf is None: buf__o = None
4037 else: buf__o = buf._o
4038 if cur is None: cur__o = None
4039 else: cur__o = cur._o
4040 libxml2mod.htmlNodeDumpFormatOutput(buf__o, self._o, cur__o, encoding, format)
4042 def htmlNodeDumpOutput(self, buf, cur, encoding):
4043 """Dump an HTML node, recursive behaviour,children are printed
4044 too, and formatting returns/spaces are added. """
4045 if buf is None: buf__o = None
4046 else: buf__o = buf._o
4047 if cur is None: cur__o = None
4048 else: cur__o = cur._o
4049 libxml2mod.htmlNodeDumpOutput(buf__o, self._o, cur__o, encoding)
4051 def htmlSaveFile(self, filename):
4052 """Dump an HTML document to a file. If @filename is "-" the
4053 stdout file is used. """
4054 ret = libxml2mod.htmlSaveFile(filename, self._o)
4057 def htmlSaveFileEnc(self, filename, encoding):
4058 """Dump an HTML document to a file using a given encoding and
4059 formatting returns/spaces are added. """
4060 ret = libxml2mod.htmlSaveFileEnc(filename, self._o, encoding)
4063 def htmlSaveFileFormat(self, filename, encoding, format):
4064 """Dump an HTML document to a file using a given encoding. """
4065 ret = libxml2mod.htmlSaveFileFormat(filename, self._o, encoding, format)
4068 def htmlSetMetaEncoding(self, encoding):
4069 """Sets the current encoding in the Meta tags NOTE: this will
4070 not change the document content encoding, just the META
4071 flag associated. """
4072 ret = libxml2mod.htmlSetMetaEncoding(self._o, encoding)
4076 # xmlDoc functions from module debugXML
4079 def debugCheckDocument(self, output):
4080 """Check the document for potential content problems, and
4081 output the errors to @output """
4082 ret = libxml2mod.xmlDebugCheckDocument(output, self._o)
4085 def debugDumpDocument(self, output):
4086 """Dumps debug information for the document, it's recursive """
4087 libxml2mod.xmlDebugDumpDocument(output, self._o)
4089 def debugDumpDocumentHead(self, output):
4090 """Dumps debug information cncerning the document, not
4092 libxml2mod.xmlDebugDumpDocumentHead(output, self._o)
4094 def debugDumpEntities(self, output):
4095 """Dumps debug information for all the entities in use by the
4097 libxml2mod.xmlDebugDumpEntities(output, self._o)
4100 # xmlDoc functions from module entities
4103 def addDocEntity(self, name, type, ExternalID, SystemID, content):
4104 """Register a new entity for this document. """
4105 ret = libxml2mod.xmlAddDocEntity(self._o, name, type, ExternalID, SystemID, content)
4106 if ret is None:raise treeError('xmlAddDocEntity() failed')
4107 __tmp = xmlEntity(_obj=ret)
4110 def addDtdEntity(self, name, type, ExternalID, SystemID, content):
4111 """Register a new entity for this document DTD external subset. """
4112 ret = libxml2mod.xmlAddDtdEntity(self._o, name, type, ExternalID, SystemID, content)
4113 if ret is None:raise treeError('xmlAddDtdEntity() failed')
4114 __tmp = xmlEntity(_obj=ret)
4117 def docEntity(self, name):
4118 """Do an entity lookup in the document entity hash table and """
4119 ret = libxml2mod.xmlGetDocEntity(self._o, name)
4120 if ret is None:raise treeError('xmlGetDocEntity() failed')
4121 __tmp = xmlEntity(_obj=ret)
4124 def dtdEntity(self, name):
4125 """Do an entity lookup in the DTD entity hash table and """
4126 ret = libxml2mod.xmlGetDtdEntity(self._o, name)
4127 if ret is None:raise treeError('xmlGetDtdEntity() failed')
4128 __tmp = xmlEntity(_obj=ret)
4131 def encodeEntities(self, input):
4132 """TODO: remove xmlEncodeEntities, once we are not afraid of
4133 breaking binary compatibility People must migrate their
4134 code to xmlEncodeEntitiesReentrant ! This routine will
4135 issue a warning when encountered. """
4136 ret = libxml2mod.xmlEncodeEntities(self._o, input)
4139 def encodeEntitiesReentrant(self, input):
4140 """Do a global encoding of a string, replacing the predefined
4141 entities and non ASCII values with their entities and
4142 CharRef counterparts. Contrary to xmlEncodeEntities, this
4143 routine is reentrant, and result must be deallocated. """
4144 ret = libxml2mod.xmlEncodeEntitiesReentrant(self._o, input)
4147 def encodeSpecialChars(self, input):
4148 """Do a global encoding of a string, replacing the predefined
4149 entities this routine is reentrant, and result must be
4151 ret = libxml2mod.xmlEncodeSpecialChars(self._o, input)
4154 def newEntity(self, name, type, ExternalID, SystemID, content):
4155 """Create a new entity, this differs from xmlAddDocEntity()
4156 that if the document is None or has no internal subset
4157 defined, then an unlinked entity structure will be
4158 returned, it is then the responsability of the caller to
4159 link it to the document later or free it when not needed
4161 ret = libxml2mod.xmlNewEntity(self._o, name, type, ExternalID, SystemID, content)
4162 if ret is None:raise treeError('xmlNewEntity() failed')
4163 __tmp = xmlEntity(_obj=ret)
4166 def parameterEntity(self, name):
4167 """Do an entity lookup in the internal and external subsets and """
4168 ret = libxml2mod.xmlGetParameterEntity(self._o, name)
4169 if ret is None:raise treeError('xmlGetParameterEntity() failed')
4170 __tmp = xmlEntity(_obj=ret)
4174 # xmlDoc functions from module relaxng
4177 def relaxNGNewDocParserCtxt(self):
4178 """Create an XML RelaxNGs parser context for that document.
4179 Note: since the process of compiling a RelaxNG schemas
4180 modifies the document, the @doc parameter is duplicated
4182 ret = libxml2mod.xmlRelaxNGNewDocParserCtxt(self._o)
4183 if ret is None:raise parserError('xmlRelaxNGNewDocParserCtxt() failed')
4184 __tmp = relaxNgParserCtxt(_obj=ret)
4187 def relaxNGValidateDoc(self, ctxt):
4188 """Validate a document tree in memory. """
4189 if ctxt is None: ctxt__o = None
4190 else: ctxt__o = ctxt._o
4191 ret = libxml2mod.xmlRelaxNGValidateDoc(ctxt__o, self._o)
4194 def relaxNGValidateFullElement(self, ctxt, elem):
4195 """Validate a full subtree when
4196 xmlRelaxNGValidatePushElement() returned 0 and the content
4197 of the node has been expanded. """
4198 if ctxt is None: ctxt__o = None
4199 else: ctxt__o = ctxt._o
4200 if elem is None: elem__o = None
4201 else: elem__o = elem._o
4202 ret = libxml2mod.xmlRelaxNGValidateFullElement(ctxt__o, self._o, elem__o)
4205 def relaxNGValidatePopElement(self, ctxt, elem):
4206 """Pop the element end from the RelaxNG validation stack. """
4207 if ctxt is None: ctxt__o = None
4208 else: ctxt__o = ctxt._o
4209 if elem is None: elem__o = None
4210 else: elem__o = elem._o
4211 ret = libxml2mod.xmlRelaxNGValidatePopElement(ctxt__o, self._o, elem__o)
4214 def relaxNGValidatePushElement(self, ctxt, elem):
4215 """Push a new element start on the RelaxNG validation stack. """
4216 if ctxt is None: ctxt__o = None
4217 else: ctxt__o = ctxt._o
4218 if elem is None: elem__o = None
4219 else: elem__o = elem._o
4220 ret = libxml2mod.xmlRelaxNGValidatePushElement(ctxt__o, self._o, elem__o)
4224 # xmlDoc functions from module tree
4227 def copyDoc(self, recursive):
4228 """Do a copy of the document info. If recursive, the content
4229 tree will be copied too as well as DTD, namespaces and
4231 ret = libxml2mod.xmlCopyDoc(self._o, recursive)
4232 if ret is None:raise treeError('xmlCopyDoc() failed')
4233 __tmp = xmlDoc(_obj=ret)
4236 def copyNode(self, node, extended):
4237 """Do a copy of the node to a given document. """
4238 if node is None: node__o = None
4239 else: node__o = node._o
4240 ret = libxml2mod.xmlDocCopyNode(node__o, self._o, extended)
4241 if ret is None:raise treeError('xmlDocCopyNode() failed')
4242 __tmp = xmlNode(_obj=ret)
4245 def copyNodeList(self, node):
4246 """Do a recursive copy of the node list. """
4247 if node is None: node__o = None
4248 else: node__o = node._o
4249 ret = libxml2mod.xmlDocCopyNodeList(self._o, node__o)
4250 if ret is None:raise treeError('xmlDocCopyNodeList() failed')
4251 __tmp = xmlNode(_obj=ret)
4254 def createIntSubset(self, name, ExternalID, SystemID):
4255 """Create the internal subset of a document """
4256 ret = libxml2mod.xmlCreateIntSubset(self._o, name, ExternalID, SystemID)
4257 if ret is None:raise treeError('xmlCreateIntSubset() failed')
4258 __tmp = xmlDtd(_obj=ret)
4261 def docCompressMode(self):
4262 """get the compression ratio for a document, ZLIB based """
4263 ret = libxml2mod.xmlGetDocCompressMode(self._o)
4267 """Dump an XML document to an open FILE. """
4268 ret = libxml2mod.xmlDocDump(f, self._o)
4271 def elemDump(self, f, cur):
4272 """Dump an XML/HTML node, recursive behaviour, children are
4274 if cur is None: cur__o = None
4275 else: cur__o = cur._o
4276 libxml2mod.xmlElemDump(f, self._o, cur__o)
4278 def formatDump(self, f, format):
4279 """Dump an XML document to an open FILE. """
4280 ret = libxml2mod.xmlDocFormatDump(f, self._o, format)
4284 """Free up all the structures used by a document, tree
4286 libxml2mod.xmlFreeDoc(self._o)
4288 def getRootElement(self):
4289 """Get the root element of the document (doc->children is a
4290 list containing possibly comments, PIs, etc ...). """
4291 ret = libxml2mod.xmlDocGetRootElement(self._o)
4292 if ret is None:raise treeError('xmlDocGetRootElement() failed')
4293 __tmp = xmlNode(_obj=ret)
4296 def intSubset(self):
4297 """Get the internal subset of a document """
4298 ret = libxml2mod.xmlGetIntSubset(self._o)
4299 if ret is None:raise treeError('xmlGetIntSubset() failed')
4300 __tmp = xmlDtd(_obj=ret)
4303 def newCDataBlock(self, content, len):
4304 """Creation of a new node containing a CDATA block. """
4305 ret = libxml2mod.xmlNewCDataBlock(self._o, content, len)
4306 if ret is None:raise treeError('xmlNewCDataBlock() failed')
4307 __tmp = xmlNode(_obj=ret)
4310 def newCharRef(self, name):
4311 """Creation of a new character reference node. """
4312 ret = libxml2mod.xmlNewCharRef(self._o, name)
4313 if ret is None:raise treeError('xmlNewCharRef() failed')
4314 __tmp = xmlNode(_obj=ret)
4317 def newDocComment(self, content):
4318 """Creation of a new node containing a comment within a
4320 ret = libxml2mod.xmlNewDocComment(self._o, content)
4321 if ret is None:raise treeError('xmlNewDocComment() failed')
4322 __tmp = xmlNode(_obj=ret)
4325 def newDocFragment(self):
4326 """Creation of a new Fragment node. """
4327 ret = libxml2mod.xmlNewDocFragment(self._o)
4328 if ret is None:raise treeError('xmlNewDocFragment() failed')
4329 __tmp = xmlNode(_obj=ret)
4332 def newDocNode(self, ns, name, content):
4333 """Creation of a new node element within a document. @ns and
4334 @content are optional (None). NOTE: @content is supposed to
4335 be a piece of XML CDATA, so it allow entities references,
4336 but XML special chars need to be escaped first by using
4337 xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you
4338 don't need entities support. """
4339 if ns is None: ns__o = None
4341 ret = libxml2mod.xmlNewDocNode(self._o, ns__o, name, content)
4342 if ret is None:raise treeError('xmlNewDocNode() failed')
4343 __tmp = xmlNode(_obj=ret)
4346 def newDocNodeEatName(self, ns, name, content):
4347 """Creation of a new node element within a document. @ns and
4348 @content are optional (None). NOTE: @content is supposed to
4349 be a piece of XML CDATA, so it allow entities references,
4350 but XML special chars need to be escaped first by using
4351 xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you
4352 don't need entities support. """
4353 if ns is None: ns__o = None
4355 ret = libxml2mod.xmlNewDocNodeEatName(self._o, ns__o, name, content)
4356 if ret is None:raise treeError('xmlNewDocNodeEatName() failed')
4357 __tmp = xmlNode(_obj=ret)
4360 def newDocPI(self, name, content):
4361 """Creation of a processing instruction element. """
4362 ret = libxml2mod.xmlNewDocPI(self._o, name, content)
4363 if ret is None:raise treeError('xmlNewDocPI() failed')
4364 __tmp = xmlNode(_obj=ret)
4367 def newDocProp(self, name, value):
4368 """Create a new property carried by a document. """
4369 ret = libxml2mod.xmlNewDocProp(self._o, name, value)
4370 if ret is None:raise treeError('xmlNewDocProp() failed')
4371 __tmp = xmlAttr(_obj=ret)
4374 def newDocRawNode(self, ns, name, content):
4375 """Creation of a new node element within a document. @ns and
4376 @content are optional (None). """
4377 if ns is None: ns__o = None
4379 ret = libxml2mod.xmlNewDocRawNode(self._o, ns__o, name, content)
4380 if ret is None:raise treeError('xmlNewDocRawNode() failed')
4381 __tmp = xmlNode(_obj=ret)
4384 def newDocText(self, content):
4385 """Creation of a new text node within a document. """
4386 ret = libxml2mod.xmlNewDocText(self._o, content)
4387 if ret is None:raise treeError('xmlNewDocText() failed')
4388 __tmp = xmlNode(_obj=ret)
4391 def newDocTextLen(self, content, len):
4392 """Creation of a new text node with an extra content length
4393 parameter. The text node pertain to a given document. """
4394 ret = libxml2mod.xmlNewDocTextLen(self._o, content, len)
4395 if ret is None:raise treeError('xmlNewDocTextLen() failed')
4396 __tmp = xmlNode(_obj=ret)
4399 def newDtd(self, name, ExternalID, SystemID):
4400 """Creation of a new DTD for the external subset. To create an
4401 internal subset, use xmlCreateIntSubset(). """
4402 ret = libxml2mod.xmlNewDtd(self._o, name, ExternalID, SystemID)
4403 if ret is None:raise treeError('xmlNewDtd() failed')
4404 __tmp = xmlDtd(_obj=ret)
4407 def newGlobalNs(self, href, prefix):
4408 """Creation of a Namespace, the old way using PI and without
4409 scoping DEPRECATED !!! """
4410 ret = libxml2mod.xmlNewGlobalNs(self._o, href, prefix)
4411 if ret is None:raise treeError('xmlNewGlobalNs() failed')
4412 __tmp = xmlNs(_obj=ret)
4415 def newReference(self, name):
4416 """Creation of a new reference node. """
4417 ret = libxml2mod.xmlNewReference(self._o, name)
4418 if ret is None:raise treeError('xmlNewReference() failed')
4419 __tmp = xmlNode(_obj=ret)
4422 def nodeDumpOutput(self, buf, cur, level, format, encoding):
4423 """Dump an XML node, recursive behaviour, children are printed
4424 too. Note that @format = 1 provide node indenting only if
4425 xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was
4427 if buf is None: buf__o = None
4428 else: buf__o = buf._o
4429 if cur is None: cur__o = None
4430 else: cur__o = cur._o
4431 libxml2mod.xmlNodeDumpOutput(buf__o, self._o, cur__o, level, format, encoding)
4433 def nodeGetBase(self, cur):
4434 """Searches for the BASE URL. The code should work on both XML
4435 and HTML document even if base mechanisms are completely
4436 different. It returns the base as defined in RFC 2396
4437 sections 5.1.1. Base URI within Document Content and 5.1.2.
4438 Base URI from the Encapsulating Entity However it does not
4439 return the document base (5.1.3), use doc->URL in this case """
4440 if cur is None: cur__o = None
4441 else: cur__o = cur._o
4442 ret = libxml2mod.xmlNodeGetBase(self._o, cur__o)
4445 def nodeListGetRawString(self, list, inLine):
4446 """Builds the string equivalent to the text contained in the
4447 Node list made of TEXTs and ENTITY_REFs, contrary to
4448 xmlNodeListGetString() this function doesn't do any
4449 character encoding handling. """
4450 if list is None: list__o = None
4451 else: list__o = list._o
4452 ret = libxml2mod.xmlNodeListGetRawString(self._o, list__o, inLine)
4455 def nodeListGetString(self, list, inLine):
4456 """Build the string equivalent to the text contained in the
4457 Node list made of TEXTs and ENTITY_REFs """
4458 if list is None: list__o = None
4459 else: list__o = list._o
4460 ret = libxml2mod.xmlNodeListGetString(self._o, list__o, inLine)
4463 def reconciliateNs(self, tree):
4464 """This function checks that all the namespaces declared
4465 within the given tree are properly declared. This is needed
4466 for example after Copy or Cut and then paste operations.
4467 The subtree may still hold pointers to namespace
4468 declarations outside the subtree or invalid/masked. As much
4469 as possible the function try to reuse the existing
4470 namespaces found in the new environment. If not possible
4471 the new namespaces are redeclared on @tree at the top of
4472 the given subtree. """
4473 if tree is None: tree__o = None
4474 else: tree__o = tree._o
4475 ret = libxml2mod.xmlReconciliateNs(self._o, tree__o)
4478 def saveFile(self, filename):
4479 """Dump an XML document to a file. Will use compression if
4480 compiled in and enabled. If @filename is "-" the stdout
4482 ret = libxml2mod.xmlSaveFile(filename, self._o)
4485 def saveFileEnc(self, filename, encoding):
4486 """Dump an XML document, converting it to the given encoding """
4487 ret = libxml2mod.xmlSaveFileEnc(filename, self._o, encoding)
4490 def saveFileTo(self, buf, encoding):
4491 """Dump an XML document to an I/O buffer. Warning ! This call
4492 xmlOutputBufferClose() on buf which is not available after
4494 if buf is None: buf__o = None
4495 else: buf__o = buf._o
4496 ret = libxml2mod.xmlSaveFileTo(buf__o, self._o, encoding)
4499 def saveFormatFile(self, filename, format):
4500 """Dump an XML document to a file. Will use compression if
4501 compiled in and enabled. If @filename is "-" the stdout
4502 file is used. If @format is set then the document will be
4503 indented on output. Note that @format = 1 provide node
4504 indenting only if xmlIndentTreeOutput = 1 or
4505 xmlKeepBlanksDefault(0) was called """
4506 ret = libxml2mod.xmlSaveFormatFile(filename, self._o, format)
4509 def saveFormatFileEnc(self, filename, encoding, format):
4510 """Dump an XML document to a file or an URL. """
4511 ret = libxml2mod.xmlSaveFormatFileEnc(filename, self._o, encoding, format)
4514 def saveFormatFileTo(self, buf, encoding, format):
4515 """Dump an XML document to an I/O buffer. Warning ! This call
4516 xmlOutputBufferClose() on buf which is not available after
4518 if buf is None: buf__o = None
4519 else: buf__o = buf._o
4520 ret = libxml2mod.xmlSaveFormatFileTo(buf__o, self._o, encoding, format)
4523 def searchNs(self, node, nameSpace):
4524 """Search a Ns registered under a given name space for a
4525 document. recurse on the parents until it finds the defined
4526 namespace or return None otherwise. @nameSpace can be None,
4527 this is a search for the default namespace. We don't allow
4528 to cross entities boundaries. If you don't declare the
4529 namespace within those you will be in troubles !!! A
4530 warning is generated to cover this case. """
4531 if node is None: node__o = None
4532 else: node__o = node._o
4533 ret = libxml2mod.xmlSearchNs(self._o, node__o, nameSpace)
4534 if ret is None:raise treeError('xmlSearchNs() failed')
4535 __tmp = xmlNs(_obj=ret)
4538 def searchNsByHref(self, node, href):
4539 """Search a Ns aliasing a given URI. Recurse on the parents
4540 until it finds the defined namespace or return None
4542 if node is None: node__o = None
4543 else: node__o = node._o
4544 ret = libxml2mod.xmlSearchNsByHref(self._o, node__o, href)
4545 if ret is None:raise treeError('xmlSearchNsByHref() failed')
4546 __tmp = xmlNs(_obj=ret)
4549 def setDocCompressMode(self, mode):
4550 """set the compression ratio for a document, ZLIB based
4551 Correct values: 0 (uncompressed) to 9 (max compression) """
4552 libxml2mod.xmlSetDocCompressMode(self._o, mode)
4554 def setListDoc(self, list):
4555 """update all nodes in the list to point to the right document """
4556 if list is None: list__o = None
4557 else: list__o = list._o
4558 libxml2mod.xmlSetListDoc(list__o, self._o)
4560 def setRootElement(self, root):
4561 """Set the root element of the document (doc->children is a
4562 list containing possibly comments, PIs, etc ...). """
4563 if root is None: root__o = None
4564 else: root__o = root._o
4565 ret = libxml2mod.xmlDocSetRootElement(self._o, root__o)
4566 if ret is None:return None
4567 __tmp = xmlNode(_obj=ret)
4570 def setTreeDoc(self, tree):
4571 """update all nodes under the tree to point to the right
4573 if tree is None: tree__o = None
4574 else: tree__o = tree._o
4575 libxml2mod.xmlSetTreeDoc(tree__o, self._o)
4577 def stringGetNodeList(self, value):
4578 """Parse the value string and build the node list associated.
4579 Should produce a flat tree with only TEXTs and ENTITY_REFs. """
4580 ret = libxml2mod.xmlStringGetNodeList(self._o, value)
4581 if ret is None:raise treeError('xmlStringGetNodeList() failed')
4582 __tmp = xmlNode(_obj=ret)
4585 def stringLenGetNodeList(self, value, len):
4586 """Parse the value string and build the node list associated.
4587 Should produce a flat tree with only TEXTs and ENTITY_REFs. """
4588 ret = libxml2mod.xmlStringLenGetNodeList(self._o, value, len)
4589 if ret is None:raise treeError('xmlStringLenGetNodeList() failed')
4590 __tmp = xmlNode(_obj=ret)
4594 # xmlDoc functions from module valid
4598 """Search the attribute declaring the given ID """
4599 ret = libxml2mod.xmlGetID(self._o, ID)
4600 if ret is None:raise treeError('xmlGetID() failed')
4601 __tmp = xmlAttr(_obj=ret)
4604 def isID(self, elem, attr):
4605 """Determine whether an attribute is of type ID. In case we
4606 have DTD(s) then this is done if DTD loading has been
4607 requested. In the case of HTML documents parsed with the
4608 HTML parser, then ID detection is done systematically. """
4609 if elem is None: elem__o = None
4610 else: elem__o = elem._o
4611 if attr is None: attr__o = None
4612 else: attr__o = attr._o
4613 ret = libxml2mod.xmlIsID(self._o, elem__o, attr__o)
4616 def isMixedElement(self, name):
4617 """Search in the DtDs whether an element accept Mixed content
4618 (or ANY) basically if it is supposed to accept text childs """
4619 ret = libxml2mod.xmlIsMixedElement(self._o, name)
4622 def isRef(self, elem, attr):
4623 """Determine whether an attribute is of type Ref. In case we
4624 have DTD(s) then this is simple, otherwise we use an
4625 heuristic: name Ref (upper or lowercase). """
4626 if elem is None: elem__o = None
4627 else: elem__o = elem._o
4628 if attr is None: attr__o = None
4629 else: attr__o = attr._o
4630 ret = libxml2mod.xmlIsRef(self._o, elem__o, attr__o)
4633 def removeID(self, attr):
4634 """Remove the given attribute from the ID table maintained
4636 if attr is None: attr__o = None
4637 else: attr__o = attr._o
4638 ret = libxml2mod.xmlRemoveID(self._o, attr__o)
4641 def removeRef(self, attr):
4642 """Remove the given attribute from the Ref table maintained
4644 if attr is None: attr__o = None
4645 else: attr__o = attr._o
4646 ret = libxml2mod.xmlRemoveRef(self._o, attr__o)
4649 def validCtxtNormalizeAttributeValue(self, ctxt, elem, name, value):
4650 """Does the validation related extra step of the normalization
4651 of attribute values: If the declared value is not CDATA,
4652 then the XML processor must further process the normalized
4653 attribute value by discarding any leading and trailing
4654 space (#x20) characters, and by replacing sequences of
4655 space (#x20) characters by single space (#x20) character.
4656 Also check VC: Standalone Document Declaration in P32, and
4657 update ctxt->valid accordingly """
4658 if ctxt is None: ctxt__o = None
4659 else: ctxt__o = ctxt._o
4660 if elem is None: elem__o = None
4661 else: elem__o = elem._o
4662 ret = libxml2mod.xmlValidCtxtNormalizeAttributeValue(ctxt__o, self._o, elem__o, name, value)
4665 def validNormalizeAttributeValue(self, elem, name, value):
4666 """Does the validation related extra step of the normalization
4667 of attribute values: If the declared value is not CDATA,
4668 then the XML processor must further process the normalized
4669 attribute value by discarding any leading and trailing
4670 space (#x20) characters, and by replacing sequences of
4671 space (#x20) characters by single space (#x20) character. """
4672 if elem is None: elem__o = None
4673 else: elem__o = elem._o
4674 ret = libxml2mod.xmlValidNormalizeAttributeValue(self._o, elem__o, name, value)
4677 def validateDocument(self, ctxt):
4678 """Try to validate the document instance basically it does
4679 the all the checks described by the XML Rec i.e. validates
4680 the internal and external subset (if present) and validate
4681 the document tree. """
4682 if ctxt is None: ctxt__o = None
4683 else: ctxt__o = ctxt._o
4684 ret = libxml2mod.xmlValidateDocument(ctxt__o, self._o)
4687 def validateDocumentFinal(self, ctxt):
4688 """Does the final step for the document validation once all
4689 the incremental validation steps have been completed
4690 basically it does the following checks described by the XML
4691 Rec Check all the IDREF/IDREFS attributes definition for
4693 if ctxt is None: ctxt__o = None
4694 else: ctxt__o = ctxt._o
4695 ret = libxml2mod.xmlValidateDocumentFinal(ctxt__o, self._o)
4698 def validateDtd(self, ctxt, dtd):
4699 """Try to validate the document against the dtd instance
4700 Basically it does check all the definitions in the DtD.
4701 Note the the internal subset (if present) is de-coupled
4702 (i.e. not used), which could give problems if ID or IDREF
4704 if ctxt is None: ctxt__o = None
4705 else: ctxt__o = ctxt._o
4706 if dtd is None: dtd__o = None
4707 else: dtd__o = dtd._o
4708 ret = libxml2mod.xmlValidateDtd(ctxt__o, self._o, dtd__o)
4711 def validateDtdFinal(self, ctxt):
4712 """Does the final step for the dtds validation once all the
4713 subsets have been parsed basically it does the following
4714 checks described by the XML Rec - check that ENTITY and
4715 ENTITIES type attributes default or possible values matches
4716 one of the defined entities. - check that NOTATION type
4717 attributes default or possible values matches one of the
4718 defined notations. """
4719 if ctxt is None: ctxt__o = None
4720 else: ctxt__o = ctxt._o
4721 ret = libxml2mod.xmlValidateDtdFinal(ctxt__o, self._o)
4724 def validateElement(self, ctxt, elem):
4725 """Try to validate the subtree under an element """
4726 if ctxt is None: ctxt__o = None
4727 else: ctxt__o = ctxt._o
4728 if elem is None: elem__o = None
4729 else: elem__o = elem._o
4730 ret = libxml2mod.xmlValidateElement(ctxt__o, self._o, elem__o)
4733 def validateNotationUse(self, ctxt, notationName):
4734 """Validate that the given name match a notation declaration.
4735 - [ VC: Notation Declared ] """
4736 if ctxt is None: ctxt__o = None
4737 else: ctxt__o = ctxt._o
4738 ret = libxml2mod.xmlValidateNotationUse(ctxt__o, self._o, notationName)
4741 def validateOneAttribute(self, ctxt, elem, attr, value):
4742 """Try to validate a single attribute for an element basically
4743 it does the following checks as described by the XML-1.0
4744 recommendation: - [ VC: Attribute Value Type ] - [ VC:
4745 Fixed Attribute Default ] - [ VC: Entity Name ] - [ VC:
4746 Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC: Entity
4747 Name ] - [ VC: Notation Attributes ] The ID/IDREF
4748 uniqueness and matching are done separately """
4749 if ctxt is None: ctxt__o = None
4750 else: ctxt__o = ctxt._o
4751 if elem is None: elem__o = None
4752 else: elem__o = elem._o
4753 if attr is None: attr__o = None
4754 else: attr__o = attr._o
4755 ret = libxml2mod.xmlValidateOneAttribute(ctxt__o, self._o, elem__o, attr__o, value)
4758 def validateOneElement(self, ctxt, elem):
4759 """Try to validate a single element and it's attributes,
4760 basically it does the following checks as described by the
4761 XML-1.0 recommendation: - [ VC: Element Valid ] - [ VC:
4762 Required Attribute ] Then call xmlValidateOneAttribute()
4763 for each attribute present. The ID/IDREF checkings are
4765 if ctxt is None: ctxt__o = None
4766 else: ctxt__o = ctxt._o
4767 if elem is None: elem__o = None
4768 else: elem__o = elem._o
4769 ret = libxml2mod.xmlValidateOneElement(ctxt__o, self._o, elem__o)
4772 def validateOneNamespace(self, ctxt, elem, prefix, ns, value):
4773 """Try to validate a single namespace declaration for an
4774 element basically it does the following checks as described
4775 by the XML-1.0 recommendation: - [ VC: Attribute Value Type
4776 ] - [ VC: Fixed Attribute Default ] - [ VC: Entity Name ] -
4777 [ VC: Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC:
4778 Entity Name ] - [ VC: Notation Attributes ] The ID/IDREF
4779 uniqueness and matching are done separately """
4780 if ctxt is None: ctxt__o = None
4781 else: ctxt__o = ctxt._o
4782 if elem is None: elem__o = None
4783 else: elem__o = elem._o
4784 if ns is None: ns__o = None
4786 ret = libxml2mod.xmlValidateOneNamespace(ctxt__o, self._o, elem__o, prefix, ns__o, value)
4789 def validatePopElement(self, ctxt, elem, qname):
4790 """Pop the element end from the validation stack. """
4791 if ctxt is None: ctxt__o = None
4792 else: ctxt__o = ctxt._o
4793 if elem is None: elem__o = None
4794 else: elem__o = elem._o
4795 ret = libxml2mod.xmlValidatePopElement(ctxt__o, self._o, elem__o, qname)
4798 def validatePushElement(self, ctxt, elem, qname):
4799 """Push a new element start on the validation stack. """
4800 if ctxt is None: ctxt__o = None
4801 else: ctxt__o = ctxt._o
4802 if elem is None: elem__o = None
4803 else: elem__o = elem._o
4804 ret = libxml2mod.xmlValidatePushElement(ctxt__o, self._o, elem__o, qname)
4807 def validateRoot(self, ctxt):
4808 """Try to validate a the root element basically it does the
4809 following check as described by the XML-1.0 recommendation:
4810 - [ VC: Root Element Type ] it doesn't try to recurse or
4811 apply other check to the element """
4812 if ctxt is None: ctxt__o = None
4813 else: ctxt__o = ctxt._o
4814 ret = libxml2mod.xmlValidateRoot(ctxt__o, self._o)
4818 # xmlDoc functions from module xinclude
4821 def xincludeProcess(self):
4822 """Implement the XInclude substitution on the XML document @doc """
4823 ret = libxml2mod.xmlXIncludeProcess(self._o)
4826 def xincludeProcessFlags(self, flags):
4827 """Implement the XInclude substitution on the XML document @doc """
4828 ret = libxml2mod.xmlXIncludeProcessFlags(self._o, flags)
4832 # xmlDoc functions from module xmlreader
4835 def NewWalker(self, reader):
4836 """Setup an xmltextReader to parse a preparsed XML document.
4837 This reuses the existing @reader xmlTextReader. """
4838 if reader is None: reader__o = None
4839 else: reader__o = reader._o
4840 ret = libxml2mod.xmlReaderNewWalker(reader__o, self._o)
4843 def readerWalker(self):
4844 """Create an xmltextReader for a preparsed document. """
4845 ret = libxml2mod.xmlReaderWalker(self._o)
4846 if ret is None:raise treeError('xmlReaderWalker() failed')
4847 __tmp = xmlTextReader(_obj=ret)
4851 # xmlDoc functions from module xmlschemas
4854 def schemaNewDocParserCtxt(self):
4855 """Create an XML Schemas parse context for that document. NB.
4856 The document may be modified during the parsing process. """
4857 ret = libxml2mod.xmlSchemaNewDocParserCtxt(self._o)
4858 if ret is None:raise parserError('xmlSchemaNewDocParserCtxt() failed')
4859 __tmp = SchemaParserCtxt(_obj=ret)
4862 def schemaValidateDoc(self, ctxt):
4863 """Validate a document tree in memory. """
4864 if ctxt is None: ctxt__o = None
4865 else: ctxt__o = ctxt._o
4866 ret = libxml2mod.xmlSchemaValidateDoc(ctxt__o, self._o)
4870 # xmlDoc functions from module xpath
4873 def xpathNewContext(self):
4874 """Create a new xmlXPathContext """
4875 ret = libxml2mod.xmlXPathNewContext(self._o)
4876 if ret is None:raise xpathError('xmlXPathNewContext() failed')
4877 __tmp = xpathContext(_obj=ret)
4880 def xpathOrderDocElems(self):
4881 """Call this routine to speed up XPath computation on static
4882 documents. This stamps all the element nodes with the
4883 document order Like for line information, the order is kept
4884 in the element->content field, the value stored is actually
4885 - the node number (starting at -1) to be able to
4886 differentiate from line numbers. """
4887 ret = libxml2mod.xmlXPathOrderDocElems(self._o)
4891 # xmlDoc functions from module xpointer
4894 def xpointerNewContext(self, here, origin):
4895 """Create a new XPointer context """
4896 if here is None: here__o = None
4897 else: here__o = here._o
4898 if origin is None: origin__o = None
4899 else: origin__o = origin._o
4900 ret = libxml2mod.xmlXPtrNewContext(self._o, here__o, origin__o)
4901 if ret is None:raise treeError('xmlXPtrNewContext() failed')
4902 __tmp = xpathContext(_obj=ret)
4905 class parserCtxt(parserCtxtCore):
4906 def __init__(self, _obj=None):
4908 parserCtxtCore.__init__(self, _obj=_obj)
4912 libxml2mod.xmlFreeParserCtxt(self._o)
4915 # accessors for parserCtxt
4917 """Get the document tree from a parser context. """
4918 ret = libxml2mod.xmlParserGetDoc(self._o)
4919 if ret is None:raise parserError('xmlParserGetDoc() failed')
4920 __tmp = xmlDoc(_obj=ret)
4924 """Get the validity information from a parser context. """
4925 ret = libxml2mod.xmlParserGetIsValid(self._o)
4928 def lineNumbers(self, linenumbers):
4929 """Switch on the generation of line number for elements nodes. """
4930 libxml2mod.xmlParserSetLineNumbers(self._o, linenumbers)
4932 def loadSubset(self, loadsubset):
4933 """Switch the parser to load the DTD without validating. """
4934 libxml2mod.xmlParserSetLoadSubset(self._o, loadsubset)
4936 def pedantic(self, pedantic):
4937 """Switch the parser to be pedantic. """
4938 libxml2mod.xmlParserSetPedantic(self._o, pedantic)
4940 def replaceEntities(self, replaceEntities):
4941 """Switch the parser to replace entities. """
4942 libxml2mod.xmlParserSetReplaceEntities(self._o, replaceEntities)
4944 def validate(self, validate):
4945 """Switch the parser to validation mode. """
4946 libxml2mod.xmlParserSetValidate(self._o, validate)
4948 def wellFormed(self):
4949 """Get the well formed information from a parser context. """
4950 ret = libxml2mod.xmlParserGetWellFormed(self._o)
4954 # parserCtxt functions from module HTMLparser
4957 def htmlCtxtReadDoc(self, cur, URL, encoding, options):
4958 """parse an XML in-memory document and build a tree. This
4959 reuses the existing @ctxt parser context """
4960 ret = libxml2mod.htmlCtxtReadDoc(self._o, cur, URL, encoding, options)
4961 if ret is None:raise treeError('htmlCtxtReadDoc() failed')
4962 __tmp = xmlDoc(_obj=ret)
4965 def htmlCtxtReadFd(self, fd, URL, encoding, options):
4966 """parse an XML from a file descriptor and build a tree. This
4967 reuses the existing @ctxt parser context """
4968 ret = libxml2mod.htmlCtxtReadFd(self._o, fd, URL, encoding, options)
4969 if ret is None:raise treeError('htmlCtxtReadFd() failed')
4970 __tmp = xmlDoc(_obj=ret)
4973 def htmlCtxtReadFile(self, filename, encoding, options):
4974 """parse an XML file from the filesystem or the network. This
4975 reuses the existing @ctxt parser context """
4976 ret = libxml2mod.htmlCtxtReadFile(self._o, filename, encoding, options)
4977 if ret is None:raise treeError('htmlCtxtReadFile() failed')
4978 __tmp = xmlDoc(_obj=ret)
4981 def htmlCtxtReadMemory(self, buffer, size, URL, encoding, options):
4982 """parse an XML in-memory document and build a tree. This
4983 reuses the existing @ctxt parser context """
4984 ret = libxml2mod.htmlCtxtReadMemory(self._o, buffer, size, URL, encoding, options)
4985 if ret is None:raise treeError('htmlCtxtReadMemory() failed')
4986 __tmp = xmlDoc(_obj=ret)
4989 def htmlCtxtReset(self):
4990 """Reset a parser context """
4991 libxml2mod.htmlCtxtReset(self._o)
4993 def htmlCtxtUseOptions(self, options):
4994 """Applies the options to the parser context """
4995 ret = libxml2mod.htmlCtxtUseOptions(self._o, options)
4998 def htmlFreeParserCtxt(self):
4999 """Free all the memory used by a parser context. However the
5000 parsed document in ctxt->myDoc is not freed. """
5001 libxml2mod.htmlFreeParserCtxt(self._o)
5003 def htmlParseCharRef(self):
5004 """parse Reference declarations [66] CharRef ::= '&#' [0-9]+
5005 ';' | '&#x' [0-9a-fA-F]+ ';' """
5006 ret = libxml2mod.htmlParseCharRef(self._o)
5009 def htmlParseChunk(self, chunk, size, terminate):
5010 """Parse a Chunk of memory """
5011 ret = libxml2mod.htmlParseChunk(self._o, chunk, size, terminate)
5014 def htmlParseDocument(self):
5015 """parse an HTML document (and build a tree if using the
5016 standard SAX interface). """
5017 ret = libxml2mod.htmlParseDocument(self._o)
5020 def htmlParseElement(self):
5021 """parse an HTML element, this is highly recursive this is
5022 kept for compatibility with previous code versions [39]
5023 element ::= EmptyElemTag | STag content ETag [41]
5024 Attribute ::= Name Eq AttValue """
5025 libxml2mod.htmlParseElement(self._o)
5028 # parserCtxt functions from module parser
5031 def byteConsumed(self):
5032 """This function provides the current index of the parser
5033 relative to the start of the current entity. This function
5034 is computed in bytes from the beginning starting at zero
5035 and finishing at the size in byte of the file if parsing a
5036 file. The function is of constant cost if the input is
5037 UTF-8 but can be costly if run on non-UTF-8 input. """
5038 ret = libxml2mod.xmlByteConsumed(self._o)
5041 def clearParserCtxt(self):
5042 """Clear (release owned resources) and reinitialize a parser
5044 libxml2mod.xmlClearParserCtxt(self._o)
5046 def ctxtReadDoc(self, cur, URL, encoding, options):
5047 """parse an XML in-memory document and build a tree. This
5048 reuses the existing @ctxt parser context """
5049 ret = libxml2mod.xmlCtxtReadDoc(self._o, cur, URL, encoding, options)
5050 if ret is None:raise treeError('xmlCtxtReadDoc() failed')
5051 __tmp = xmlDoc(_obj=ret)
5054 def ctxtReadFd(self, fd, URL, encoding, options):
5055 """parse an XML from a file descriptor and build a tree. This
5056 reuses the existing @ctxt parser context NOTE that the file
5057 descriptor will not be closed when the reader is closed or
5059 ret = libxml2mod.xmlCtxtReadFd(self._o, fd, URL, encoding, options)
5060 if ret is None:raise treeError('xmlCtxtReadFd() failed')
5061 __tmp = xmlDoc(_obj=ret)
5064 def ctxtReadFile(self, filename, encoding, options):
5065 """parse an XML file from the filesystem or the network. This
5066 reuses the existing @ctxt parser context """
5067 ret = libxml2mod.xmlCtxtReadFile(self._o, filename, encoding, options)
5068 if ret is None:raise treeError('xmlCtxtReadFile() failed')
5069 __tmp = xmlDoc(_obj=ret)
5072 def ctxtReadMemory(self, buffer, size, URL, encoding, options):
5073 """parse an XML in-memory document and build a tree. This
5074 reuses the existing @ctxt parser context """
5075 ret = libxml2mod.xmlCtxtReadMemory(self._o, buffer, size, URL, encoding, options)
5076 if ret is None:raise treeError('xmlCtxtReadMemory() failed')
5077 __tmp = xmlDoc(_obj=ret)
5080 def ctxtReset(self):
5081 """Reset a parser context """
5082 libxml2mod.xmlCtxtReset(self._o)
5084 def ctxtResetPush(self, chunk, size, filename, encoding):
5085 """Reset a push parser context """
5086 ret = libxml2mod.xmlCtxtResetPush(self._o, chunk, size, filename, encoding)
5089 def ctxtUseOptions(self, options):
5090 """Applies the options to the parser context """
5091 ret = libxml2mod.xmlCtxtUseOptions(self._o, options)
5094 def initParserCtxt(self):
5095 """Initialize a parser context """
5096 ret = libxml2mod.xmlInitParserCtxt(self._o)
5099 def parseChunk(self, chunk, size, terminate):
5100 """Parse a Chunk of memory """
5101 ret = libxml2mod.xmlParseChunk(self._o, chunk, size, terminate)
5104 def parseDocument(self):
5105 """parse an XML document (and build a tree if using the
5106 standard SAX interface). [1] document ::= prolog element
5107 Misc* [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)? """
5108 ret = libxml2mod.xmlParseDocument(self._o)
5111 def parseExtParsedEnt(self):
5112 """parse a general parsed entity An external general parsed
5113 entity is well-formed if it matches the production labeled
5114 extParsedEnt. [78] extParsedEnt ::= TextDecl? content """
5115 ret = libxml2mod.xmlParseExtParsedEnt(self._o)
5118 def setupParserForBuffer(self, buffer, filename):
5119 """Setup the parser context to parse a new buffer; Clears any
5120 prior contents from the parser context. The buffer
5121 parameter must not be None, but the filename parameter can
5123 libxml2mod.xmlSetupParserForBuffer(self._o, buffer, filename)
5125 def stopParser(self):
5126 """Blocks further parser processing """
5127 libxml2mod.xmlStopParser(self._o)
5130 # parserCtxt functions from module parserInternals
5133 def decodeEntities(self, len, what, end, end2, end3):
5134 """This function is deprecated, we now always process entities
5135 content through xmlStringDecodeEntities TODO: remove it in
5136 next major release. [67] Reference ::= EntityRef | CharRef
5137 [69] PEReference ::= '%' Name ';' """
5138 ret = libxml2mod.xmlDecodeEntities(self._o, len, what, end, end2, end3)
5141 def handleEntity(self, entity):
5142 """Default handling of defined entities, when should we define
5143 a new input stream ? When do we just handle that as a set
5144 of chars ? OBSOLETE: to be removed at some point. """
5145 if entity is None: entity__o = None
5146 else: entity__o = entity._o
5147 libxml2mod.xmlHandleEntity(self._o, entity__o)
5149 def namespaceParseNCName(self):
5150 """parse an XML namespace name. TODO: this seems not in use
5151 anymore, the namespace handling is done on top of the SAX
5152 interfaces, i.e. not on raw input. [NS 3] NCName ::=
5153 (Letter | '_') (NCNameChar)* [NS 4] NCNameChar ::= Letter
5154 | Digit | '.' | '-' | '_' | CombiningChar | Extender """
5155 ret = libxml2mod.xmlNamespaceParseNCName(self._o)
5158 def namespaceParseNSDef(self):
5159 """parse a namespace prefix declaration TODO: this seems not
5160 in use anymore, the namespace handling is done on top of
5161 the SAX interfaces, i.e. not on raw input. [NS 1] NSDef
5162 ::= PrefixDef Eq SystemLiteral [NS 2] PrefixDef ::=
5163 'xmlns' (':' NCName)? """
5164 ret = libxml2mod.xmlNamespaceParseNSDef(self._o)
5168 """Skip to the next char input char. """
5169 libxml2mod.xmlNextChar(self._o)
5171 def parseAttValue(self):
5172 """parse a value for an attribute Note: the parser won't do
5173 substitution of entities here, this will be handled later
5174 in xmlStringGetNodeList [10] AttValue ::= '"' ([^<&"] |
5175 Reference)* '"' | "'" ([^<&'] | Reference)* "'" 3.3.3
5176 Attribute-Value Normalization: Before the value of an
5177 attribute is passed to the application or checked for
5178 validity, the XML processor must normalize it as follows: -
5179 a character reference is processed by appending the
5180 referenced character to the attribute value - an entity
5181 reference is processed by recursively processing the
5182 replacement text of the entity - a whitespace character
5183 (#x20, #xD, #xA, #x9) is processed by appending #x20 to the
5184 normalized value, except that only a single #x20 is
5185 appended for a "#xD#xA" sequence that is part of an
5186 external parsed entity or the literal entity value of an
5187 internal parsed entity - other characters are processed by
5188 appending them to the normalized value If the declared
5189 value is not CDATA, then the XML processor must further
5190 process the normalized attribute value by discarding any
5191 leading and trailing space (#x20) characters, and by
5192 replacing sequences of space (#x20) characters by a single
5193 space (#x20) character. All attributes for which no
5194 declaration has been read should be treated by a
5195 non-validating parser as if declared CDATA. """
5196 ret = libxml2mod.xmlParseAttValue(self._o)
5199 def parseAttributeListDecl(self):
5200 """: parse the Attribute list def for an element [52]
5201 AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>' [53]
5202 AttDef ::= S Name S AttType S DefaultDecl """
5203 libxml2mod.xmlParseAttributeListDecl(self._o)
5205 def parseCDSect(self):
5206 """Parse escaped pure raw content. [18] CDSect ::= CDStart
5207 CData CDEnd [19] CDStart ::= '<![CDATA[' [20] Data ::=
5208 (Char* - (Char* ']]>' Char*)) [21] CDEnd ::= ']]>' """
5209 libxml2mod.xmlParseCDSect(self._o)
5211 def parseCharData(self, cdata):
5212 """parse a CharData section. if we are within a CDATA section
5213 ']]>' marks an end of section. The right angle bracket (>)
5214 may be represented using the string ">", and must, for
5215 compatibility, be escaped using ">" or a character
5216 reference when it appears in the string "]]>" in content,
5217 when that string is not marking the end of a CDATA section.
5218 [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) """
5219 libxml2mod.xmlParseCharData(self._o, cdata)
5221 def parseCharRef(self):
5222 """parse Reference declarations [66] CharRef ::= '&#' [0-9]+
5223 ';' | '&#x' [0-9a-fA-F]+ ';' [ WFC: Legal Character ]
5224 Characters referred to using character references must
5225 match the production for Char. """
5226 ret = libxml2mod.xmlParseCharRef(self._o)
5229 def parseComment(self):
5230 """Skip an XML (SGML) comment <!-- .... --> The spec says that
5231 "For compatibility, the string "--" (double-hyphen) must
5232 not occur within comments. " [15] Comment ::= '<!--'
5233 ((Char - '-') | ('-' (Char - '-')))* '-->' """
5234 libxml2mod.xmlParseComment(self._o)
5236 def parseContent(self):
5237 """Parse a content: [43] content ::= (element | CharData |
5238 Reference | CDSect | PI | Comment)* """
5239 libxml2mod.xmlParseContent(self._o)
5241 def parseDocTypeDecl(self):
5242 """parse a DOCTYPE declaration [28] doctypedecl ::=
5243 '<!DOCTYPE' S Name (S ExternalID)? S? ('[' (markupdecl |
5244 PEReference | S)* ']' S?)? '>' [ VC: Root Element Type ]
5245 The Name in the document type declaration must match the
5246 element type of the root element. """
5247 libxml2mod.xmlParseDocTypeDecl(self._o)
5249 def parseElement(self):
5250 """parse an XML element, this is highly recursive [39]
5251 element ::= EmptyElemTag | STag content ETag [ WFC:
5252 Element Type Match ] The Name in an element's end-tag must
5253 match the element type in the start-tag. """
5254 libxml2mod.xmlParseElement(self._o)
5256 def parseElementDecl(self):
5257 """parse an Element declaration. [45] elementdecl ::=
5258 '<!ELEMENT' S Name S contentspec S? '>' [ VC: Unique
5259 Element Type Declaration ] No element type may be declared
5261 ret = libxml2mod.xmlParseElementDecl(self._o)
5264 def parseEncName(self):
5265 """parse the XML encoding name [81] EncName ::= [A-Za-z]
5266 ([A-Za-z0-9._] | '-')* """
5267 ret = libxml2mod.xmlParseEncName(self._o)
5270 def parseEncodingDecl(self):
5271 """parse the XML encoding declaration [80] EncodingDecl ::= S
5272 'encoding' Eq ('"' EncName '"' | "'" EncName "'") this
5273 setups the conversion filters. """
5274 ret = libxml2mod.xmlParseEncodingDecl(self._o)
5277 def parseEndTag(self):
5278 """parse an end of tag [42] ETag ::= '</' Name S? '>' With
5279 namespace [NS 9] ETag ::= '</' QName S? '>' """
5280 libxml2mod.xmlParseEndTag(self._o)
5282 def parseEntityDecl(self):
5283 """parse <!ENTITY declarations [70] EntityDecl ::= GEDecl |
5284 PEDecl [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S?
5285 '>' [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
5286 [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)
5287 [74] PEDef ::= EntityValue | ExternalID [76] NDataDecl ::=
5288 S 'NDATA' S Name [ VC: Notation Declared ] The Name must
5289 match the declared name of a notation. """
5290 libxml2mod.xmlParseEntityDecl(self._o)
5292 def parseEntityRef(self):
5293 """parse ENTITY references declarations [68] EntityRef ::=
5294 '&' Name ';' [ WFC: Entity Declared ] In a document
5295 without any DTD, a document with only an internal DTD
5296 subset which contains no parameter entity references, or a
5297 document with "standalone='yes'", the Name given in the
5298 entity reference must match that in an entity declaration,
5299 except that well-formed documents need not declare any of
5300 the following entities: amp, lt, gt, apos, quot. The
5301 declaration of a parameter entity must precede any
5302 reference to it. Similarly, the declaration of a general
5303 entity must precede any reference to it which appears in a
5304 default value in an attribute-list declaration. Note that
5305 if entities are declared in the external subset or in
5306 external parameter entities, a non-validating processor is
5307 not obligated to read and process their declarations; for
5308 such documents, the rule that an entity must be declared is
5309 a well-formedness constraint only if standalone='yes'. [
5310 WFC: Parsed Entity ] An entity reference must not contain
5311 the name of an unparsed entity """
5312 ret = libxml2mod.xmlParseEntityRef(self._o)
5313 if ret is None:raise parserError('xmlParseEntityRef() failed')
5314 __tmp = xmlEntity(_obj=ret)
5317 def parseExternalSubset(self, ExternalID, SystemID):
5318 """parse Markup declarations from an external subset [30]
5319 extSubset ::= textDecl? extSubsetDecl [31] extSubsetDecl
5320 ::= (markupdecl | conditionalSect | PEReference | S) * """
5321 libxml2mod.xmlParseExternalSubset(self._o, ExternalID, SystemID)
5323 def parseMarkupDecl(self):
5324 """parse Markup declarations [29] markupdecl ::= elementdecl
5325 | AttlistDecl | EntityDecl | NotationDecl | PI | Comment [
5326 VC: Proper Declaration/PE Nesting ] Parameter-entity
5327 replacement text must be properly nested with markup
5328 declarations. That is to say, if either the first character
5329 or the last character of a markup declaration (markupdecl
5330 above) is contained in the replacement text for a
5331 parameter-entity reference, both must be contained in the
5332 same replacement text. [ WFC: PEs in Internal Subset ] In
5333 the internal DTD subset, parameter-entity references can
5334 occur only where markup declarations can occur, not within
5335 markup declarations. (This does not apply to references
5336 that occur in external parameter entities or to the
5337 external subset.) """
5338 libxml2mod.xmlParseMarkupDecl(self._o)
5340 def parseMisc(self):
5341 """parse an XML Misc* optional field. [27] Misc ::= Comment |
5343 libxml2mod.xmlParseMisc(self._o)
5345 def parseName(self):
5346 """parse an XML name. [4] NameChar ::= Letter | Digit | '.' |
5347 '-' | '_' | ':' | CombiningChar | Extender [5] Name ::=
5348 (Letter | '_' | ':') (NameChar)* [6] Names ::= Name (#x20
5350 ret = libxml2mod.xmlParseName(self._o)
5353 def parseNamespace(self):
5354 """xmlParseNamespace: parse specific PI '<?namespace ...'
5355 constructs. This is what the older xml-name Working Draft
5356 specified, a bunch of other stuff may still rely on it, so
5357 support is still here as if it was declared on the root of
5358 the Tree:-( TODO: remove from library To be removed at
5359 next drop of binary compatibility """
5360 libxml2mod.xmlParseNamespace(self._o)
5362 def parseNmtoken(self):
5363 """parse an XML Nmtoken. [7] Nmtoken ::= (NameChar)+ [8]
5364 Nmtokens ::= Nmtoken (#x20 Nmtoken)* """
5365 ret = libxml2mod.xmlParseNmtoken(self._o)
5368 def parseNotationDecl(self):
5369 """parse a notation declaration [82] NotationDecl ::=
5370 '<!NOTATION' S Name S (ExternalID | PublicID) S? '>'
5371 Hence there is actually 3 choices: 'PUBLIC' S PubidLiteral
5372 'PUBLIC' S PubidLiteral S SystemLiteral and 'SYSTEM' S
5373 SystemLiteral See the NOTE on xmlParseExternalID(). """
5374 libxml2mod.xmlParseNotationDecl(self._o)
5376 def parsePEReference(self):
5377 """parse PEReference declarations The entity content is
5378 handled directly by pushing it's content as a new input
5379 stream. [69] PEReference ::= '%' Name ';' [ WFC: No
5380 Recursion ] A parsed entity must not contain a recursive
5381 reference to itself, either directly or indirectly. [ WFC:
5382 Entity Declared ] In a document without any DTD, a document
5383 with only an internal DTD subset which contains no
5384 parameter entity references, or a document with
5385 "standalone='yes'", ... ... The declaration of a parameter
5386 entity must precede any reference to it... [ VC: Entity
5387 Declared ] In a document with an external subset or
5388 external parameter entities with "standalone='no'", ...
5389 ... The declaration of a parameter entity must precede any
5390 reference to it... [ WFC: In DTD ] Parameter-entity
5391 references may only appear in the DTD. NOTE: misleading but
5392 this is handled. """
5393 libxml2mod.xmlParsePEReference(self._o)
5396 """parse an XML Processing Instruction. [16] PI ::= '<?'
5397 PITarget (S (Char* - (Char* '?>' Char*)))? '?>' The
5398 processing is transfered to SAX once parsed. """
5399 libxml2mod.xmlParsePI(self._o)
5401 def parsePITarget(self):
5402 """parse the name of a PI [17] PITarget ::= Name - (('X' |
5403 'x') ('M' | 'm') ('L' | 'l')) """
5404 ret = libxml2mod.xmlParsePITarget(self._o)
5407 def parsePubidLiteral(self):
5408 """parse an XML public literal [12] PubidLiteral ::= '"'
5409 PubidChar* '"' | "'" (PubidChar - "'")* "'" """
5410 ret = libxml2mod.xmlParsePubidLiteral(self._o)
5413 def parseQuotedString(self):
5414 """Parse and return a string between quotes or doublequotes
5415 TODO: Deprecated, to be removed at next drop of binary
5417 ret = libxml2mod.xmlParseQuotedString(self._o)
5420 def parseReference(self):
5421 """parse and handle entity references in content, depending on
5422 the SAX interface, this may end-up in a call to character()
5423 if this is a CharRef, a predefined entity, if there is no
5424 reference() callback. or if the parser was asked to switch
5425 to that mode. [67] Reference ::= EntityRef | CharRef """
5426 libxml2mod.xmlParseReference(self._o)
5428 def parseSDDecl(self):
5429 """parse the XML standalone declaration [32] SDDecl ::= S
5430 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' |
5431 'no')'"')) [ VC: Standalone Document Declaration ] TODO
5432 The standalone document declaration must have the value
5433 "no" if any external markup declarations contain
5434 declarations of: - attributes with default values, if
5435 elements to which these attributes apply appear in the
5436 document without specifications of values for these
5437 attributes, or - entities (other than amp, lt, gt, apos,
5438 quot), if references to those entities appear in the
5439 document, or - attributes with values subject to
5440 normalization, where the attribute appears in the document
5441 with a value which will change as a result of
5442 normalization, or - element types with element content, if
5443 white space occurs directly within any instance of those
5445 ret = libxml2mod.xmlParseSDDecl(self._o)
5448 def parseStartTag(self):
5449 """parse a start of tag either for rule element or
5450 EmptyElement. In both case we don't parse the tag closing
5451 chars. [40] STag ::= '<' Name (S Attribute)* S? '>' [
5452 WFC: Unique Att Spec ] No attribute name may appear more
5453 than once in the same start-tag or empty-element tag. [44]
5454 EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' [ WFC:
5455 Unique Att Spec ] No attribute name may appear more than
5456 once in the same start-tag or empty-element tag. With
5457 namespace: [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
5458 [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>' """
5459 ret = libxml2mod.xmlParseStartTag(self._o)
5462 def parseSystemLiteral(self):
5463 """parse an XML Literal [11] SystemLiteral ::= ('"' [^"]*
5464 '"') | ("'" [^']* "'") """
5465 ret = libxml2mod.xmlParseSystemLiteral(self._o)
5468 def parseTextDecl(self):
5469 """parse an XML declaration header for external entities [77]
5470 TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>' """
5471 libxml2mod.xmlParseTextDecl(self._o)
5473 def parseVersionInfo(self):
5474 """parse the XML version. [24] VersionInfo ::= S 'version' Eq
5475 (' VersionNum ' | " VersionNum ") [25] Eq ::= S? '=' S? """
5476 ret = libxml2mod.xmlParseVersionInfo(self._o)
5479 def parseVersionNum(self):
5480 """parse the XML version value. [26] VersionNum ::= '1.'
5481 [0-9]+ In practice allow [0-9].[0-9]+ at that level """
5482 ret = libxml2mod.xmlParseVersionNum(self._o)
5485 def parseXMLDecl(self):
5486 """parse an XML declaration header [23] XMLDecl ::= '<?xml'
5487 VersionInfo EncodingDecl? SDDecl? S? '?>' """
5488 libxml2mod.xmlParseXMLDecl(self._o)
5490 def parserHandlePEReference(self):
5491 """[69] PEReference ::= '%' Name ';' [ WFC: No Recursion ] A
5492 parsed entity must not contain a recursive reference to
5493 itself, either directly or indirectly. [ WFC: Entity
5494 Declared ] In a document without any DTD, a document with
5495 only an internal DTD subset which contains no parameter
5496 entity references, or a document with "standalone='yes'",
5497 ... ... The declaration of a parameter entity must precede
5498 any reference to it... [ VC: Entity Declared ] In a
5499 document with an external subset or external parameter
5500 entities with "standalone='no'", ... ... The declaration
5501 of a parameter entity must precede any reference to it...
5502 [ WFC: In DTD ] Parameter-entity references may only appear
5503 in the DTD. NOTE: misleading but this is handled. A
5504 PEReference may have been detected in the current input
5505 stream the handling is done accordingly to
5506 http://www.w3.org/TR/REC-xml#entproc i.e. - Included in
5507 literal in entity values - Included as Parameter Entity
5508 reference within DTDs """
5509 libxml2mod.xmlParserHandlePEReference(self._o)
5511 def parserHandleReference(self):
5512 """TODO: Remove, now deprecated ... the test is done directly
5513 in the content parsing routines. [67] Reference ::=
5514 EntityRef | CharRef [68] EntityRef ::= '&' Name ';' [
5515 WFC: Entity Declared ] the Name given in the entity
5516 reference must match that in an entity declaration, except
5517 that well-formed documents need not declare any of the
5518 following entities: amp, lt, gt, apos, quot. [ WFC: Parsed
5519 Entity ] An entity reference must not contain the name of
5520 an unparsed entity [66] CharRef ::= '&#' [0-9]+ ';' |
5521 '&#x' [0-9a-fA-F]+ ';' A PEReference may have been
5522 detected in the current input stream the handling is done
5523 accordingly to http://www.w3.org/TR/REC-xml#entproc """
5524 libxml2mod.xmlParserHandleReference(self._o)
5527 """xmlPopInput: the current input pointed by ctxt->input came
5528 to an end pop it and return the next char. """
5529 ret = libxml2mod.xmlPopInput(self._o)
5533 """Trickery: parse an XML name but without consuming the input
5534 flow Needed for rollback cases. Used only when parsing
5535 entities references. TODO: seems deprecated now, only used
5536 in the default part of xmlParserHandleReference [4]
5537 NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
5538 CombiningChar | Extender [5] Name ::= (Letter | '_' | ':')
5539 (NameChar)* [6] Names ::= Name (S Name)* """
5540 ret = libxml2mod.xmlScanName(self._o)
5543 def skipBlankChars(self):
5544 """skip all blanks character found at that point in the input
5545 streams. It pops up finished entities in the process if
5546 allowable at that point. """
5547 ret = libxml2mod.xmlSkipBlankChars(self._o)
5550 def stringDecodeEntities(self, str, what, end, end2, end3):
5551 """Takes a entity string content and process to do the
5552 adequate substitutions. [67] Reference ::= EntityRef |
5553 CharRef [69] PEReference ::= '%' Name ';' """
5554 ret = libxml2mod.xmlStringDecodeEntities(self._o, str, what, end, end2, end3)
5557 def stringLenDecodeEntities(self, str, len, what, end, end2, end3):
5558 """Takes a entity string content and process to do the
5559 adequate substitutions. [67] Reference ::= EntityRef |
5560 CharRef [69] PEReference ::= '%' Name ';' """
5561 ret = libxml2mod.xmlStringLenDecodeEntities(self._o, str, len, what, end, end2, end3)
5564 class xmlAttr(xmlNode):
5565 def __init__(self, _obj=None):
5566 if checkWrapper(_obj) != 0: raise TypeError('xmlAttr got a wrong wrapper object type')
5568 xmlNode.__init__(self, _obj=_obj)
5571 return "<xmlAttr (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
5574 # xmlAttr functions from module debugXML
5577 def debugDumpAttr(self, output, depth):
5578 """Dumps debug information for the attribute """
5579 libxml2mod.xmlDebugDumpAttr(output, self._o, depth)
5581 def debugDumpAttrList(self, output, depth):
5582 """Dumps debug information for the attribute list """
5583 libxml2mod.xmlDebugDumpAttrList(output, self._o, depth)
5586 # xmlAttr functions from module tree
5589 def copyProp(self, target):
5590 """Do a copy of the attribute. """
5591 if target is None: target__o = None
5592 else: target__o = target._o
5593 ret = libxml2mod.xmlCopyProp(target__o, self._o)
5594 if ret is None:raise treeError('xmlCopyProp() failed')
5595 __tmp = xmlAttr(_obj=ret)
5598 def copyPropList(self, target):
5599 """Do a copy of an attribute list. """
5600 if target is None: target__o = None
5601 else: target__o = target._o
5602 ret = libxml2mod.xmlCopyPropList(target__o, self._o)
5603 if ret is None:raise treeError('xmlCopyPropList() failed')
5604 __tmp = xmlAttr(_obj=ret)
5608 """Free one attribute, all the content is freed too """
5609 libxml2mod.xmlFreeProp(self._o)
5611 def freePropList(self):
5612 """Free a property and all its siblings, all the children are
5614 libxml2mod.xmlFreePropList(self._o)
5616 def removeProp(self):
5617 """Unlink and free one attribute, all the content is freed too
5618 Note this doesn't work for namespace definition attributes """
5619 ret = libxml2mod.xmlRemoveProp(self._o)
5623 # xmlAttr functions from module valid
5626 def removeID(self, doc):
5627 """Remove the given attribute from the ID table maintained
5629 if doc is None: doc__o = None
5630 else: doc__o = doc._o
5631 ret = libxml2mod.xmlRemoveID(doc__o, self._o)
5634 def removeRef(self, doc):
5635 """Remove the given attribute from the Ref table maintained
5637 if doc is None: doc__o = None
5638 else: doc__o = doc._o
5639 ret = libxml2mod.xmlRemoveRef(doc__o, self._o)
5642 class xmlAttribute(xmlNode):
5643 def __init__(self, _obj=None):
5644 if checkWrapper(_obj) != 0: raise TypeError('xmlAttribute got a wrong wrapper object type')
5646 xmlNode.__init__(self, _obj=_obj)
5649 return "<xmlAttribute (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
5652 def __init__(self, _obj=None):
5653 if _obj != None:self._o = _obj;return
5658 libxml2mod.xmlFreeCatalog(self._o)
5662 # catalog functions from module catalog
5665 def add(self, type, orig, replace):
5666 """Add an entry in the catalog, it may overwrite existing but
5667 different entries. """
5668 ret = libxml2mod.xmlACatalogAdd(self._o, type, orig, replace)
5671 def catalogIsEmpty(self):
5672 """Check is a catalog is empty """
5673 ret = libxml2mod.xmlCatalogIsEmpty(self._o)
5676 def convertSGMLCatalog(self):
5677 """Convert all the SGML catalog entries as XML ones """
5678 ret = libxml2mod.xmlConvertSGMLCatalog(self._o)
5681 def dump(self, out):
5682 """Dump the given catalog to the given file. """
5683 libxml2mod.xmlACatalogDump(self._o, out)
5685 def remove(self, value):
5686 """Remove an entry from the catalog """
5687 ret = libxml2mod.xmlACatalogRemove(self._o, value)
5690 def resolve(self, pubID, sysID):
5691 """Do a complete resolution lookup of an External Identifier """
5692 ret = libxml2mod.xmlACatalogResolve(self._o, pubID, sysID)
5695 def resolvePublic(self, pubID):
5696 """Try to lookup the catalog local reference associated to a
5697 public ID in that catalog """
5698 ret = libxml2mod.xmlACatalogResolvePublic(self._o, pubID)
5701 def resolveSystem(self, sysID):
5702 """Try to lookup the catalog resource for a system ID """
5703 ret = libxml2mod.xmlACatalogResolveSystem(self._o, sysID)
5706 def resolveURI(self, URI):
5707 """Do a complete resolution lookup of an URI """
5708 ret = libxml2mod.xmlACatalogResolveURI(self._o, URI)
5711 class xmlDtd(xmlNode):
5712 def __init__(self, _obj=None):
5713 if checkWrapper(_obj) != 0: raise TypeError('xmlDtd got a wrong wrapper object type')
5715 xmlNode.__init__(self, _obj=_obj)
5718 return "<xmlDtd (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
5721 # xmlDtd functions from module debugXML
5724 def debugDumpDTD(self, output):
5725 """Dumps debug information for the DTD """
5726 libxml2mod.xmlDebugDumpDTD(output, self._o)
5729 # xmlDtd functions from module tree
5733 """Do a copy of the dtd. """
5734 ret = libxml2mod.xmlCopyDtd(self._o)
5735 if ret is None:raise treeError('xmlCopyDtd() failed')
5736 __tmp = xmlDtd(_obj=ret)
5740 """Free a DTD structure. """
5741 libxml2mod.xmlFreeDtd(self._o)
5744 # xmlDtd functions from module valid
5747 def dtdAttrDesc(self, elem, name):
5748 """Search the DTD for the description of this attribute on
5750 ret = libxml2mod.xmlGetDtdAttrDesc(self._o, elem, name)
5751 if ret is None:raise treeError('xmlGetDtdAttrDesc() failed')
5752 __tmp = xmlAttribute(_obj=ret)
5755 def dtdElementDesc(self, name):
5756 """Search the DTD for the description of this element """
5757 ret = libxml2mod.xmlGetDtdElementDesc(self._o, name)
5758 if ret is None:raise treeError('xmlGetDtdElementDesc() failed')
5759 __tmp = xmlElement(_obj=ret)
5762 def dtdQAttrDesc(self, elem, name, prefix):
5763 """Search the DTD for the description of this qualified
5764 attribute on this element. """
5765 ret = libxml2mod.xmlGetDtdQAttrDesc(self._o, elem, name, prefix)
5766 if ret is None:raise treeError('xmlGetDtdQAttrDesc() failed')
5767 __tmp = xmlAttribute(_obj=ret)
5770 def dtdQElementDesc(self, name, prefix):
5771 """Search the DTD for the description of this element """
5772 ret = libxml2mod.xmlGetDtdQElementDesc(self._o, name, prefix)
5773 if ret is None:raise treeError('xmlGetDtdQElementDesc() failed')
5774 __tmp = xmlElement(_obj=ret)
5777 class xmlElement(xmlNode):
5778 def __init__(self, _obj=None):
5779 if checkWrapper(_obj) != 0: raise TypeError('xmlElement got a wrong wrapper object type')
5781 xmlNode.__init__(self, _obj=_obj)
5784 return "<xmlElement (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
5786 class xmlEntity(xmlNode):
5787 def __init__(self, _obj=None):
5788 if checkWrapper(_obj) != 0: raise TypeError('xmlEntity got a wrong wrapper object type')
5790 xmlNode.__init__(self, _obj=_obj)
5793 return "<xmlEntity (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
5796 # xmlEntity functions from module parserInternals
5799 def handleEntity(self, ctxt):
5800 """Default handling of defined entities, when should we define
5801 a new input stream ? When do we just handle that as a set
5802 of chars ? OBSOLETE: to be removed at some point. """
5803 if ctxt is None: ctxt__o = None
5804 else: ctxt__o = ctxt._o
5805 libxml2mod.xmlHandleEntity(ctxt__o, self._o)
5808 def __init__(self, _obj=None):
5809 if _obj != None:self._o = _obj;return
5812 # accessors for Error
5814 """The error code, e.g. an xmlParserError """
5815 ret = libxml2mod.xmlErrorGetCode(self._o)
5819 """What part of the library raised this error """
5820 ret = libxml2mod.xmlErrorGetDomain(self._o)
5825 ret = libxml2mod.xmlErrorGetFile(self._o)
5829 """how consequent is the error """
5830 ret = libxml2mod.xmlErrorGetLevel(self._o)
5834 """the line number if available """
5835 ret = libxml2mod.xmlErrorGetLine(self._o)
5839 """human-readable informative error message """
5840 ret = libxml2mod.xmlErrorGetMessage(self._o)
5844 # Error functions from module xmlerror
5847 def copyError(self, to):
5848 """Save the original error to the new place. """
5849 if to is None: to__o = None
5851 ret = libxml2mod.xmlCopyError(self._o, to__o)
5854 def resetError(self):
5855 """Cleanup the error. """
5856 libxml2mod.xmlResetError(self._o)
5858 class xmlNs(xmlNode):
5859 def __init__(self, _obj=None):
5860 if checkWrapper(_obj) != 0: raise TypeError('xmlNs got a wrong wrapper object type')
5862 xmlNode.__init__(self, _obj=_obj)
5865 return "<xmlNs (%s) object at 0x%x>" % (self.name, int(pos_id (self)))
5868 # xmlNs functions from module tree
5871 def copyNamespace(self):
5872 """Do a copy of the namespace. """
5873 ret = libxml2mod.xmlCopyNamespace(self._o)
5874 if ret is None:raise treeError('xmlCopyNamespace() failed')
5875 __tmp = xmlNs(_obj=ret)
5878 def copyNamespaceList(self):
5879 """Do a copy of an namespace list. """
5880 ret = libxml2mod.xmlCopyNamespaceList(self._o)
5881 if ret is None:raise treeError('xmlCopyNamespaceList() failed')
5882 __tmp = xmlNs(_obj=ret)
5886 """Free up the structures associated to a namespace """
5887 libxml2mod.xmlFreeNs(self._o)
5889 def freeNsList(self):
5890 """Free up all the structures associated to the chained
5892 libxml2mod.xmlFreeNsList(self._o)
5894 def newChild(self, parent, name, content):
5895 """Creation of a new child element, added at the end of
5896 @parent children list. @ns and @content parameters are
5897 optional (None). If @ns is None, the newly created element
5898 inherits the namespace of @parent. If @content is non None,
5899 a child list containing the TEXTs and ENTITY_REFs node will
5900 be created. NOTE: @content is supposed to be a piece of XML
5901 CDATA, so it allows entity references. XML special chars
5902 must be escaped first by using
5903 xmlEncodeEntitiesReentrant(), or xmlNewTextChild() should
5905 if parent is None: parent__o = None
5906 else: parent__o = parent._o
5907 ret = libxml2mod.xmlNewChild(parent__o, self._o, name, content)
5908 if ret is None:raise treeError('xmlNewChild() failed')
5909 __tmp = xmlNode(_obj=ret)
5912 def newDocNode(self, doc, name, content):
5913 """Creation of a new node element within a document. @ns and
5914 @content are optional (None). NOTE: @content is supposed to
5915 be a piece of XML CDATA, so it allow entities references,
5916 but XML special chars need to be escaped first by using
5917 xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you
5918 don't need entities support. """
5919 if doc is None: doc__o = None
5920 else: doc__o = doc._o
5921 ret = libxml2mod.xmlNewDocNode(doc__o, self._o, name, content)
5922 if ret is None:raise treeError('xmlNewDocNode() failed')
5923 __tmp = xmlNode(_obj=ret)
5926 def newDocNodeEatName(self, doc, name, content):
5927 """Creation of a new node element within a document. @ns and
5928 @content are optional (None). NOTE: @content is supposed to
5929 be a piece of XML CDATA, so it allow entities references,
5930 but XML special chars need to be escaped first by using
5931 xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you
5932 don't need entities support. """
5933 if doc is None: doc__o = None
5934 else: doc__o = doc._o
5935 ret = libxml2mod.xmlNewDocNodeEatName(doc__o, self._o, name, content)
5936 if ret is None:raise treeError('xmlNewDocNodeEatName() failed')
5937 __tmp = xmlNode(_obj=ret)
5940 def newDocRawNode(self, doc, name, content):
5941 """Creation of a new node element within a document. @ns and
5942 @content are optional (None). """
5943 if doc is None: doc__o = None
5944 else: doc__o = doc._o
5945 ret = libxml2mod.xmlNewDocRawNode(doc__o, self._o, name, content)
5946 if ret is None:raise treeError('xmlNewDocRawNode() failed')
5947 __tmp = xmlNode(_obj=ret)
5950 def newNodeEatName(self, name):
5951 """Creation of a new node element. @ns is optional (None). """
5952 ret = libxml2mod.xmlNewNodeEatName(self._o, name)
5953 if ret is None:raise treeError('xmlNewNodeEatName() failed')
5954 __tmp = xmlNode(_obj=ret)
5957 def newNsProp(self, node, name, value):
5958 """Create a new property tagged with a namespace and carried
5960 if node is None: node__o = None
5961 else: node__o = node._o
5962 ret = libxml2mod.xmlNewNsProp(node__o, self._o, name, value)
5963 if ret is None:raise treeError('xmlNewNsProp() failed')
5964 __tmp = xmlAttr(_obj=ret)
5967 def newNsPropEatName(self, node, name, value):
5968 """Create a new property tagged with a namespace and carried
5970 if node is None: node__o = None
5971 else: node__o = node._o
5972 ret = libxml2mod.xmlNewNsPropEatName(node__o, self._o, name, value)
5973 if ret is None:raise treeError('xmlNewNsPropEatName() failed')
5974 __tmp = xmlAttr(_obj=ret)
5977 def newTextChild(self, parent, name, content):
5978 """Creation of a new child element, added at the end of
5979 @parent children list. @ns and @content parameters are
5980 optional (None). If @ns is None, the newly created element
5981 inherits the namespace of @parent. If @content is non None,
5982 a child TEXT node will be created containing the string
5983 @content. NOTE: Use xmlNewChild() if @content will contain
5984 entities that need to be preserved. Use this function,
5985 xmlNewTextChild(), if you need to ensure that reserved XML
5986 chars that might appear in @content, such as the ampersand,
5987 greater-than or less-than signs, are automatically replaced
5988 by their XML escaped entity representations. """
5989 if parent is None: parent__o = None
5990 else: parent__o = parent._o
5991 ret = libxml2mod.xmlNewTextChild(parent__o, self._o, name, content)
5992 if ret is None:raise treeError('xmlNewTextChild() failed')
5993 __tmp = xmlNode(_obj=ret)
5996 def setNs(self, node):
5997 """Associate a namespace to a node, a posteriori. """
5998 if node is None: node__o = None
5999 else: node__o = node._o
6000 libxml2mod.xmlSetNs(node__o, self._o)
6002 def setNsProp(self, node, name, value):
6003 """Set (or reset) an attribute carried by a node. The ns
6004 structure must be in scope, this is not checked """
6005 if node is None: node__o = None
6006 else: node__o = node._o
6007 ret = libxml2mod.xmlSetNsProp(node__o, self._o, name, value)
6008 if ret is None:raise treeError('xmlSetNsProp() failed')
6009 __tmp = xmlAttr(_obj=ret)
6012 def unsetNsProp(self, node, name):
6013 """Remove an attribute carried by a node. """
6014 if node is None: node__o = None
6015 else: node__o = node._o
6016 ret = libxml2mod.xmlUnsetNsProp(node__o, self._o, name)
6020 # xmlNs functions from module xpathInternals
6023 def xpathNodeSetFreeNs(self):
6024 """Namespace nodes in libxml don't match the XPath semantic.
6025 In a node set the namespace nodes are duplicated and the
6026 next pointer is set to the parent node in the XPath
6027 semantic. Check if such a node needs to be freed """
6028 libxml2mod.xmlXPathNodeSetFreeNs(self._o)
6030 class outputBuffer(ioWriteWrapper):
6031 def __init__(self, _obj=None):
6033 ioWriteWrapper.__init__(self, _obj=_obj)
6036 # outputBuffer functions from module HTMLtree
6039 def htmlDocContentDumpFormatOutput(self, cur, encoding, format):
6040 """Dump an HTML document. """
6041 if cur is None: cur__o = None
6042 else: cur__o = cur._o
6043 libxml2mod.htmlDocContentDumpFormatOutput(self._o, cur__o, encoding, format)
6045 def htmlDocContentDumpOutput(self, cur, encoding):
6046 """Dump an HTML document. Formating return/spaces are added. """
6047 if cur is None: cur__o = None
6048 else: cur__o = cur._o
6049 libxml2mod.htmlDocContentDumpOutput(self._o, cur__o, encoding)
6051 def htmlNodeDumpFormatOutput(self, doc, cur, encoding, format):
6052 """Dump an HTML node, recursive behaviour,children are printed
6054 if doc is None: doc__o = None
6055 else: doc__o = doc._o
6056 if cur is None: cur__o = None
6057 else: cur__o = cur._o
6058 libxml2mod.htmlNodeDumpFormatOutput(self._o, doc__o, cur__o, encoding, format)
6060 def htmlNodeDumpOutput(self, doc, cur, encoding):
6061 """Dump an HTML node, recursive behaviour,children are printed
6062 too, and formatting returns/spaces are added. """
6063 if doc is None: doc__o = None
6064 else: doc__o = doc._o
6065 if cur is None: cur__o = None
6066 else: cur__o = cur._o
6067 libxml2mod.htmlNodeDumpOutput(self._o, doc__o, cur__o, encoding)
6070 # outputBuffer functions from module tree
6073 def nodeDumpOutput(self, doc, cur, level, format, encoding):
6074 """Dump an XML node, recursive behaviour, children are printed
6075 too. Note that @format = 1 provide node indenting only if
6076 xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was
6078 if doc is None: doc__o = None
6079 else: doc__o = doc._o
6080 if cur is None: cur__o = None
6081 else: cur__o = cur._o
6082 libxml2mod.xmlNodeDumpOutput(self._o, doc__o, cur__o, level, format, encoding)
6084 def saveFileTo(self, cur, encoding):
6085 """Dump an XML document to an I/O buffer. Warning ! This call
6086 xmlOutputBufferClose() on buf which is not available after
6088 if cur is None: cur__o = None
6089 else: cur__o = cur._o
6090 ret = libxml2mod.xmlSaveFileTo(self._o, cur__o, encoding)
6093 def saveFormatFileTo(self, cur, encoding, format):
6094 """Dump an XML document to an I/O buffer. Warning ! This call
6095 xmlOutputBufferClose() on buf which is not available after
6097 if cur is None: cur__o = None
6098 else: cur__o = cur._o
6099 ret = libxml2mod.xmlSaveFormatFileTo(self._o, cur__o, encoding, format)
6103 # outputBuffer functions from module xmlIO
6106 def getContent(self):
6107 """Gives a pointer to the data currently held in the output
6109 ret = libxml2mod.xmlOutputBufferGetContent(self._o)
6112 def write(self, len, buf):
6113 """Write the content of the array in the output I/O buffer
6114 This routine handle the I18N transcoding from internal
6115 UTF-8 The buffer is lossless, i.e. will store in case of
6116 partial or delayed writes. """
6117 ret = libxml2mod.xmlOutputBufferWrite(self._o, len, buf)
6120 def writeString(self, str):
6121 """Write the content of the string in the output I/O buffer
6122 This routine handle the I18N transcoding from internal
6123 UTF-8 The buffer is lossless, i.e. will store in case of
6124 partial or delayed writes. """
6125 ret = libxml2mod.xmlOutputBufferWriteString(self._o, str)
6128 class inputBuffer(ioReadWrapper):
6129 def __init__(self, _obj=None):
6131 ioReadWrapper.__init__(self, _obj=_obj)
6135 libxml2mod.xmlFreeParserInputBuffer(self._o)
6139 # inputBuffer functions from module xmlIO
6142 def grow(self, len):
6143 """Grow up the content of the input buffer, the old data are
6144 preserved This routine handle the I18N transcoding to
6145 internal UTF-8 This routine is used when operating the
6146 parser in normal (pull) mode TODO: one should be able to
6147 remove one extra copy by copying directly onto in->buffer
6149 ret = libxml2mod.xmlParserInputBufferGrow(self._o, len)
6152 def push(self, len, buf):
6153 """Push the content of the arry in the input buffer This
6154 routine handle the I18N transcoding to internal UTF-8 This
6155 is used when operating the parser in progressive (push)
6157 ret = libxml2mod.xmlParserInputBufferPush(self._o, len, buf)
6160 def read(self, len):
6161 """Refresh the content of the input buffer, the old data are
6162 considered consumed This routine handle the I18N
6163 transcoding to internal UTF-8 """
6164 ret = libxml2mod.xmlParserInputBufferRead(self._o, len)
6168 # inputBuffer functions from module xmlreader
6171 def Setup(self, reader, URL, encoding, options):
6172 """Setup an XML reader with new options """
6173 if reader is None: reader__o = None
6174 else: reader__o = reader._o
6175 ret = libxml2mod.xmlTextReaderSetup(reader__o, self._o, URL, encoding, options)
6178 def newTextReader(self, URI):
6179 """Create an xmlTextReader structure fed with @input """
6180 ret = libxml2mod.xmlNewTextReader(self._o, URI)
6181 if ret is None:raise treeError('xmlNewTextReader() failed')
6182 __tmp = xmlTextReader(_obj=ret)
6187 def __init__(self, _obj=None):
6188 if _obj != None:self._o = _obj;return
6193 libxml2mod.xmlRegFreeRegexp(self._o)
6197 # xmlReg functions from module xmlregexp
6200 def regexpExec(self, content):
6201 """Check if the regular expression generates the value """
6202 ret = libxml2mod.xmlRegexpExec(self._o, content)
6205 def regexpIsDeterminist(self):
6206 """Check if the regular expression is determinist """
6207 ret = libxml2mod.xmlRegexpIsDeterminist(self._o)
6210 def regexpPrint(self, output):
6211 """Print the content of the compiled regular expression """
6212 libxml2mod.xmlRegexpPrint(output, self._o)
6214 class relaxNgParserCtxt:
6215 def __init__(self, _obj=None):
6216 if _obj != None:self._o = _obj;return
6221 libxml2mod.xmlRelaxNGFreeParserCtxt(self._o)
6225 # relaxNgParserCtxt functions from module relaxng
6228 def relaxNGParse(self):
6229 """parse a schema definition resource and build an internal
6230 XML Shema struture which can be used to validate instances. """
6231 ret = libxml2mod.xmlRelaxNGParse(self._o)
6232 if ret is None:raise parserError('xmlRelaxNGParse() failed')
6233 __tmp = relaxNgSchema(_obj=ret)
6236 def relaxParserSetFlag(self, flags):
6237 """Semi private function used to pass informations to a parser
6238 context which are a combination of xmlRelaxNGParserFlag . """
6239 ret = libxml2mod.xmlRelaxParserSetFlag(self._o, flags)
6242 class relaxNgSchema:
6243 def __init__(self, _obj=None):
6244 if _obj != None:self._o = _obj;return
6249 libxml2mod.xmlRelaxNGFree(self._o)
6253 # relaxNgSchema functions from module relaxng
6256 def relaxNGDump(self, output):
6257 """Dump a RelaxNG structure back """
6258 libxml2mod.xmlRelaxNGDump(output, self._o)
6260 def relaxNGDumpTree(self, output):
6261 """Dump the transformed RelaxNG tree. """
6262 libxml2mod.xmlRelaxNGDumpTree(output, self._o)
6264 def relaxNGNewValidCtxt(self):
6265 """Create an XML RelaxNGs validation context based on the
6267 ret = libxml2mod.xmlRelaxNGNewValidCtxt(self._o)
6268 if ret is None:raise treeError('xmlRelaxNGNewValidCtxt() failed')
6269 __tmp = relaxNgValidCtxt(_obj=ret)
6274 # relaxNgSchema functions from module xmlreader
6277 def RelaxNGSetSchema(self, reader):
6278 """Use RelaxNG to validate the document as it is processed.
6279 Activation is only possible before the first Read(). if
6280 @schema is None, then RelaxNG validation is desactivated. @
6281 The @schema should not be freed until the reader is
6282 deallocated or its use has been deactivated. """
6283 if reader is None: reader__o = None
6284 else: reader__o = reader._o
6285 ret = libxml2mod.xmlTextReaderRelaxNGSetSchema(reader__o, self._o)
6288 class relaxNgValidCtxt(relaxNgValidCtxtCore):
6289 def __init__(self, _obj=None):
6292 relaxNgValidCtxtCore.__init__(self, _obj=_obj)
6296 libxml2mod.xmlRelaxNGFreeValidCtxt(self._o)
6300 # relaxNgValidCtxt functions from module relaxng
6303 def relaxNGValidateDoc(self, doc):
6304 """Validate a document tree in memory. """
6305 if doc is None: doc__o = None
6306 else: doc__o = doc._o
6307 ret = libxml2mod.xmlRelaxNGValidateDoc(self._o, doc__o)
6310 def relaxNGValidateFullElement(self, doc, elem):
6311 """Validate a full subtree when
6312 xmlRelaxNGValidatePushElement() returned 0 and the content
6313 of the node has been expanded. """
6314 if doc is None: doc__o = None
6315 else: doc__o = doc._o
6316 if elem is None: elem__o = None
6317 else: elem__o = elem._o
6318 ret = libxml2mod.xmlRelaxNGValidateFullElement(self._o, doc__o, elem__o)
6321 def relaxNGValidatePopElement(self, doc, elem):
6322 """Pop the element end from the RelaxNG validation stack. """
6323 if doc is None: doc__o = None
6324 else: doc__o = doc._o
6325 if elem is None: elem__o = None
6326 else: elem__o = elem._o
6327 ret = libxml2mod.xmlRelaxNGValidatePopElement(self._o, doc__o, elem__o)
6330 def relaxNGValidatePushCData(self, data, len):
6331 """check the CData parsed for validation in the current stack """
6332 ret = libxml2mod.xmlRelaxNGValidatePushCData(self._o, data, len)
6335 def relaxNGValidatePushElement(self, doc, elem):
6336 """Push a new element start on the RelaxNG validation stack. """
6337 if doc is None: doc__o = None
6338 else: doc__o = doc._o
6339 if elem is None: elem__o = None
6340 else: elem__o = elem._o
6341 ret = libxml2mod.xmlRelaxNGValidatePushElement(self._o, doc__o, elem__o)
6345 # relaxNgValidCtxt functions from module xmlreader
6348 def RelaxNGValidateCtxt(self, reader, options):
6349 """Use RelaxNG schema context to validate the document as it
6350 is processed. Activation is only possible before the first
6351 Read(). If @ctxt is None, then RelaxNG schema validation is
6353 if reader is None: reader__o = None
6354 else: reader__o = reader._o
6355 ret = libxml2mod.xmlTextReaderRelaxNGValidateCtxt(reader__o, self._o, options)
6358 class SchemaParserCtxt:
6359 def __init__(self, _obj=None):
6360 if _obj != None:self._o = _obj;return
6365 libxml2mod.xmlSchemaFreeParserCtxt(self._o)
6369 # SchemaParserCtxt functions from module xmlschemas
6372 def schemaParse(self):
6373 """parse a schema definition resource and build an internal
6374 XML Shema struture which can be used to validate instances. """
6375 ret = libxml2mod.xmlSchemaParse(self._o)
6376 if ret is None:raise parserError('xmlSchemaParse() failed')
6377 __tmp = Schema(_obj=ret)
6381 def __init__(self, _obj=None):
6382 if _obj != None:self._o = _obj;return
6387 libxml2mod.xmlSchemaFree(self._o)
6391 # Schema functions from module xmlreader
6394 def SetSchema(self, reader):
6395 """Use XSD Schema to validate the document as it is processed.
6396 Activation is only possible before the first Read(). if
6397 @schema is None, then Schema validation is desactivated. @
6398 The @schema should not be freed until the reader is
6399 deallocated or its use has been deactivated. """
6400 if reader is None: reader__o = None
6401 else: reader__o = reader._o
6402 ret = libxml2mod.xmlTextReaderSetSchema(reader__o, self._o)
6406 # Schema functions from module xmlschemas
6409 def schemaDump(self, output):
6410 """Dump a Schema structure. """
6411 libxml2mod.xmlSchemaDump(output, self._o)
6413 def schemaNewValidCtxt(self):
6414 """Create an XML Schemas validation context based on the given
6416 ret = libxml2mod.xmlSchemaNewValidCtxt(self._o)
6417 if ret is None:raise treeError('xmlSchemaNewValidCtxt() failed')
6418 __tmp = SchemaValidCtxt(_obj=ret)
6422 class SchemaValidCtxt(SchemaValidCtxtCore):
6423 def __init__(self, _obj=None):
6426 SchemaValidCtxtCore.__init__(self, _obj=_obj)
6430 libxml2mod.xmlSchemaFreeValidCtxt(self._o)
6434 # SchemaValidCtxt functions from module xmlreader
6437 def SchemaValidateCtxt(self, reader, options):
6438 """Use W3C XSD schema context to validate the document as it
6439 is processed. Activation is only possible before the first
6440 Read(). If @ctxt is None, then XML Schema validation is
6442 if reader is None: reader__o = None
6443 else: reader__o = reader._o
6444 ret = libxml2mod.xmlTextReaderSchemaValidateCtxt(reader__o, self._o, options)
6448 # SchemaValidCtxt functions from module xmlschemas
6451 def schemaIsValid(self):
6452 """Check if any error was detected during validation. """
6453 ret = libxml2mod.xmlSchemaIsValid(self._o)
6456 def schemaSetValidOptions(self, options):
6457 """Sets the options to be used during the validation. """
6458 ret = libxml2mod.xmlSchemaSetValidOptions(self._o, options)
6461 def schemaValidCtxtGetOptions(self):
6462 """Get the validation context options. """
6463 ret = libxml2mod.xmlSchemaValidCtxtGetOptions(self._o)
6466 def schemaValidCtxtGetParserCtxt(self):
6467 """allow access to the parser context of the schema validation
6469 ret = libxml2mod.xmlSchemaValidCtxtGetParserCtxt(self._o)
6470 if ret is None:raise parserError('xmlSchemaValidCtxtGetParserCtxt() failed')
6471 __tmp = parserCtxt(_obj=ret)
6474 def schemaValidateDoc(self, doc):
6475 """Validate a document tree in memory. """
6476 if doc is None: doc__o = None
6477 else: doc__o = doc._o
6478 ret = libxml2mod.xmlSchemaValidateDoc(self._o, doc__o)
6481 def schemaValidateFile(self, filename, options):
6482 """Do a schemas validation of the given resource, it will use
6483 the SAX streamable validation internally. """
6484 ret = libxml2mod.xmlSchemaValidateFile(self._o, filename, options)
6487 def schemaValidateOneElement(self, elem):
6488 """Validate a branch of a tree, starting with the given @elem. """
6489 if elem is None: elem__o = None
6490 else: elem__o = elem._o
6491 ret = libxml2mod.xmlSchemaValidateOneElement(self._o, elem__o)
6494 def schemaValidateSetFilename(self, filename):
6495 """Workaround to provide file error reporting information when
6496 this is not provided by current APIs """
6497 libxml2mod.xmlSchemaValidateSetFilename(self._o, filename)
6499 class xmlTextReaderLocator:
6500 def __init__(self, _obj=None):
6501 if _obj != None:self._o = _obj;return
6505 # xmlTextReaderLocator functions from module xmlreader
6509 """Obtain the base URI for the given locator. """
6510 ret = libxml2mod.xmlTextReaderLocatorBaseURI(self._o)
6513 def LineNumber(self):
6514 """Obtain the line number for the given locator. """
6515 ret = libxml2mod.xmlTextReaderLocatorLineNumber(self._o)
6518 class xmlTextReader(xmlTextReaderCore):
6519 def __init__(self, _obj=None):
6522 xmlTextReaderCore.__init__(self, _obj=_obj)
6526 libxml2mod.xmlFreeTextReader(self._o)
6530 # xmlTextReader functions from module xmlreader
6533 def AttributeCount(self):
6534 """Provides the number of attributes of the current node """
6535 ret = libxml2mod.xmlTextReaderAttributeCount(self._o)
6539 """The base URI of the node. """
6540 ret = libxml2mod.xmlTextReaderConstBaseUri(self._o)
6543 def ByteConsumed(self):
6544 """This function provides the current index of the parser used
6545 by the reader, relative to the start of the current entity.
6546 This function actually just wraps a call to
6547 xmlBytesConsumed() for the parser context associated with
6548 the reader. See xmlBytesConsumed() for more information. """
6549 ret = libxml2mod.xmlTextReaderByteConsumed(self._o)
6553 """This method releases any resources allocated by the current
6554 instance changes the state to Closed and close any
6555 underlying input. """
6556 ret = libxml2mod.xmlTextReaderClose(self._o)
6559 def CurrentDoc(self):
6560 """Hacking interface allowing to get the xmlDocPtr
6561 correponding to the current document being accessed by the
6562 xmlTextReader. NOTE: as a result of this call, the reader
6563 will not destroy the associated XML document and calling
6564 xmlFreeDoc() on the result is needed once the reader
6565 parsing has finished. """
6566 ret = libxml2mod.xmlTextReaderCurrentDoc(self._o)
6567 if ret is None:raise treeError('xmlTextReaderCurrentDoc() failed')
6568 __tmp = xmlDoc(_obj=ret)
6571 def CurrentNode(self):
6572 """Hacking interface allowing to get the xmlNodePtr
6573 correponding to the current node being accessed by the
6574 xmlTextReader. This is dangerous because the underlying
6575 node may be destroyed on the next Reads. """
6576 ret = libxml2mod.xmlTextReaderCurrentNode(self._o)
6577 if ret is None:raise treeError('xmlTextReaderCurrentNode() failed')
6578 __tmp = xmlNode(_obj=ret)
6582 """The depth of the node in the tree. """
6583 ret = libxml2mod.xmlTextReaderDepth(self._o)
6587 """Determine the encoding of the document being read. """
6588 ret = libxml2mod.xmlTextReaderConstEncoding(self._o)
6592 """Reads the contents of the current node and the full
6593 subtree. It then makes the subtree available until the next
6594 xmlTextReaderRead() call """
6595 ret = libxml2mod.xmlTextReaderExpand(self._o)
6596 if ret is None:raise treeError('xmlTextReaderExpand() failed')
6597 __tmp = xmlNode(_obj=ret)
6600 def GetAttribute(self, name):
6601 """Provides the value of the attribute with the specified
6603 ret = libxml2mod.xmlTextReaderGetAttribute(self._o, name)
6606 def GetAttributeNo(self, no):
6607 """Provides the value of the attribute with the specified
6608 index relative to the containing element. """
6609 ret = libxml2mod.xmlTextReaderGetAttributeNo(self._o, no)
6612 def GetAttributeNs(self, localName, namespaceURI):
6613 """Provides the value of the specified attribute """
6614 ret = libxml2mod.xmlTextReaderGetAttributeNs(self._o, localName, namespaceURI)
6617 def GetParserColumnNumber(self):
6618 """Provide the column number of the current parsing point. """
6619 ret = libxml2mod.xmlTextReaderGetParserColumnNumber(self._o)
6622 def GetParserLineNumber(self):
6623 """Provide the line number of the current parsing point. """
6624 ret = libxml2mod.xmlTextReaderGetParserLineNumber(self._o)
6627 def GetParserProp(self, prop):
6628 """Read the parser internal property. """
6629 ret = libxml2mod.xmlTextReaderGetParserProp(self._o, prop)
6632 def GetRemainder(self):
6633 """Method to get the remainder of the buffered XML. this
6634 method stops the parser, set its state to End Of File and
6635 return the input stream with what is left that the parser
6636 did not use. The implementation is not good, the parser
6637 certainly procgressed past what's left in reader->input,
6638 and there is an allocation problem. Best would be to
6639 rewrite it differently. """
6640 ret = libxml2mod.xmlTextReaderGetRemainder(self._o)
6641 if ret is None:raise treeError('xmlTextReaderGetRemainder() failed')
6642 __tmp = inputBuffer(_obj=ret)
6645 def HasAttributes(self):
6646 """Whether the node has attributes. """
6647 ret = libxml2mod.xmlTextReaderHasAttributes(self._o)
6651 """Whether the node can have a text value. """
6652 ret = libxml2mod.xmlTextReaderHasValue(self._o)
6655 def IsDefault(self):
6656 """Whether an Attribute node was generated from the default
6657 value defined in the DTD or schema. """
6658 ret = libxml2mod.xmlTextReaderIsDefault(self._o)
6661 def IsEmptyElement(self):
6662 """Check if the current node is empty """
6663 ret = libxml2mod.xmlTextReaderIsEmptyElement(self._o)
6666 def IsNamespaceDecl(self):
6667 """Determine whether the current node is a namespace
6668 declaration rather than a regular attribute. """
6669 ret = libxml2mod.xmlTextReaderIsNamespaceDecl(self._o)
6673 """Retrieve the validity status from the parser context """
6674 ret = libxml2mod.xmlTextReaderIsValid(self._o)
6677 def LocalName(self):
6678 """The local name of the node. """
6679 ret = libxml2mod.xmlTextReaderConstLocalName(self._o)
6682 def LookupNamespace(self, prefix):
6683 """Resolves a namespace prefix in the scope of the current
6685 ret = libxml2mod.xmlTextReaderLookupNamespace(self._o, prefix)
6688 def MoveToAttribute(self, name):
6689 """Moves the position of the current instance to the attribute
6690 with the specified qualified name. """
6691 ret = libxml2mod.xmlTextReaderMoveToAttribute(self._o, name)
6694 def MoveToAttributeNo(self, no):
6695 """Moves the position of the current instance to the attribute
6696 with the specified index relative to the containing element. """
6697 ret = libxml2mod.xmlTextReaderMoveToAttributeNo(self._o, no)
6700 def MoveToAttributeNs(self, localName, namespaceURI):
6701 """Moves the position of the current instance to the attribute
6702 with the specified local name and namespace URI. """
6703 ret = libxml2mod.xmlTextReaderMoveToAttributeNs(self._o, localName, namespaceURI)
6706 def MoveToElement(self):
6707 """Moves the position of the current instance to the node that
6708 contains the current Attribute node. """
6709 ret = libxml2mod.xmlTextReaderMoveToElement(self._o)
6712 def MoveToFirstAttribute(self):
6713 """Moves the position of the current instance to the first
6714 attribute associated with the current node. """
6715 ret = libxml2mod.xmlTextReaderMoveToFirstAttribute(self._o)
6718 def MoveToNextAttribute(self):
6719 """Moves the position of the current instance to the next
6720 attribute associated with the current node. """
6721 ret = libxml2mod.xmlTextReaderMoveToNextAttribute(self._o)
6725 """The qualified name of the node, equal to Prefix :LocalName. """
6726 ret = libxml2mod.xmlTextReaderConstName(self._o)
6729 def NamespaceUri(self):
6730 """The URI defining the namespace associated with the node. """
6731 ret = libxml2mod.xmlTextReaderConstNamespaceUri(self._o)
6734 def NewDoc(self, cur, URL, encoding, options):
6735 """Setup an xmltextReader to parse an XML in-memory document.
6736 The parsing flags @options are a combination of
6737 xmlParserOption. This reuses the existing @reader
6739 ret = libxml2mod.xmlReaderNewDoc(self._o, cur, URL, encoding, options)
6742 def NewFd(self, fd, URL, encoding, options):
6743 """Setup an xmltextReader to parse an XML from a file
6744 descriptor. NOTE that the file descriptor will not be
6745 closed when the reader is closed or reset. The parsing
6746 flags @options are a combination of xmlParserOption. This
6747 reuses the existing @reader xmlTextReader. """
6748 ret = libxml2mod.xmlReaderNewFd(self._o, fd, URL, encoding, options)
6751 def NewFile(self, filename, encoding, options):
6752 """parse an XML file from the filesystem or the network. The
6753 parsing flags @options are a combination of
6754 xmlParserOption. This reuses the existing @reader
6756 ret = libxml2mod.xmlReaderNewFile(self._o, filename, encoding, options)
6759 def NewMemory(self, buffer, size, URL, encoding, options):
6760 """Setup an xmltextReader to parse an XML in-memory document.
6761 The parsing flags @options are a combination of
6762 xmlParserOption. This reuses the existing @reader
6764 ret = libxml2mod.xmlReaderNewMemory(self._o, buffer, size, URL, encoding, options)
6767 def NewWalker(self, doc):
6768 """Setup an xmltextReader to parse a preparsed XML document.
6769 This reuses the existing @reader xmlTextReader. """
6770 if doc is None: doc__o = None
6771 else: doc__o = doc._o
6772 ret = libxml2mod.xmlReaderNewWalker(self._o, doc__o)
6776 """Skip to the node following the current one in document
6777 order while avoiding the subtree if any. """
6778 ret = libxml2mod.xmlTextReaderNext(self._o)
6781 def NextSibling(self):
6782 """Skip to the node following the current one in document
6783 order while avoiding the subtree if any. Currently
6784 implemented only for Readers built on a document """
6785 ret = libxml2mod.xmlTextReaderNextSibling(self._o)
6789 """Get the node type of the current node Reference:
6790 http://www.gnu.org/software/dotgnu/pnetlib-doc/System/Xml/Xm
6792 ret = libxml2mod.xmlTextReaderNodeType(self._o)
6795 def Normalization(self):
6796 """The value indicating whether to normalize white space and
6797 attribute values. Since attribute value and end of line
6798 normalizations are a MUST in the XML specification only the
6799 value true is accepted. The broken bahaviour of accepting
6800 out of range character entities like � is of course not
6801 supported either. """
6802 ret = libxml2mod.xmlTextReaderNormalization(self._o)
6806 """A shorthand reference to the namespace associated with the
6808 ret = libxml2mod.xmlTextReaderConstPrefix(self._o)
6812 """This tells the XML Reader to preserve the current node. The
6813 caller must also use xmlTextReaderCurrentDoc() to keep an
6814 handle on the resulting document once parsing has finished """
6815 ret = libxml2mod.xmlTextReaderPreserve(self._o)
6816 if ret is None:raise treeError('xmlTextReaderPreserve() failed')
6817 __tmp = xmlNode(_obj=ret)
6820 def QuoteChar(self):
6821 """The quotation mark character used to enclose the value of
6823 ret = libxml2mod.xmlTextReaderQuoteChar(self._o)
6827 """Moves the position of the current instance to the next node
6828 in the stream, exposing its properties. """
6829 ret = libxml2mod.xmlTextReaderRead(self._o)
6832 def ReadAttributeValue(self):
6833 """Parses an attribute value into one or more Text and
6834 EntityReference nodes. """
6835 ret = libxml2mod.xmlTextReaderReadAttributeValue(self._o)
6838 def ReadInnerXml(self):
6839 """Reads the contents of the current node, including child
6840 nodes and markup. """
6841 ret = libxml2mod.xmlTextReaderReadInnerXml(self._o)
6844 def ReadOuterXml(self):
6845 """Reads the contents of the current node, including child
6846 nodes and markup. """
6847 ret = libxml2mod.xmlTextReaderReadOuterXml(self._o)
6850 def ReadState(self):
6851 """Gets the read state of the reader. """
6852 ret = libxml2mod.xmlTextReaderReadState(self._o)
6855 def ReadString(self):
6856 """Reads the contents of an element or a text node as a string. """
6857 ret = libxml2mod.xmlTextReaderReadString(self._o)
6860 def RelaxNGSetSchema(self, schema):
6861 """Use RelaxNG to validate the document as it is processed.
6862 Activation is only possible before the first Read(). if
6863 @schema is None, then RelaxNG validation is desactivated. @
6864 The @schema should not be freed until the reader is
6865 deallocated or its use has been deactivated. """
6866 if schema is None: schema__o = None
6867 else: schema__o = schema._o
6868 ret = libxml2mod.xmlTextReaderRelaxNGSetSchema(self._o, schema__o)
6871 def RelaxNGValidate(self, rng):
6872 """Use RelaxNG schema to validate the document as it is
6873 processed. Activation is only possible before the first
6874 Read(). If @rng is None, then RelaxNG schema validation is
6876 ret = libxml2mod.xmlTextReaderRelaxNGValidate(self._o, rng)
6879 def RelaxNGValidateCtxt(self, ctxt, options):
6880 """Use RelaxNG schema context to validate the document as it
6881 is processed. Activation is only possible before the first
6882 Read(). If @ctxt is None, then RelaxNG schema validation is
6884 if ctxt is None: ctxt__o = None
6885 else: ctxt__o = ctxt._o
6886 ret = libxml2mod.xmlTextReaderRelaxNGValidateCtxt(self._o, ctxt__o, options)
6889 def SchemaValidate(self, xsd):
6890 """Use W3C XSD schema to validate the document as it is
6891 processed. Activation is only possible before the first
6892 Read(). If @xsd is None, then XML Schema validation is
6894 ret = libxml2mod.xmlTextReaderSchemaValidate(self._o, xsd)
6897 def SchemaValidateCtxt(self, ctxt, options):
6898 """Use W3C XSD schema context to validate the document as it
6899 is processed. Activation is only possible before the first
6900 Read(). If @ctxt is None, then XML Schema validation is
6902 if ctxt is None: ctxt__o = None
6903 else: ctxt__o = ctxt._o
6904 ret = libxml2mod.xmlTextReaderSchemaValidateCtxt(self._o, ctxt__o, options)
6907 def SetParserProp(self, prop, value):
6908 """Change the parser processing behaviour by changing some of
6909 its internal properties. Note that some properties can only
6910 be changed before any read has been done. """
6911 ret = libxml2mod.xmlTextReaderSetParserProp(self._o, prop, value)
6914 def SetSchema(self, schema):
6915 """Use XSD Schema to validate the document as it is processed.
6916 Activation is only possible before the first Read(). if
6917 @schema is None, then Schema validation is desactivated. @
6918 The @schema should not be freed until the reader is
6919 deallocated or its use has been deactivated. """
6920 if schema is None: schema__o = None
6921 else: schema__o = schema._o
6922 ret = libxml2mod.xmlTextReaderSetSchema(self._o, schema__o)
6925 def Setup(self, input, URL, encoding, options):
6926 """Setup an XML reader with new options """
6927 if input is None: input__o = None
6928 else: input__o = input._o
6929 ret = libxml2mod.xmlTextReaderSetup(self._o, input__o, URL, encoding, options)
6932 def Standalone(self):
6933 """Determine the standalone status of the document being read. """
6934 ret = libxml2mod.xmlTextReaderStandalone(self._o)
6937 def String(self, str):
6938 """Get an interned string from the reader, allows for example
6939 to speedup string name comparisons """
6940 ret = libxml2mod.xmlTextReaderConstString(self._o, str)
6944 """Provides the text value of the node if present """
6945 ret = libxml2mod.xmlTextReaderConstValue(self._o)
6949 """The xml:lang scope within which the node resides. """
6950 ret = libxml2mod.xmlTextReaderConstXmlLang(self._o)
6953 def XmlVersion(self):
6954 """Determine the XML version of the document being read. """
6955 ret = libxml2mod.xmlTextReaderConstXmlVersion(self._o)
6959 def __init__(self, _obj=None):
6960 if _obj != None:self._o = _obj;return
6965 libxml2mod.xmlFreeURI(self._o)
6969 def authority(self):
6970 """Get the authority part from an URI """
6971 ret = libxml2mod.xmlURIGetAuthority(self._o)
6975 """Get the fragment part from an URI """
6976 ret = libxml2mod.xmlURIGetFragment(self._o)
6980 """Get the opaque part from an URI """
6981 ret = libxml2mod.xmlURIGetOpaque(self._o)
6985 """Get the path part from an URI """
6986 ret = libxml2mod.xmlURIGetPath(self._o)
6990 """Get the port part from an URI """
6991 ret = libxml2mod.xmlURIGetPort(self._o)
6995 """Get the query part from an URI """
6996 ret = libxml2mod.xmlURIGetQuery(self._o)
7000 """Get the raw query part from an URI (i.e. the unescaped
7002 ret = libxml2mod.xmlURIGetQueryRaw(self._o)
7006 """Get the scheme part from an URI """
7007 ret = libxml2mod.xmlURIGetScheme(self._o)
7011 """Get the server part from an URI """
7012 ret = libxml2mod.xmlURIGetServer(self._o)
7015 def setAuthority(self, authority):
7016 """Set the authority part of an URI. """
7017 libxml2mod.xmlURISetAuthority(self._o, authority)
7019 def setFragment(self, fragment):
7020 """Set the fragment part of an URI. """
7021 libxml2mod.xmlURISetFragment(self._o, fragment)
7023 def setOpaque(self, opaque):
7024 """Set the opaque part of an URI. """
7025 libxml2mod.xmlURISetOpaque(self._o, opaque)
7027 def setPath(self, path):
7028 """Set the path part of an URI. """
7029 libxml2mod.xmlURISetPath(self._o, path)
7031 def setPort(self, port):
7032 """Set the port part of an URI. """
7033 libxml2mod.xmlURISetPort(self._o, port)
7035 def setQuery(self, query):
7036 """Set the query part of an URI. """
7037 libxml2mod.xmlURISetQuery(self._o, query)
7039 def setQueryRaw(self, query_raw):
7040 """Set the raw query part of an URI (i.e. the unescaped form). """
7041 libxml2mod.xmlURISetQueryRaw(self._o, query_raw)
7043 def setScheme(self, scheme):
7044 """Set the scheme part of an URI. """
7045 libxml2mod.xmlURISetScheme(self._o, scheme)
7047 def setServer(self, server):
7048 """Set the server part of an URI. """
7049 libxml2mod.xmlURISetServer(self._o, server)
7051 def setUser(self, user):
7052 """Set the user part of an URI. """
7053 libxml2mod.xmlURISetUser(self._o, user)
7056 """Get the user part from an URI """
7057 ret = libxml2mod.xmlURIGetUser(self._o)
7061 # URI functions from module uri
7064 def parseURIReference(self, str):
7065 """Parse an URI reference string based on RFC 3986 and fills
7066 in the appropriate fields of the @uri structure
7067 URI-reference = URI / relative-ref """
7068 ret = libxml2mod.xmlParseURIReference(self._o, str)
7071 def printURI(self, stream):
7072 """Prints the URI in the stream @stream. """
7073 libxml2mod.xmlPrintURI(stream, self._o)
7076 """Save the URI as an escaped string """
7077 ret = libxml2mod.xmlSaveUri(self._o)
7080 class ValidCtxt(ValidCtxtCore):
7081 def __init__(self, _obj=None):
7083 ValidCtxtCore.__init__(self, _obj=_obj)
7087 libxml2mod.xmlFreeValidCtxt(self._o)
7091 # ValidCtxt functions from module valid
7094 def validCtxtNormalizeAttributeValue(self, doc, elem, name, value):
7095 """Does the validation related extra step of the normalization
7096 of attribute values: If the declared value is not CDATA,
7097 then the XML processor must further process the normalized
7098 attribute value by discarding any leading and trailing
7099 space (#x20) characters, and by replacing sequences of
7100 space (#x20) characters by single space (#x20) character.
7101 Also check VC: Standalone Document Declaration in P32, and
7102 update ctxt->valid accordingly """
7103 if doc is None: doc__o = None
7104 else: doc__o = doc._o
7105 if elem is None: elem__o = None
7106 else: elem__o = elem._o
7107 ret = libxml2mod.xmlValidCtxtNormalizeAttributeValue(self._o, doc__o, elem__o, name, value)
7110 def validateDocument(self, doc):
7111 """Try to validate the document instance basically it does
7112 the all the checks described by the XML Rec i.e. validates
7113 the internal and external subset (if present) and validate
7114 the document tree. """
7115 if doc is None: doc__o = None
7116 else: doc__o = doc._o
7117 ret = libxml2mod.xmlValidateDocument(self._o, doc__o)
7120 def validateDocumentFinal(self, doc):
7121 """Does the final step for the document validation once all
7122 the incremental validation steps have been completed
7123 basically it does the following checks described by the XML
7124 Rec Check all the IDREF/IDREFS attributes definition for
7126 if doc is None: doc__o = None
7127 else: doc__o = doc._o
7128 ret = libxml2mod.xmlValidateDocumentFinal(self._o, doc__o)
7131 def validateDtd(self, doc, dtd):
7132 """Try to validate the document against the dtd instance
7133 Basically it does check all the definitions in the DtD.
7134 Note the the internal subset (if present) is de-coupled
7135 (i.e. not used), which could give problems if ID or IDREF
7137 if doc is None: doc__o = None
7138 else: doc__o = doc._o
7139 if dtd is None: dtd__o = None
7140 else: dtd__o = dtd._o
7141 ret = libxml2mod.xmlValidateDtd(self._o, doc__o, dtd__o)
7144 def validateDtdFinal(self, doc):
7145 """Does the final step for the dtds validation once all the
7146 subsets have been parsed basically it does the following
7147 checks described by the XML Rec - check that ENTITY and
7148 ENTITIES type attributes default or possible values matches
7149 one of the defined entities. - check that NOTATION type
7150 attributes default or possible values matches one of the
7151 defined notations. """
7152 if doc is None: doc__o = None
7153 else: doc__o = doc._o
7154 ret = libxml2mod.xmlValidateDtdFinal(self._o, doc__o)
7157 def validateElement(self, doc, elem):
7158 """Try to validate the subtree under an element """
7159 if doc is None: doc__o = None
7160 else: doc__o = doc._o
7161 if elem is None: elem__o = None
7162 else: elem__o = elem._o
7163 ret = libxml2mod.xmlValidateElement(self._o, doc__o, elem__o)
7166 def validateNotationUse(self, doc, notationName):
7167 """Validate that the given name match a notation declaration.
7168 - [ VC: Notation Declared ] """
7169 if doc is None: doc__o = None
7170 else: doc__o = doc._o
7171 ret = libxml2mod.xmlValidateNotationUse(self._o, doc__o, notationName)
7174 def validateOneAttribute(self, doc, elem, attr, value):
7175 """Try to validate a single attribute for an element basically
7176 it does the following checks as described by the XML-1.0
7177 recommendation: - [ VC: Attribute Value Type ] - [ VC:
7178 Fixed Attribute Default ] - [ VC: Entity Name ] - [ VC:
7179 Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC: Entity
7180 Name ] - [ VC: Notation Attributes ] The ID/IDREF
7181 uniqueness and matching are done separately """
7182 if doc is None: doc__o = None
7183 else: doc__o = doc._o
7184 if elem is None: elem__o = None
7185 else: elem__o = elem._o
7186 if attr is None: attr__o = None
7187 else: attr__o = attr._o
7188 ret = libxml2mod.xmlValidateOneAttribute(self._o, doc__o, elem__o, attr__o, value)
7191 def validateOneElement(self, doc, elem):
7192 """Try to validate a single element and it's attributes,
7193 basically it does the following checks as described by the
7194 XML-1.0 recommendation: - [ VC: Element Valid ] - [ VC:
7195 Required Attribute ] Then call xmlValidateOneAttribute()
7196 for each attribute present. The ID/IDREF checkings are
7198 if doc is None: doc__o = None
7199 else: doc__o = doc._o
7200 if elem is None: elem__o = None
7201 else: elem__o = elem._o
7202 ret = libxml2mod.xmlValidateOneElement(self._o, doc__o, elem__o)
7205 def validateOneNamespace(self, doc, elem, prefix, ns, value):
7206 """Try to validate a single namespace declaration for an
7207 element basically it does the following checks as described
7208 by the XML-1.0 recommendation: - [ VC: Attribute Value Type
7209 ] - [ VC: Fixed Attribute Default ] - [ VC: Entity Name ] -
7210 [ VC: Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC:
7211 Entity Name ] - [ VC: Notation Attributes ] The ID/IDREF
7212 uniqueness and matching are done separately """
7213 if doc is None: doc__o = None
7214 else: doc__o = doc._o
7215 if elem is None: elem__o = None
7216 else: elem__o = elem._o
7217 if ns is None: ns__o = None
7219 ret = libxml2mod.xmlValidateOneNamespace(self._o, doc__o, elem__o, prefix, ns__o, value)
7222 def validatePopElement(self, doc, elem, qname):
7223 """Pop the element end from the validation stack. """
7224 if doc is None: doc__o = None
7225 else: doc__o = doc._o
7226 if elem is None: elem__o = None
7227 else: elem__o = elem._o
7228 ret = libxml2mod.xmlValidatePopElement(self._o, doc__o, elem__o, qname)
7231 def validatePushCData(self, data, len):
7232 """check the CData parsed for validation in the current stack """
7233 ret = libxml2mod.xmlValidatePushCData(self._o, data, len)
7236 def validatePushElement(self, doc, elem, qname):
7237 """Push a new element start on the validation stack. """
7238 if doc is None: doc__o = None
7239 else: doc__o = doc._o
7240 if elem is None: elem__o = None
7241 else: elem__o = elem._o
7242 ret = libxml2mod.xmlValidatePushElement(self._o, doc__o, elem__o, qname)
7245 def validateRoot(self, doc):
7246 """Try to validate a the root element basically it does the
7247 following check as described by the XML-1.0 recommendation:
7248 - [ VC: Root Element Type ] it doesn't try to recurse or
7249 apply other check to the element """
7250 if doc is None: doc__o = None
7251 else: doc__o = doc._o
7252 ret = libxml2mod.xmlValidateRoot(self._o, doc__o)
7256 def __init__(self, _obj=None):
7257 if _obj != None:self._o = _obj;return
7260 # accessors for xpathContext
7261 def contextDoc(self):
7262 """Get the doc from an xpathContext """
7263 ret = libxml2mod.xmlXPathGetContextDoc(self._o)
7264 if ret is None:raise xpathError('xmlXPathGetContextDoc() failed')
7265 __tmp = xmlDoc(_obj=ret)
7268 def contextNode(self):
7269 """Get the current node from an xpathContext """
7270 ret = libxml2mod.xmlXPathGetContextNode(self._o)
7271 if ret is None:raise xpathError('xmlXPathGetContextNode() failed')
7272 __tmp = xmlNode(_obj=ret)
7275 def contextPosition(self):
7276 """Get the current node from an xpathContext """
7277 ret = libxml2mod.xmlXPathGetContextPosition(self._o)
7280 def contextSize(self):
7281 """Get the current node from an xpathContext """
7282 ret = libxml2mod.xmlXPathGetContextSize(self._o)
7286 """Get the current function name xpathContext """
7287 ret = libxml2mod.xmlXPathGetFunction(self._o)
7290 def functionURI(self):
7291 """Get the current function name URI xpathContext """
7292 ret = libxml2mod.xmlXPathGetFunctionURI(self._o)
7295 def setContextDoc(self, doc):
7296 """Set the doc of an xpathContext """
7297 if doc is None: doc__o = None
7298 else: doc__o = doc._o
7299 libxml2mod.xmlXPathSetContextDoc(self._o, doc__o)
7301 def setContextNode(self, node):
7302 """Set the current node of an xpathContext """
7303 if node is None: node__o = None
7304 else: node__o = node._o
7305 libxml2mod.xmlXPathSetContextNode(self._o, node__o)
7308 # xpathContext functions from module python
7311 def registerXPathFunction(self, name, ns_uri, f):
7312 """Register a Python written function to the XPath interpreter """
7313 ret = libxml2mod.xmlRegisterXPathFunction(self._o, name, ns_uri, f)
7316 def xpathRegisterVariable(self, name, ns_uri, value):
7317 """Register a variable with the XPath context """
7318 ret = libxml2mod.xmlXPathRegisterVariable(self._o, name, ns_uri, value)
7322 # xpathContext functions from module xpath
7325 def xpathContextSetCache(self, active, value, options):
7326 """Creates/frees an object cache on the XPath context. If
7327 activates XPath objects (xmlXPathObject) will be cached
7328 internally to be reused. @options: 0: This will set the
7329 XPath object caching: @value: This will set the maximum
7330 number of XPath objects to be cached per slot There are 5
7331 slots for: node-set, string, number, boolean, and misc
7332 objects. Use <0 for the default number (100). Other values
7333 for @options have currently no effect. """
7334 ret = libxml2mod.xmlXPathContextSetCache(self._o, active, value, options)
7337 def xpathEval(self, str):
7338 """Evaluate the XPath Location Path in the given context. """
7339 ret = libxml2mod.xmlXPathEval(str, self._o)
7340 if ret is None:raise xpathError('xmlXPathEval() failed')
7341 return xpathObjectRet(ret)
7343 def xpathEvalExpression(self, str):
7344 """Evaluate the XPath expression in the given context. """
7345 ret = libxml2mod.xmlXPathEvalExpression(str, self._o)
7346 if ret is None:raise xpathError('xmlXPathEvalExpression() failed')
7347 return xpathObjectRet(ret)
7349 def xpathFreeContext(self):
7350 """Free up an xmlXPathContext """
7351 libxml2mod.xmlXPathFreeContext(self._o)
7354 # xpathContext functions from module xpathInternals
7357 def xpathNewParserContext(self, str):
7358 """Create a new xmlXPathParserContext """
7359 ret = libxml2mod.xmlXPathNewParserContext(str, self._o)
7360 if ret is None:raise xpathError('xmlXPathNewParserContext() failed')
7361 __tmp = xpathParserContext(_obj=ret)
7364 def xpathNsLookup(self, prefix):
7365 """Search in the namespace declaration array of the context
7366 for the given namespace name associated to the given prefix """
7367 ret = libxml2mod.xmlXPathNsLookup(self._o, prefix)
7370 def xpathRegisterAllFunctions(self):
7371 """Registers all default XPath functions in this context """
7372 libxml2mod.xmlXPathRegisterAllFunctions(self._o)
7374 def xpathRegisterNs(self, prefix, ns_uri):
7375 """Register a new namespace. If @ns_uri is None it unregisters
7377 ret = libxml2mod.xmlXPathRegisterNs(self._o, prefix, ns_uri)
7380 def xpathRegisteredFuncsCleanup(self):
7381 """Cleanup the XPath context data associated to registered
7383 libxml2mod.xmlXPathRegisteredFuncsCleanup(self._o)
7385 def xpathRegisteredNsCleanup(self):
7386 """Cleanup the XPath context data associated to registered
7388 libxml2mod.xmlXPathRegisteredNsCleanup(self._o)
7390 def xpathRegisteredVariablesCleanup(self):
7391 """Cleanup the XPath context data associated to registered
7393 libxml2mod.xmlXPathRegisteredVariablesCleanup(self._o)
7395 def xpathVariableLookup(self, name):
7396 """Search in the Variable array of the context for the given
7398 ret = libxml2mod.xmlXPathVariableLookup(self._o, name)
7399 if ret is None:raise xpathError('xmlXPathVariableLookup() failed')
7400 return xpathObjectRet(ret)
7402 def xpathVariableLookupNS(self, name, ns_uri):
7403 """Search in the Variable array of the context for the given
7405 ret = libxml2mod.xmlXPathVariableLookupNS(self._o, name, ns_uri)
7406 if ret is None:raise xpathError('xmlXPathVariableLookupNS() failed')
7407 return xpathObjectRet(ret)
7410 # xpathContext functions from module xpointer
7413 def xpointerEval(self, str):
7414 """Evaluate the XPath Location Path in the given context. """
7415 ret = libxml2mod.xmlXPtrEval(str, self._o)
7416 if ret is None:raise treeError('xmlXPtrEval() failed')
7417 return xpathObjectRet(ret)
7419 class xpathParserContext:
7420 def __init__(self, _obj=None):
7421 if _obj != None:self._o = _obj;return
7424 # accessors for xpathParserContext
7426 """Get the xpathContext from an xpathParserContext """
7427 ret = libxml2mod.xmlXPathParserGetContext(self._o)
7428 if ret is None:raise xpathError('xmlXPathParserGetContext() failed')
7429 __tmp = xpathContext(_obj=ret)
7433 # xpathParserContext functions from module xpathInternals
7436 def xpathAddValues(self):
7437 """Implement the add operation on XPath objects: The numeric
7438 operators convert their operands to numbers as if by
7439 calling the number function. """
7440 libxml2mod.xmlXPathAddValues(self._o)
7442 def xpathBooleanFunction(self, nargs):
7443 """Implement the boolean() XPath function boolean
7444 boolean(object) The boolean function converts its argument
7445 to a boolean as follows: - a number is true if and only if
7446 it is neither positive or negative zero nor NaN - a
7447 node-set is true if and only if it is non-empty - a string
7448 is true if and only if its length is non-zero """
7449 libxml2mod.xmlXPathBooleanFunction(self._o, nargs)
7451 def xpathCeilingFunction(self, nargs):
7452 """Implement the ceiling() XPath function number
7453 ceiling(number) The ceiling function returns the smallest
7454 (closest to negative infinity) number that is not less than
7455 the argument and that is an integer. """
7456 libxml2mod.xmlXPathCeilingFunction(self._o, nargs)
7458 def xpathCompareValues(self, inf, strict):
7459 """Implement the compare operation on XPath objects: @arg1 <
7460 @arg2 (1, 1, ... @arg1 <= @arg2 (1, 0, ... @arg1 >
7461 @arg2 (0, 1, ... @arg1 >= @arg2 (0, 0, ... When
7462 neither object to be compared is a node-set and the
7463 operator is <=, <, >=, >, then the objects are compared by
7464 converted both objects to numbers and comparing the numbers
7465 according to IEEE 754. The < comparison will be true if and
7466 only if the first number is less than the second number.
7467 The <= comparison will be true if and only if the first
7468 number is less than or equal to the second number. The >
7469 comparison will be true if and only if the first number is
7470 greater than the second number. The >= comparison will be
7471 true if and only if the first number is greater than or
7472 equal to the second number. """
7473 ret = libxml2mod.xmlXPathCompareValues(self._o, inf, strict)
7476 def xpathConcatFunction(self, nargs):
7477 """Implement the concat() XPath function string concat(string,
7478 string, string*) The concat function returns the
7479 concatenation of its arguments. """
7480 libxml2mod.xmlXPathConcatFunction(self._o, nargs)
7482 def xpathContainsFunction(self, nargs):
7483 """Implement the contains() XPath function boolean
7484 contains(string, string) The contains function returns true
7485 if the first argument string contains the second argument
7486 string, and otherwise returns false. """
7487 libxml2mod.xmlXPathContainsFunction(self._o, nargs)
7489 def xpathCountFunction(self, nargs):
7490 """Implement the count() XPath function number count(node-set) """
7491 libxml2mod.xmlXPathCountFunction(self._o, nargs)
7493 def xpathDivValues(self):
7494 """Implement the div operation on XPath objects @arg1 / @arg2:
7495 The numeric operators convert their operands to numbers as
7496 if by calling the number function. """
7497 libxml2mod.xmlXPathDivValues(self._o)
7499 def xpathEqualValues(self):
7500 """Implement the equal operation on XPath objects content:
7502 ret = libxml2mod.xmlXPathEqualValues(self._o)
7505 def xpathErr(self, error):
7506 """Handle an XPath error """
7507 libxml2mod.xmlXPathErr(self._o, error)
7509 def xpathEvalExpr(self):
7510 """Parse and evaluate an XPath expression in the given
7511 context, then push the result on the context stack """
7512 libxml2mod.xmlXPathEvalExpr(self._o)
7514 def xpathFalseFunction(self, nargs):
7515 """Implement the false() XPath function boolean false() """
7516 libxml2mod.xmlXPathFalseFunction(self._o, nargs)
7518 def xpathFloorFunction(self, nargs):
7519 """Implement the floor() XPath function number floor(number)
7520 The floor function returns the largest (closest to positive
7521 infinity) number that is not greater than the argument and
7522 that is an integer. """
7523 libxml2mod.xmlXPathFloorFunction(self._o, nargs)
7525 def xpathFreeParserContext(self):
7526 """Free up an xmlXPathParserContext """
7527 libxml2mod.xmlXPathFreeParserContext(self._o)
7529 def xpathIdFunction(self, nargs):
7530 """Implement the id() XPath function node-set id(object) The
7531 id function selects elements by their unique ID (see [5.2.1
7532 Unique IDs]). When the argument to id is of type node-set,
7533 then the result is the union of the result of applying id
7534 to the string value of each of the nodes in the argument
7535 node-set. When the argument to id is of any other type, the
7536 argument is converted to a string as if by a call to the
7537 string function; the string is split into a
7538 whitespace-separated list of tokens (whitespace is any
7539 sequence of characters matching the production S); the
7540 result is a node-set containing the elements in the same
7541 document as the context node that have a unique ID equal to
7542 any of the tokens in the list. """
7543 libxml2mod.xmlXPathIdFunction(self._o, nargs)
7545 def xpathLangFunction(self, nargs):
7546 """Implement the lang() XPath function boolean lang(string)
7547 The lang function returns true or false depending on
7548 whether the language of the context node as specified by
7549 xml:lang attributes is the same as or is a sublanguage of
7550 the language specified by the argument string. The language
7551 of the context node is determined by the value of the
7552 xml:lang attribute on the context node, or, if the context
7553 node has no xml:lang attribute, by the value of the
7554 xml:lang attribute on the nearest ancestor of the context
7555 node that has an xml:lang attribute. If there is no such
7556 attribute, then lang """
7557 libxml2mod.xmlXPathLangFunction(self._o, nargs)
7559 def xpathLastFunction(self, nargs):
7560 """Implement the last() XPath function number last() The last
7561 function returns the number of nodes in the context node
7563 libxml2mod.xmlXPathLastFunction(self._o, nargs)
7565 def xpathLocalNameFunction(self, nargs):
7566 """Implement the local-name() XPath function string
7567 local-name(node-set?) The local-name function returns a
7568 string containing the local part of the name of the node in
7569 the argument node-set that is first in document order. If
7570 the node-set is empty or the first node has no name, an
7571 empty string is returned. If the argument is omitted it
7572 defaults to the context node. """
7573 libxml2mod.xmlXPathLocalNameFunction(self._o, nargs)
7575 def xpathModValues(self):
7576 """Implement the mod operation on XPath objects: @arg1 / @arg2
7577 The numeric operators convert their operands to numbers as
7578 if by calling the number function. """
7579 libxml2mod.xmlXPathModValues(self._o)
7581 def xpathMultValues(self):
7582 """Implement the multiply operation on XPath objects: The
7583 numeric operators convert their operands to numbers as if
7584 by calling the number function. """
7585 libxml2mod.xmlXPathMultValues(self._o)
7587 def xpathNamespaceURIFunction(self, nargs):
7588 """Implement the namespace-uri() XPath function string
7589 namespace-uri(node-set?) The namespace-uri function returns
7590 a string containing the namespace URI of the expanded name
7591 of the node in the argument node-set that is first in
7592 document order. If the node-set is empty, the first node
7593 has no name, or the expanded name has no namespace URI, an
7594 empty string is returned. If the argument is omitted it
7595 defaults to the context node. """
7596 libxml2mod.xmlXPathNamespaceURIFunction(self._o, nargs)
7598 def xpathNextAncestor(self, cur):
7599 """Traversal function for the "ancestor" direction the
7600 ancestor axis contains the ancestors of the context node;
7601 the ancestors of the context node consist of the parent of
7602 context node and the parent's parent and so on; the nodes
7603 are ordered in reverse document order; thus the parent is
7604 the first node on the axis, and the parent's parent is the
7605 second node on the axis """
7606 if cur is None: cur__o = None
7607 else: cur__o = cur._o
7608 ret = libxml2mod.xmlXPathNextAncestor(self._o, cur__o)
7609 if ret is None:raise xpathError('xmlXPathNextAncestor() failed')
7610 __tmp = xmlNode(_obj=ret)
7613 def xpathNextAncestorOrSelf(self, cur):
7614 """Traversal function for the "ancestor-or-self" direction he
7615 ancestor-or-self axis contains the context node and
7616 ancestors of the context node in reverse document order;
7617 thus the context node is the first node on the axis, and
7618 the context node's parent the second; parent here is
7619 defined the same as with the parent axis. """
7620 if cur is None: cur__o = None
7621 else: cur__o = cur._o
7622 ret = libxml2mod.xmlXPathNextAncestorOrSelf(self._o, cur__o)
7623 if ret is None:raise xpathError('xmlXPathNextAncestorOrSelf() failed')
7624 __tmp = xmlNode(_obj=ret)
7627 def xpathNextAttribute(self, cur):
7628 """Traversal function for the "attribute" direction TODO:
7629 support DTD inherited default attributes """
7630 if cur is None: cur__o = None
7631 else: cur__o = cur._o
7632 ret = libxml2mod.xmlXPathNextAttribute(self._o, cur__o)
7633 if ret is None:raise xpathError('xmlXPathNextAttribute() failed')
7634 __tmp = xmlNode(_obj=ret)
7637 def xpathNextChild(self, cur):
7638 """Traversal function for the "child" direction The child axis
7639 contains the children of the context node in document order. """
7640 if cur is None: cur__o = None
7641 else: cur__o = cur._o
7642 ret = libxml2mod.xmlXPathNextChild(self._o, cur__o)
7643 if ret is None:raise xpathError('xmlXPathNextChild() failed')
7644 __tmp = xmlNode(_obj=ret)
7647 def xpathNextDescendant(self, cur):
7648 """Traversal function for the "descendant" direction the
7649 descendant axis contains the descendants of the context
7650 node in document order; a descendant is a child or a child
7651 of a child and so on. """
7652 if cur is None: cur__o = None
7653 else: cur__o = cur._o
7654 ret = libxml2mod.xmlXPathNextDescendant(self._o, cur__o)
7655 if ret is None:raise xpathError('xmlXPathNextDescendant() failed')
7656 __tmp = xmlNode(_obj=ret)
7659 def xpathNextDescendantOrSelf(self, cur):
7660 """Traversal function for the "descendant-or-self" direction
7661 the descendant-or-self axis contains the context node and
7662 the descendants of the context node in document order; thus
7663 the context node is the first node on the axis, and the
7664 first child of the context node is the second node on the
7666 if cur is None: cur__o = None
7667 else: cur__o = cur._o
7668 ret = libxml2mod.xmlXPathNextDescendantOrSelf(self._o, cur__o)
7669 if ret is None:raise xpathError('xmlXPathNextDescendantOrSelf() failed')
7670 __tmp = xmlNode(_obj=ret)
7673 def xpathNextFollowing(self, cur):
7674 """Traversal function for the "following" direction The
7675 following axis contains all nodes in the same document as
7676 the context node that are after the context node in
7677 document order, excluding any descendants and excluding
7678 attribute nodes and namespace nodes; the nodes are ordered
7679 in document order """
7680 if cur is None: cur__o = None
7681 else: cur__o = cur._o
7682 ret = libxml2mod.xmlXPathNextFollowing(self._o, cur__o)
7683 if ret is None:raise xpathError('xmlXPathNextFollowing() failed')
7684 __tmp = xmlNode(_obj=ret)
7687 def xpathNextFollowingSibling(self, cur):
7688 """Traversal function for the "following-sibling" direction
7689 The following-sibling axis contains the following siblings
7690 of the context node in document order. """
7691 if cur is None: cur__o = None
7692 else: cur__o = cur._o
7693 ret = libxml2mod.xmlXPathNextFollowingSibling(self._o, cur__o)
7694 if ret is None:raise xpathError('xmlXPathNextFollowingSibling() failed')
7695 __tmp = xmlNode(_obj=ret)
7698 def xpathNextNamespace(self, cur):
7699 """Traversal function for the "namespace" direction the
7700 namespace axis contains the namespace nodes of the context
7701 node; the order of nodes on this axis is
7702 implementation-defined; the axis will be empty unless the
7703 context node is an element We keep the XML namespace node
7704 at the end of the list. """
7705 if cur is None: cur__o = None
7706 else: cur__o = cur._o
7707 ret = libxml2mod.xmlXPathNextNamespace(self._o, cur__o)
7708 if ret is None:raise xpathError('xmlXPathNextNamespace() failed')
7709 __tmp = xmlNode(_obj=ret)
7712 def xpathNextParent(self, cur):
7713 """Traversal function for the "parent" direction The parent
7714 axis contains the parent of the context node, if there is
7716 if cur is None: cur__o = None
7717 else: cur__o = cur._o
7718 ret = libxml2mod.xmlXPathNextParent(self._o, cur__o)
7719 if ret is None:raise xpathError('xmlXPathNextParent() failed')
7720 __tmp = xmlNode(_obj=ret)
7723 def xpathNextPreceding(self, cur):
7724 """Traversal function for the "preceding" direction the
7725 preceding axis contains all nodes in the same document as
7726 the context node that are before the context node in
7727 document order, excluding any ancestors and excluding
7728 attribute nodes and namespace nodes; the nodes are ordered
7729 in reverse document order """
7730 if cur is None: cur__o = None
7731 else: cur__o = cur._o
7732 ret = libxml2mod.xmlXPathNextPreceding(self._o, cur__o)
7733 if ret is None:raise xpathError('xmlXPathNextPreceding() failed')
7734 __tmp = xmlNode(_obj=ret)
7737 def xpathNextPrecedingSibling(self, cur):
7738 """Traversal function for the "preceding-sibling" direction
7739 The preceding-sibling axis contains the preceding siblings
7740 of the context node in reverse document order; the first
7741 preceding sibling is first on the axis; the sibling
7742 preceding that node is the second on the axis and so on. """
7743 if cur is None: cur__o = None
7744 else: cur__o = cur._o
7745 ret = libxml2mod.xmlXPathNextPrecedingSibling(self._o, cur__o)
7746 if ret is None:raise xpathError('xmlXPathNextPrecedingSibling() failed')
7747 __tmp = xmlNode(_obj=ret)
7750 def xpathNextSelf(self, cur):
7751 """Traversal function for the "self" direction The self axis
7752 contains just the context node itself """
7753 if cur is None: cur__o = None
7754 else: cur__o = cur._o
7755 ret = libxml2mod.xmlXPathNextSelf(self._o, cur__o)
7756 if ret is None:raise xpathError('xmlXPathNextSelf() failed')
7757 __tmp = xmlNode(_obj=ret)
7760 def xpathNormalizeFunction(self, nargs):
7761 """Implement the normalize-space() XPath function string
7762 normalize-space(string?) The normalize-space function
7763 returns the argument string with white space normalized by
7764 stripping leading and trailing whitespace and replacing
7765 sequences of whitespace characters by a single space.
7766 Whitespace characters are the same allowed by the S
7767 production in XML. If the argument is omitted, it defaults
7768 to the context node converted to a string, in other words
7769 the value of the context node. """
7770 libxml2mod.xmlXPathNormalizeFunction(self._o, nargs)
7772 def xpathNotEqualValues(self):
7773 """Implement the equal operation on XPath objects content:
7775 ret = libxml2mod.xmlXPathNotEqualValues(self._o)
7778 def xpathNotFunction(self, nargs):
7779 """Implement the not() XPath function boolean not(boolean) The
7780 not function returns true if its argument is false, and
7781 false otherwise. """
7782 libxml2mod.xmlXPathNotFunction(self._o, nargs)
7784 def xpathNumberFunction(self, nargs):
7785 """Implement the number() XPath function number number(object?) """
7786 libxml2mod.xmlXPathNumberFunction(self._o, nargs)
7788 def xpathParseNCName(self):
7789 """parse an XML namespace non qualified name. [NS 3] NCName
7790 ::= (Letter | '_') (NCNameChar)* [NS 4] NCNameChar ::=
7791 Letter | Digit | '.' | '-' | '_' | CombiningChar | Extender """
7792 ret = libxml2mod.xmlXPathParseNCName(self._o)
7795 def xpathParseName(self):
7796 """parse an XML name [4] NameChar ::= Letter | Digit | '.' |
7797 '-' | '_' | ':' | CombiningChar | Extender [5] Name ::=
7798 (Letter | '_' | ':') (NameChar)* """
7799 ret = libxml2mod.xmlXPathParseName(self._o)
7802 def xpathPopBoolean(self):
7803 """Pops a boolean from the stack, handling conversion if
7804 needed. Check error with #xmlXPathCheckError. """
7805 ret = libxml2mod.xmlXPathPopBoolean(self._o)
7808 def xpathPopNumber(self):
7809 """Pops a number from the stack, handling conversion if
7810 needed. Check error with #xmlXPathCheckError. """
7811 ret = libxml2mod.xmlXPathPopNumber(self._o)
7814 def xpathPopString(self):
7815 """Pops a string from the stack, handling conversion if
7816 needed. Check error with #xmlXPathCheckError. """
7817 ret = libxml2mod.xmlXPathPopString(self._o)
7820 def xpathPositionFunction(self, nargs):
7821 """Implement the position() XPath function number position()
7822 The position function returns the position of the context
7823 node in the context node list. The first position is 1, and
7824 so the last position will be equal to last(). """
7825 libxml2mod.xmlXPathPositionFunction(self._o, nargs)
7827 def xpathRoot(self):
7828 """Initialize the context to the root of the document """
7829 libxml2mod.xmlXPathRoot(self._o)
7831 def xpathRoundFunction(self, nargs):
7832 """Implement the round() XPath function number round(number)
7833 The round function returns the number that is closest to
7834 the argument and that is an integer. If there are two such
7835 numbers, then the one that is even is returned. """
7836 libxml2mod.xmlXPathRoundFunction(self._o, nargs)
7838 def xpathStartsWithFunction(self, nargs):
7839 """Implement the starts-with() XPath function boolean
7840 starts-with(string, string) The starts-with function
7841 returns true if the first argument string starts with the
7842 second argument string, and otherwise returns false. """
7843 libxml2mod.xmlXPathStartsWithFunction(self._o, nargs)
7845 def xpathStringFunction(self, nargs):
7846 """Implement the string() XPath function string
7847 string(object?) The string function converts an object to a
7848 string as follows: - A node-set is converted to a string by
7849 returning the value of the node in the node-set that is
7850 first in document order. If the node-set is empty, an empty
7851 string is returned. - A number is converted to a string as
7852 follows + NaN is converted to the string NaN + positive
7853 zero is converted to the string 0 + negative zero is
7854 converted to the string 0 + positive infinity is converted
7855 to the string Infinity + negative infinity is converted to
7856 the string -Infinity + if the number is an integer, the
7857 number is represented in decimal form as a Number with no
7858 decimal point and no leading zeros, preceded by a minus
7859 sign (-) if the number is negative + otherwise, the number
7860 is represented in decimal form as a Number including a
7861 decimal point with at least one digit before the decimal
7862 point and at least one digit after the decimal point,
7863 preceded by a minus sign (-) if the number is negative;
7864 there must be no leading zeros before the decimal point
7865 apart possibly from the one required digit immediately
7866 before the decimal point; beyond the one required digit
7867 after the decimal point there must be as many, but only as
7868 many, more digits as are needed to uniquely distinguish the
7869 number from all other IEEE 754 numeric values. - The
7870 boolean false value is converted to the string false. The
7871 boolean true value is converted to the string true. If the
7872 argument is omitted, it defaults to a node-set with the
7873 context node as its only member. """
7874 libxml2mod.xmlXPathStringFunction(self._o, nargs)
7876 def xpathStringLengthFunction(self, nargs):
7877 """Implement the string-length() XPath function number
7878 string-length(string?) The string-length returns the number
7879 of characters in the string (see [3.6 Strings]). If the
7880 argument is omitted, it defaults to the context node
7881 converted to a string, in other words the value of the
7883 libxml2mod.xmlXPathStringLengthFunction(self._o, nargs)
7885 def xpathSubValues(self):
7886 """Implement the subtraction operation on XPath objects: The
7887 numeric operators convert their operands to numbers as if
7888 by calling the number function. """
7889 libxml2mod.xmlXPathSubValues(self._o)
7891 def xpathSubstringAfterFunction(self, nargs):
7892 """Implement the substring-after() XPath function string
7893 substring-after(string, string) The substring-after
7894 function returns the substring of the first argument string
7895 that follows the first occurrence of the second argument
7896 string in the first argument string, or the empty stringi
7897 if the first argument string does not contain the second
7898 argument string. For example,
7899 substring-after("1999/04/01","/") returns 04/01, and
7900 substring-after("1999/04/01","19") returns 99/04/01. """
7901 libxml2mod.xmlXPathSubstringAfterFunction(self._o, nargs)
7903 def xpathSubstringBeforeFunction(self, nargs):
7904 """Implement the substring-before() XPath function string
7905 substring-before(string, string) The substring-before
7906 function returns the substring of the first argument string
7907 that precedes the first occurrence of the second argument
7908 string in the first argument string, or the empty string if
7909 the first argument string does not contain the second
7910 argument string. For example,
7911 substring-before("1999/04/01","/") returns 1999. """
7912 libxml2mod.xmlXPathSubstringBeforeFunction(self._o, nargs)
7914 def xpathSubstringFunction(self, nargs):
7915 """Implement the substring() XPath function string
7916 substring(string, number, number?) The substring function
7917 returns the substring of the first argument starting at the
7918 position specified in the second argument with length
7919 specified in the third argument. For example,
7920 substring("12345",2,3) returns "234". If the third argument
7921 is not specified, it returns the substring starting at the
7922 position specified in the second argument and continuing to
7923 the end of the string. For example, substring("12345",2)
7924 returns "2345". More precisely, each character in the
7925 string (see [3.6 Strings]) is considered to have a numeric
7926 position: the position of the first character is 1, the
7927 position of the second character is 2 and so on. The
7928 returned substring contains those characters for which the
7929 position of the character is greater than or equal to the
7930 second argument and, if the third argument is specified,
7931 less than the sum of the second and third arguments; the
7932 comparisons and addition used for the above follow the
7933 standard IEEE 754 rules. Thus: - substring("12345", 1.5,
7934 2.6) returns "234" - substring("12345", 0, 3) returns "12"
7935 - substring("12345", 0 div 0, 3) returns "" -
7936 substring("12345", 1, 0 div 0) returns "" -
7937 substring("12345", -42, 1 div 0) returns "12345" -
7938 substring("12345", -1 div 0, 1 div 0) returns "" """
7939 libxml2mod.xmlXPathSubstringFunction(self._o, nargs)
7941 def xpathSumFunction(self, nargs):
7942 """Implement the sum() XPath function number sum(node-set) The
7943 sum function returns the sum of the values of the nodes in
7944 the argument node-set. """
7945 libxml2mod.xmlXPathSumFunction(self._o, nargs)
7947 def xpathTranslateFunction(self, nargs):
7948 """Implement the translate() XPath function string
7949 translate(string, string, string) The translate function
7950 returns the first argument string with occurrences of
7951 characters in the second argument string replaced by the
7952 character at the corresponding position in the third
7953 argument string. For example, translate("bar","abc","ABC")
7954 returns the string BAr. If there is a character in the
7955 second argument string with no character at a corresponding
7956 position in the third argument string (because the second
7957 argument string is longer than the third argument string),
7958 then occurrences of that character in the first argument
7959 string are removed. For example,
7960 translate("--aaa--","abc-","ABC") """
7961 libxml2mod.xmlXPathTranslateFunction(self._o, nargs)
7963 def xpathTrueFunction(self, nargs):
7964 """Implement the true() XPath function boolean true() """
7965 libxml2mod.xmlXPathTrueFunction(self._o, nargs)
7967 def xpathValueFlipSign(self):
7968 """Implement the unary - operation on an XPath object The
7969 numeric operators convert their operands to numbers as if
7970 by calling the number function. """
7971 libxml2mod.xmlXPathValueFlipSign(self._o)
7973 def xpatherror(self, file, line, no):
7974 """Formats an error message. """
7975 libxml2mod.xmlXPatherror(self._o, file, line, no)
7978 # xpathParserContext functions from module xpointer
7981 def xpointerEvalRangePredicate(self):
7982 """[8] Predicate ::= '[' PredicateExpr ']' [9]
7983 PredicateExpr ::= Expr Evaluate a predicate as in
7984 xmlXPathEvalPredicate() but for a Location Set instead of a
7986 libxml2mod.xmlXPtrEvalRangePredicate(self._o)
7988 def xpointerRangeToFunction(self, nargs):
7989 """Implement the range-to() XPointer function """
7990 libxml2mod.xmlXPtrRangeToFunction(self._o, nargs)
7995 XLINK_SHOW_EMBED = 2
7996 XLINK_SHOW_REPLACE = 3
7998 # xmlRelaxNGParserFlag
7999 XML_RELAXNGP_NONE = 0
8000 XML_RELAXNGP_FREE_DOC = 1
8001 XML_RELAXNGP_CRNG = 2
8003 # xmlBufferAllocationScheme
8004 XML_BUFFER_ALLOC_DOUBLEIT = 1
8005 XML_BUFFER_ALLOC_EXACT = 2
8006 XML_BUFFER_ALLOC_IMMUTABLE = 3
8007 XML_BUFFER_ALLOC_IO = 4
8008 XML_BUFFER_ALLOC_HYBRID = 5
8010 # xmlParserSeverities
8011 XML_PARSER_SEVERITY_VALIDITY_WARNING = 1
8012 XML_PARSER_SEVERITY_VALIDITY_ERROR = 2
8013 XML_PARSER_SEVERITY_WARNING = 3
8014 XML_PARSER_SEVERITY_ERROR = 4
8016 # xmlAttributeDefault
8017 XML_ATTRIBUTE_NONE = 1
8018 XML_ATTRIBUTE_REQUIRED = 2
8019 XML_ATTRIBUTE_IMPLIED = 3
8020 XML_ATTRIBUTE_FIXED = 4
8023 XML_SCHEMAS_UNKNOWN = 0
8024 XML_SCHEMAS_STRING = 1
8025 XML_SCHEMAS_NORMSTRING = 2
8026 XML_SCHEMAS_DECIMAL = 3
8027 XML_SCHEMAS_TIME = 4
8028 XML_SCHEMAS_GDAY = 5
8029 XML_SCHEMAS_GMONTH = 6
8030 XML_SCHEMAS_GMONTHDAY = 7
8031 XML_SCHEMAS_GYEAR = 8
8032 XML_SCHEMAS_GYEARMONTH = 9
8033 XML_SCHEMAS_DATE = 10
8034 XML_SCHEMAS_DATETIME = 11
8035 XML_SCHEMAS_DURATION = 12
8036 XML_SCHEMAS_FLOAT = 13
8037 XML_SCHEMAS_DOUBLE = 14
8038 XML_SCHEMAS_BOOLEAN = 15
8039 XML_SCHEMAS_TOKEN = 16
8040 XML_SCHEMAS_LANGUAGE = 17
8041 XML_SCHEMAS_NMTOKEN = 18
8042 XML_SCHEMAS_NMTOKENS = 19
8043 XML_SCHEMAS_NAME = 20
8044 XML_SCHEMAS_QNAME = 21
8045 XML_SCHEMAS_NCNAME = 22
8047 XML_SCHEMAS_IDREF = 24
8048 XML_SCHEMAS_IDREFS = 25
8049 XML_SCHEMAS_ENTITY = 26
8050 XML_SCHEMAS_ENTITIES = 27
8051 XML_SCHEMAS_NOTATION = 28
8052 XML_SCHEMAS_ANYURI = 29
8053 XML_SCHEMAS_INTEGER = 30
8054 XML_SCHEMAS_NPINTEGER = 31
8055 XML_SCHEMAS_NINTEGER = 32
8056 XML_SCHEMAS_NNINTEGER = 33
8057 XML_SCHEMAS_PINTEGER = 34
8058 XML_SCHEMAS_INT = 35
8059 XML_SCHEMAS_UINT = 36
8060 XML_SCHEMAS_LONG = 37
8061 XML_SCHEMAS_ULONG = 38
8062 XML_SCHEMAS_SHORT = 39
8063 XML_SCHEMAS_USHORT = 40
8064 XML_SCHEMAS_BYTE = 41
8065 XML_SCHEMAS_UBYTE = 42
8066 XML_SCHEMAS_HEXBINARY = 43
8067 XML_SCHEMAS_BASE64BINARY = 44
8068 XML_SCHEMAS_ANYTYPE = 45
8069 XML_SCHEMAS_ANYSIMPLETYPE = 46
8071 # xmlParserInputState
8073 XML_PARSER_START = 0
8077 XML_PARSER_PROLOG = 4
8078 XML_PARSER_COMMENT = 5
8079 XML_PARSER_START_TAG = 6
8080 XML_PARSER_CONTENT = 7
8081 XML_PARSER_CDATA_SECTION = 8
8082 XML_PARSER_END_TAG = 9
8083 XML_PARSER_ENTITY_DECL = 10
8084 XML_PARSER_ENTITY_VALUE = 11
8085 XML_PARSER_ATTRIBUTE_VALUE = 12
8086 XML_PARSER_SYSTEM_LITERAL = 13
8087 XML_PARSER_EPILOG = 14
8088 XML_PARSER_IGNORE = 15
8089 XML_PARSER_PUBLIC_LITERAL = 16
8092 XML_INTERNAL_GENERAL_ENTITY = 1
8093 XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2
8094 XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3
8095 XML_INTERNAL_PARAMETER_ENTITY = 4
8096 XML_EXTERNAL_PARAMETER_ENTITY = 5
8097 XML_INTERNAL_PREDEFINED_ENTITY = 6
8101 XML_SAVE_NO_DECL = 2
8102 XML_SAVE_NO_EMPTY = 4
8103 XML_SAVE_NO_XHTML = 8
8105 XML_SAVE_AS_XML = 32
8106 XML_SAVE_AS_HTML = 64
8107 XML_SAVE_WSNONSIG = 128
8110 XML_PATTERN_DEFAULT = 0
8111 XML_PATTERN_XPATH = 1
8112 XML_PATTERN_XSSEL = 2
8113 XML_PATTERN_XSFIELD = 4
8117 XML_ERR_INTERNAL_ERROR = 1
8118 XML_ERR_NO_MEMORY = 2
8119 XML_ERR_DOCUMENT_START = 3
8120 XML_ERR_DOCUMENT_EMPTY = 4
8121 XML_ERR_DOCUMENT_END = 5
8122 XML_ERR_INVALID_HEX_CHARREF = 6
8123 XML_ERR_INVALID_DEC_CHARREF = 7
8124 XML_ERR_INVALID_CHARREF = 8
8125 XML_ERR_INVALID_CHAR = 9
8126 XML_ERR_CHARREF_AT_EOF = 10
8127 XML_ERR_CHARREF_IN_PROLOG = 11
8128 XML_ERR_CHARREF_IN_EPILOG = 12
8129 XML_ERR_CHARREF_IN_DTD = 13
8130 XML_ERR_ENTITYREF_AT_EOF = 14
8131 XML_ERR_ENTITYREF_IN_PROLOG = 15
8132 XML_ERR_ENTITYREF_IN_EPILOG = 16
8133 XML_ERR_ENTITYREF_IN_DTD = 17
8134 XML_ERR_PEREF_AT_EOF = 18
8135 XML_ERR_PEREF_IN_PROLOG = 19
8136 XML_ERR_PEREF_IN_EPILOG = 20
8137 XML_ERR_PEREF_IN_INT_SUBSET = 21
8138 XML_ERR_ENTITYREF_NO_NAME = 22
8139 XML_ERR_ENTITYREF_SEMICOL_MISSING = 23
8140 XML_ERR_PEREF_NO_NAME = 24
8141 XML_ERR_PEREF_SEMICOL_MISSING = 25
8142 XML_ERR_UNDECLARED_ENTITY = 26
8143 XML_WAR_UNDECLARED_ENTITY = 27
8144 XML_ERR_UNPARSED_ENTITY = 28
8145 XML_ERR_ENTITY_IS_EXTERNAL = 29
8146 XML_ERR_ENTITY_IS_PARAMETER = 30
8147 XML_ERR_UNKNOWN_ENCODING = 31
8148 XML_ERR_UNSUPPORTED_ENCODING = 32
8149 XML_ERR_STRING_NOT_STARTED = 33
8150 XML_ERR_STRING_NOT_CLOSED = 34
8151 XML_ERR_NS_DECL_ERROR = 35
8152 XML_ERR_ENTITY_NOT_STARTED = 36
8153 XML_ERR_ENTITY_NOT_FINISHED = 37
8154 XML_ERR_LT_IN_ATTRIBUTE = 38
8155 XML_ERR_ATTRIBUTE_NOT_STARTED = 39
8156 XML_ERR_ATTRIBUTE_NOT_FINISHED = 40
8157 XML_ERR_ATTRIBUTE_WITHOUT_VALUE = 41
8158 XML_ERR_ATTRIBUTE_REDEFINED = 42
8159 XML_ERR_LITERAL_NOT_STARTED = 43
8160 XML_ERR_LITERAL_NOT_FINISHED = 44
8161 XML_ERR_COMMENT_NOT_FINISHED = 45
8162 XML_ERR_PI_NOT_STARTED = 46
8163 XML_ERR_PI_NOT_FINISHED = 47
8164 XML_ERR_NOTATION_NOT_STARTED = 48
8165 XML_ERR_NOTATION_NOT_FINISHED = 49
8166 XML_ERR_ATTLIST_NOT_STARTED = 50
8167 XML_ERR_ATTLIST_NOT_FINISHED = 51
8168 XML_ERR_MIXED_NOT_STARTED = 52
8169 XML_ERR_MIXED_NOT_FINISHED = 53
8170 XML_ERR_ELEMCONTENT_NOT_STARTED = 54
8171 XML_ERR_ELEMCONTENT_NOT_FINISHED = 55
8172 XML_ERR_XMLDECL_NOT_STARTED = 56
8173 XML_ERR_XMLDECL_NOT_FINISHED = 57
8174 XML_ERR_CONDSEC_NOT_STARTED = 58
8175 XML_ERR_CONDSEC_NOT_FINISHED = 59
8176 XML_ERR_EXT_SUBSET_NOT_FINISHED = 60
8177 XML_ERR_DOCTYPE_NOT_FINISHED = 61
8178 XML_ERR_MISPLACED_CDATA_END = 62
8179 XML_ERR_CDATA_NOT_FINISHED = 63
8180 XML_ERR_RESERVED_XML_NAME = 64
8181 XML_ERR_SPACE_REQUIRED = 65
8182 XML_ERR_SEPARATOR_REQUIRED = 66
8183 XML_ERR_NMTOKEN_REQUIRED = 67
8184 XML_ERR_NAME_REQUIRED = 68
8185 XML_ERR_PCDATA_REQUIRED = 69
8186 XML_ERR_URI_REQUIRED = 70
8187 XML_ERR_PUBID_REQUIRED = 71
8188 XML_ERR_LT_REQUIRED = 72
8189 XML_ERR_GT_REQUIRED = 73
8190 XML_ERR_LTSLASH_REQUIRED = 74
8191 XML_ERR_EQUAL_REQUIRED = 75
8192 XML_ERR_TAG_NAME_MISMATCH = 76
8193 XML_ERR_TAG_NOT_FINISHED = 77
8194 XML_ERR_STANDALONE_VALUE = 78
8195 XML_ERR_ENCODING_NAME = 79
8196 XML_ERR_HYPHEN_IN_COMMENT = 80
8197 XML_ERR_INVALID_ENCODING = 81
8198 XML_ERR_EXT_ENTITY_STANDALONE = 82
8199 XML_ERR_CONDSEC_INVALID = 83
8200 XML_ERR_VALUE_REQUIRED = 84
8201 XML_ERR_NOT_WELL_BALANCED = 85
8202 XML_ERR_EXTRA_CONTENT = 86
8203 XML_ERR_ENTITY_CHAR_ERROR = 87
8204 XML_ERR_ENTITY_PE_INTERNAL = 88
8205 XML_ERR_ENTITY_LOOP = 89
8206 XML_ERR_ENTITY_BOUNDARY = 90
8207 XML_ERR_INVALID_URI = 91
8208 XML_ERR_URI_FRAGMENT = 92
8209 XML_WAR_CATALOG_PI = 93
8211 XML_ERR_CONDSEC_INVALID_KEYWORD = 95
8212 XML_ERR_VERSION_MISSING = 96
8213 XML_WAR_UNKNOWN_VERSION = 97
8214 XML_WAR_LANG_VALUE = 98
8216 XML_WAR_NS_URI_RELATIVE = 100
8217 XML_ERR_MISSING_ENCODING = 101
8218 XML_WAR_SPACE_VALUE = 102
8219 XML_ERR_NOT_STANDALONE = 103
8220 XML_ERR_ENTITY_PROCESSING = 104
8221 XML_ERR_NOTATION_PROCESSING = 105
8222 XML_WAR_NS_COLUMN = 106
8223 XML_WAR_ENTITY_REDEFINED = 107
8224 XML_ERR_UNKNOWN_VERSION = 108
8225 XML_ERR_VERSION_MISMATCH = 109
8226 XML_ERR_NAME_TOO_LONG = 110
8227 XML_ERR_USER_STOP = 111
8228 XML_NS_ERR_XML_NAMESPACE = 200
8229 XML_NS_ERR_UNDEFINED_NAMESPACE = 201
8230 XML_NS_ERR_QNAME = 202
8231 XML_NS_ERR_ATTRIBUTE_REDEFINED = 203
8232 XML_NS_ERR_EMPTY = 204
8233 XML_NS_ERR_COLON = 205
8234 XML_DTD_ATTRIBUTE_DEFAULT = 500
8235 XML_DTD_ATTRIBUTE_REDEFINED = 501
8236 XML_DTD_ATTRIBUTE_VALUE = 502
8237 XML_DTD_CONTENT_ERROR = 503
8238 XML_DTD_CONTENT_MODEL = 504
8239 XML_DTD_CONTENT_NOT_DETERMINIST = 505
8240 XML_DTD_DIFFERENT_PREFIX = 506
8241 XML_DTD_ELEM_DEFAULT_NAMESPACE = 507
8242 XML_DTD_ELEM_NAMESPACE = 508
8243 XML_DTD_ELEM_REDEFINED = 509
8244 XML_DTD_EMPTY_NOTATION = 510
8245 XML_DTD_ENTITY_TYPE = 511
8246 XML_DTD_ID_FIXED = 512
8247 XML_DTD_ID_REDEFINED = 513
8248 XML_DTD_ID_SUBSET = 514
8249 XML_DTD_INVALID_CHILD = 515
8250 XML_DTD_INVALID_DEFAULT = 516
8251 XML_DTD_LOAD_ERROR = 517
8252 XML_DTD_MISSING_ATTRIBUTE = 518
8253 XML_DTD_MIXED_CORRUPT = 519
8254 XML_DTD_MULTIPLE_ID = 520
8255 XML_DTD_NO_DOC = 521
8256 XML_DTD_NO_DTD = 522
8257 XML_DTD_NO_ELEM_NAME = 523
8258 XML_DTD_NO_PREFIX = 524
8259 XML_DTD_NO_ROOT = 525
8260 XML_DTD_NOTATION_REDEFINED = 526
8261 XML_DTD_NOTATION_VALUE = 527
8262 XML_DTD_NOT_EMPTY = 528
8263 XML_DTD_NOT_PCDATA = 529
8264 XML_DTD_NOT_STANDALONE = 530
8265 XML_DTD_ROOT_NAME = 531
8266 XML_DTD_STANDALONE_WHITE_SPACE = 532
8267 XML_DTD_UNKNOWN_ATTRIBUTE = 533
8268 XML_DTD_UNKNOWN_ELEM = 534
8269 XML_DTD_UNKNOWN_ENTITY = 535
8270 XML_DTD_UNKNOWN_ID = 536
8271 XML_DTD_UNKNOWN_NOTATION = 537
8272 XML_DTD_STANDALONE_DEFAULTED = 538
8273 XML_DTD_XMLID_VALUE = 539
8274 XML_DTD_XMLID_TYPE = 540
8275 XML_DTD_DUP_TOKEN = 541
8276 XML_HTML_STRUCURE_ERROR = 800
8277 XML_HTML_UNKNOWN_TAG = 801
8278 XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000
8279 XML_RNGP_ATTR_CONFLICT = 1001
8280 XML_RNGP_ATTRIBUTE_CHILDREN = 1002
8281 XML_RNGP_ATTRIBUTE_CONTENT = 1003
8282 XML_RNGP_ATTRIBUTE_EMPTY = 1004
8283 XML_RNGP_ATTRIBUTE_NOOP = 1005
8284 XML_RNGP_CHOICE_CONTENT = 1006
8285 XML_RNGP_CHOICE_EMPTY = 1007
8286 XML_RNGP_CREATE_FAILURE = 1008
8287 XML_RNGP_DATA_CONTENT = 1009
8288 XML_RNGP_DEF_CHOICE_AND_INTERLEAVE = 1010
8289 XML_RNGP_DEFINE_CREATE_FAILED = 1011
8290 XML_RNGP_DEFINE_EMPTY = 1012
8291 XML_RNGP_DEFINE_MISSING = 1013
8292 XML_RNGP_DEFINE_NAME_MISSING = 1014
8293 XML_RNGP_ELEM_CONTENT_EMPTY = 1015
8294 XML_RNGP_ELEM_CONTENT_ERROR = 1016
8295 XML_RNGP_ELEMENT_EMPTY = 1017
8296 XML_RNGP_ELEMENT_CONTENT = 1018
8297 XML_RNGP_ELEMENT_NAME = 1019
8298 XML_RNGP_ELEMENT_NO_CONTENT = 1020
8299 XML_RNGP_ELEM_TEXT_CONFLICT = 1021
8300 XML_RNGP_EMPTY = 1022
8301 XML_RNGP_EMPTY_CONSTRUCT = 1023
8302 XML_RNGP_EMPTY_CONTENT = 1024
8303 XML_RNGP_EMPTY_NOT_EMPTY = 1025
8304 XML_RNGP_ERROR_TYPE_LIB = 1026
8305 XML_RNGP_EXCEPT_EMPTY = 1027
8306 XML_RNGP_EXCEPT_MISSING = 1028
8307 XML_RNGP_EXCEPT_MULTIPLE = 1029
8308 XML_RNGP_EXCEPT_NO_CONTENT = 1030
8309 XML_RNGP_EXTERNALREF_EMTPY = 1031
8310 XML_RNGP_EXTERNAL_REF_FAILURE = 1032
8311 XML_RNGP_EXTERNALREF_RECURSE = 1033
8312 XML_RNGP_FORBIDDEN_ATTRIBUTE = 1034
8313 XML_RNGP_FOREIGN_ELEMENT = 1035
8314 XML_RNGP_GRAMMAR_CONTENT = 1036
8315 XML_RNGP_GRAMMAR_EMPTY = 1037
8316 XML_RNGP_GRAMMAR_MISSING = 1038
8317 XML_RNGP_GRAMMAR_NO_START = 1039
8318 XML_RNGP_GROUP_ATTR_CONFLICT = 1040
8319 XML_RNGP_HREF_ERROR = 1041
8320 XML_RNGP_INCLUDE_EMPTY = 1042
8321 XML_RNGP_INCLUDE_FAILURE = 1043
8322 XML_RNGP_INCLUDE_RECURSE = 1044
8323 XML_RNGP_INTERLEAVE_ADD = 1045
8324 XML_RNGP_INTERLEAVE_CREATE_FAILED = 1046
8325 XML_RNGP_INTERLEAVE_EMPTY = 1047
8326 XML_RNGP_INTERLEAVE_NO_CONTENT = 1048
8327 XML_RNGP_INVALID_DEFINE_NAME = 1049
8328 XML_RNGP_INVALID_URI = 1050
8329 XML_RNGP_INVALID_VALUE = 1051
8330 XML_RNGP_MISSING_HREF = 1052
8331 XML_RNGP_NAME_MISSING = 1053
8332 XML_RNGP_NEED_COMBINE = 1054
8333 XML_RNGP_NOTALLOWED_NOT_EMPTY = 1055
8334 XML_RNGP_NSNAME_ATTR_ANCESTOR = 1056
8335 XML_RNGP_NSNAME_NO_NS = 1057
8336 XML_RNGP_PARAM_FORBIDDEN = 1058
8337 XML_RNGP_PARAM_NAME_MISSING = 1059
8338 XML_RNGP_PARENTREF_CREATE_FAILED = 1060
8339 XML_RNGP_PARENTREF_NAME_INVALID = 1061
8340 XML_RNGP_PARENTREF_NO_NAME = 1062
8341 XML_RNGP_PARENTREF_NO_PARENT = 1063
8342 XML_RNGP_PARENTREF_NOT_EMPTY = 1064
8343 XML_RNGP_PARSE_ERROR = 1065
8344 XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME = 1066
8345 XML_RNGP_PAT_ATTR_ATTR = 1067
8346 XML_RNGP_PAT_ATTR_ELEM = 1068
8347 XML_RNGP_PAT_DATA_EXCEPT_ATTR = 1069
8348 XML_RNGP_PAT_DATA_EXCEPT_ELEM = 1070
8349 XML_RNGP_PAT_DATA_EXCEPT_EMPTY = 1071
8350 XML_RNGP_PAT_DATA_EXCEPT_GROUP = 1072
8351 XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE = 1073
8352 XML_RNGP_PAT_DATA_EXCEPT_LIST = 1074
8353 XML_RNGP_PAT_DATA_EXCEPT_ONEMORE = 1075
8354 XML_RNGP_PAT_DATA_EXCEPT_REF = 1076
8355 XML_RNGP_PAT_DATA_EXCEPT_TEXT = 1077
8356 XML_RNGP_PAT_LIST_ATTR = 1078
8357 XML_RNGP_PAT_LIST_ELEM = 1079
8358 XML_RNGP_PAT_LIST_INTERLEAVE = 1080
8359 XML_RNGP_PAT_LIST_LIST = 1081
8360 XML_RNGP_PAT_LIST_REF = 1082
8361 XML_RNGP_PAT_LIST_TEXT = 1083
8362 XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME = 1084
8363 XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME = 1085
8364 XML_RNGP_PAT_ONEMORE_GROUP_ATTR = 1086
8365 XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR = 1087
8366 XML_RNGP_PAT_START_ATTR = 1088
8367 XML_RNGP_PAT_START_DATA = 1089
8368 XML_RNGP_PAT_START_EMPTY = 1090
8369 XML_RNGP_PAT_START_GROUP = 1091
8370 XML_RNGP_PAT_START_INTERLEAVE = 1092
8371 XML_RNGP_PAT_START_LIST = 1093
8372 XML_RNGP_PAT_START_ONEMORE = 1094
8373 XML_RNGP_PAT_START_TEXT = 1095
8374 XML_RNGP_PAT_START_VALUE = 1096
8375 XML_RNGP_PREFIX_UNDEFINED = 1097
8376 XML_RNGP_REF_CREATE_FAILED = 1098
8377 XML_RNGP_REF_CYCLE = 1099
8378 XML_RNGP_REF_NAME_INVALID = 1100
8379 XML_RNGP_REF_NO_DEF = 1101
8380 XML_RNGP_REF_NO_NAME = 1102
8381 XML_RNGP_REF_NOT_EMPTY = 1103
8382 XML_RNGP_START_CHOICE_AND_INTERLEAVE = 1104
8383 XML_RNGP_START_CONTENT = 1105
8384 XML_RNGP_START_EMPTY = 1106
8385 XML_RNGP_START_MISSING = 1107
8386 XML_RNGP_TEXT_EXPECTED = 1108
8387 XML_RNGP_TEXT_HAS_CHILD = 1109
8388 XML_RNGP_TYPE_MISSING = 1110
8389 XML_RNGP_TYPE_NOT_FOUND = 1111
8390 XML_RNGP_TYPE_VALUE = 1112
8391 XML_RNGP_UNKNOWN_ATTRIBUTE = 1113
8392 XML_RNGP_UNKNOWN_COMBINE = 1114
8393 XML_RNGP_UNKNOWN_CONSTRUCT = 1115
8394 XML_RNGP_UNKNOWN_TYPE_LIB = 1116
8395 XML_RNGP_URI_FRAGMENT = 1117
8396 XML_RNGP_URI_NOT_ABSOLUTE = 1118
8397 XML_RNGP_VALUE_EMPTY = 1119
8398 XML_RNGP_VALUE_NO_CONTENT = 1120
8399 XML_RNGP_XMLNS_NAME = 1121
8400 XML_RNGP_XML_NS = 1122
8401 XML_XPATH_EXPRESSION_OK = 1200
8402 XML_XPATH_NUMBER_ERROR = 1201
8403 XML_XPATH_UNFINISHED_LITERAL_ERROR = 1202
8404 XML_XPATH_START_LITERAL_ERROR = 1203
8405 XML_XPATH_VARIABLE_REF_ERROR = 1204
8406 XML_XPATH_UNDEF_VARIABLE_ERROR = 1205
8407 XML_XPATH_INVALID_PREDICATE_ERROR = 1206
8408 XML_XPATH_EXPR_ERROR = 1207
8409 XML_XPATH_UNCLOSED_ERROR = 1208
8410 XML_XPATH_UNKNOWN_FUNC_ERROR = 1209
8411 XML_XPATH_INVALID_OPERAND = 1210
8412 XML_XPATH_INVALID_TYPE = 1211
8413 XML_XPATH_INVALID_ARITY = 1212
8414 XML_XPATH_INVALID_CTXT_SIZE = 1213
8415 XML_XPATH_INVALID_CTXT_POSITION = 1214
8416 XML_XPATH_MEMORY_ERROR = 1215
8417 XML_XPTR_SYNTAX_ERROR = 1216
8418 XML_XPTR_RESOURCE_ERROR = 1217
8419 XML_XPTR_SUB_RESOURCE_ERROR = 1218
8420 XML_XPATH_UNDEF_PREFIX_ERROR = 1219
8421 XML_XPATH_ENCODING_ERROR = 1220
8422 XML_XPATH_INVALID_CHAR_ERROR = 1221
8423 XML_TREE_INVALID_HEX = 1300
8424 XML_TREE_INVALID_DEC = 1301
8425 XML_TREE_UNTERMINATED_ENTITY = 1302
8426 XML_TREE_NOT_UTF8 = 1303
8427 XML_SAVE_NOT_UTF8 = 1400
8428 XML_SAVE_CHAR_INVALID = 1401
8429 XML_SAVE_NO_DOCTYPE = 1402
8430 XML_SAVE_UNKNOWN_ENCODING = 1403
8431 XML_REGEXP_COMPILE_ERROR = 1450
8432 XML_IO_UNKNOWN = 1500
8433 XML_IO_EACCES = 1501
8434 XML_IO_EAGAIN = 1502
8436 XML_IO_EBADMSG = 1504
8438 XML_IO_ECANCELED = 1506
8439 XML_IO_ECHILD = 1507
8440 XML_IO_EDEADLK = 1508
8442 XML_IO_EEXIST = 1510
8443 XML_IO_EFAULT = 1511
8445 XML_IO_EINPROGRESS = 1513
8447 XML_IO_EINVAL = 1515
8449 XML_IO_EISDIR = 1517
8450 XML_IO_EMFILE = 1518
8451 XML_IO_EMLINK = 1519
8452 XML_IO_EMSGSIZE = 1520
8453 XML_IO_ENAMETOOLONG = 1521
8454 XML_IO_ENFILE = 1522
8455 XML_IO_ENODEV = 1523
8456 XML_IO_ENOENT = 1524
8457 XML_IO_ENOEXEC = 1525
8458 XML_IO_ENOLCK = 1526
8459 XML_IO_ENOMEM = 1527
8460 XML_IO_ENOSPC = 1528
8461 XML_IO_ENOSYS = 1529
8462 XML_IO_ENOTDIR = 1530
8463 XML_IO_ENOTEMPTY = 1531
8464 XML_IO_ENOTSUP = 1532
8465 XML_IO_ENOTTY = 1533
8469 XML_IO_ERANGE = 1537
8471 XML_IO_ESPIPE = 1539
8473 XML_IO_ETIMEDOUT = 1541
8475 XML_IO_NETWORK_ATTEMPT = 1543
8476 XML_IO_ENCODER = 1544
8479 XML_IO_NO_INPUT = 1547
8480 XML_IO_BUFFER_FULL = 1548
8481 XML_IO_LOAD_ERROR = 1549
8482 XML_IO_ENOTSOCK = 1550
8483 XML_IO_EISCONN = 1551
8484 XML_IO_ECONNREFUSED = 1552
8485 XML_IO_ENETUNREACH = 1553
8486 XML_IO_EADDRINUSE = 1554
8487 XML_IO_EALREADY = 1555
8488 XML_IO_EAFNOSUPPORT = 1556
8489 XML_XINCLUDE_RECURSION = 1600
8490 XML_XINCLUDE_PARSE_VALUE = 1601
8491 XML_XINCLUDE_ENTITY_DEF_MISMATCH = 1602
8492 XML_XINCLUDE_NO_HREF = 1603
8493 XML_XINCLUDE_NO_FALLBACK = 1604
8494 XML_XINCLUDE_HREF_URI = 1605
8495 XML_XINCLUDE_TEXT_FRAGMENT = 1606
8496 XML_XINCLUDE_TEXT_DOCUMENT = 1607
8497 XML_XINCLUDE_INVALID_CHAR = 1608
8498 XML_XINCLUDE_BUILD_FAILED = 1609
8499 XML_XINCLUDE_UNKNOWN_ENCODING = 1610
8500 XML_XINCLUDE_MULTIPLE_ROOT = 1611
8501 XML_XINCLUDE_XPTR_FAILED = 1612
8502 XML_XINCLUDE_XPTR_RESULT = 1613
8503 XML_XINCLUDE_INCLUDE_IN_INCLUDE = 1614
8504 XML_XINCLUDE_FALLBACKS_IN_INCLUDE = 1615
8505 XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE = 1616
8506 XML_XINCLUDE_DEPRECATED_NS = 1617
8507 XML_XINCLUDE_FRAGMENT_ID = 1618
8508 XML_CATALOG_MISSING_ATTR = 1650
8509 XML_CATALOG_ENTRY_BROKEN = 1651
8510 XML_CATALOG_PREFER_VALUE = 1652
8511 XML_CATALOG_NOT_CATALOG = 1653
8512 XML_CATALOG_RECURSION = 1654
8513 XML_SCHEMAP_PREFIX_UNDEFINED = 1700
8514 XML_SCHEMAP_ATTRFORMDEFAULT_VALUE = 1701
8515 XML_SCHEMAP_ATTRGRP_NONAME_NOREF = 1702
8516 XML_SCHEMAP_ATTR_NONAME_NOREF = 1703
8517 XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF = 1704
8518 XML_SCHEMAP_ELEMFORMDEFAULT_VALUE = 1705
8519 XML_SCHEMAP_ELEM_NONAME_NOREF = 1706
8520 XML_SCHEMAP_EXTENSION_NO_BASE = 1707
8521 XML_SCHEMAP_FACET_NO_VALUE = 1708
8522 XML_SCHEMAP_FAILED_BUILD_IMPORT = 1709
8523 XML_SCHEMAP_GROUP_NONAME_NOREF = 1710
8524 XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI = 1711
8525 XML_SCHEMAP_IMPORT_REDEFINE_NSNAME = 1712
8526 XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI = 1713
8527 XML_SCHEMAP_INVALID_BOOLEAN = 1714
8528 XML_SCHEMAP_INVALID_ENUM = 1715
8529 XML_SCHEMAP_INVALID_FACET = 1716
8530 XML_SCHEMAP_INVALID_FACET_VALUE = 1717
8531 XML_SCHEMAP_INVALID_MAXOCCURS = 1718
8532 XML_SCHEMAP_INVALID_MINOCCURS = 1719
8533 XML_SCHEMAP_INVALID_REF_AND_SUBTYPE = 1720
8534 XML_SCHEMAP_INVALID_WHITE_SPACE = 1721
8535 XML_SCHEMAP_NOATTR_NOREF = 1722
8536 XML_SCHEMAP_NOTATION_NO_NAME = 1723
8537 XML_SCHEMAP_NOTYPE_NOREF = 1724
8538 XML_SCHEMAP_REF_AND_SUBTYPE = 1725
8539 XML_SCHEMAP_RESTRICTION_NONAME_NOREF = 1726
8540 XML_SCHEMAP_SIMPLETYPE_NONAME = 1727
8541 XML_SCHEMAP_TYPE_AND_SUBTYPE = 1728
8542 XML_SCHEMAP_UNKNOWN_ALL_CHILD = 1729
8543 XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD = 1730
8544 XML_SCHEMAP_UNKNOWN_ATTR_CHILD = 1731
8545 XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD = 1732
8546 XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP = 1733
8547 XML_SCHEMAP_UNKNOWN_BASE_TYPE = 1734
8548 XML_SCHEMAP_UNKNOWN_CHOICE_CHILD = 1735
8549 XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD = 1736
8550 XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD = 1737
8551 XML_SCHEMAP_UNKNOWN_ELEM_CHILD = 1738
8552 XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD = 1739
8553 XML_SCHEMAP_UNKNOWN_FACET_CHILD = 1740
8554 XML_SCHEMAP_UNKNOWN_FACET_TYPE = 1741
8555 XML_SCHEMAP_UNKNOWN_GROUP_CHILD = 1742
8556 XML_SCHEMAP_UNKNOWN_IMPORT_CHILD = 1743
8557 XML_SCHEMAP_UNKNOWN_LIST_CHILD = 1744
8558 XML_SCHEMAP_UNKNOWN_NOTATION_CHILD = 1745
8559 XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD = 1746
8560 XML_SCHEMAP_UNKNOWN_REF = 1747
8561 XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD = 1748
8562 XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD = 1749
8563 XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD = 1750
8564 XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD = 1751
8565 XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD = 1752
8566 XML_SCHEMAP_UNKNOWN_TYPE = 1753
8567 XML_SCHEMAP_UNKNOWN_UNION_CHILD = 1754
8568 XML_SCHEMAP_ELEM_DEFAULT_FIXED = 1755
8569 XML_SCHEMAP_REGEXP_INVALID = 1756
8570 XML_SCHEMAP_FAILED_LOAD = 1757
8571 XML_SCHEMAP_NOTHING_TO_PARSE = 1758
8572 XML_SCHEMAP_NOROOT = 1759
8573 XML_SCHEMAP_REDEFINED_GROUP = 1760
8574 XML_SCHEMAP_REDEFINED_TYPE = 1761
8575 XML_SCHEMAP_REDEFINED_ELEMENT = 1762
8576 XML_SCHEMAP_REDEFINED_ATTRGROUP = 1763
8577 XML_SCHEMAP_REDEFINED_ATTR = 1764
8578 XML_SCHEMAP_REDEFINED_NOTATION = 1765
8579 XML_SCHEMAP_FAILED_PARSE = 1766
8580 XML_SCHEMAP_UNKNOWN_PREFIX = 1767
8581 XML_SCHEMAP_DEF_AND_PREFIX = 1768
8582 XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD = 1769
8583 XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI = 1770
8584 XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI = 1771
8585 XML_SCHEMAP_NOT_SCHEMA = 1772
8586 XML_SCHEMAP_UNKNOWN_MEMBER_TYPE = 1773
8587 XML_SCHEMAP_INVALID_ATTR_USE = 1774
8588 XML_SCHEMAP_RECURSIVE = 1775
8589 XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE = 1776
8590 XML_SCHEMAP_INVALID_ATTR_COMBINATION = 1777
8591 XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION = 1778
8592 XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD = 1779
8593 XML_SCHEMAP_INVALID_ATTR_NAME = 1780
8594 XML_SCHEMAP_REF_AND_CONTENT = 1781
8595 XML_SCHEMAP_CT_PROPS_CORRECT_1 = 1782
8596 XML_SCHEMAP_CT_PROPS_CORRECT_2 = 1783
8597 XML_SCHEMAP_CT_PROPS_CORRECT_3 = 1784
8598 XML_SCHEMAP_CT_PROPS_CORRECT_4 = 1785
8599 XML_SCHEMAP_CT_PROPS_CORRECT_5 = 1786
8600 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1 = 1787
8601 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1 = 1788
8602 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2 = 1789
8603 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2 = 1790
8604 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3 = 1791
8605 XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER = 1792
8606 XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE = 1793
8607 XML_SCHEMAP_UNION_NOT_EXPRESSIBLE = 1794
8608 XML_SCHEMAP_SRC_IMPORT_3_1 = 1795
8609 XML_SCHEMAP_SRC_IMPORT_3_2 = 1796
8610 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1 = 1797
8611 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2 = 1798
8612 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3 = 1799
8613 XML_SCHEMAP_COS_CT_EXTENDS_1_3 = 1800
8614 XML_SCHEMAV_NOROOT = 1801
8615 XML_SCHEMAV_UNDECLAREDELEM = 1802
8616 XML_SCHEMAV_NOTTOPLEVEL = 1803
8617 XML_SCHEMAV_MISSING = 1804
8618 XML_SCHEMAV_WRONGELEM = 1805
8619 XML_SCHEMAV_NOTYPE = 1806
8620 XML_SCHEMAV_NOROLLBACK = 1807
8621 XML_SCHEMAV_ISABSTRACT = 1808
8622 XML_SCHEMAV_NOTEMPTY = 1809
8623 XML_SCHEMAV_ELEMCONT = 1810
8624 XML_SCHEMAV_HAVEDEFAULT = 1811
8625 XML_SCHEMAV_NOTNILLABLE = 1812
8626 XML_SCHEMAV_EXTRACONTENT = 1813
8627 XML_SCHEMAV_INVALIDATTR = 1814
8628 XML_SCHEMAV_INVALIDELEM = 1815
8629 XML_SCHEMAV_NOTDETERMINIST = 1816
8630 XML_SCHEMAV_CONSTRUCT = 1817
8631 XML_SCHEMAV_INTERNAL = 1818
8632 XML_SCHEMAV_NOTSIMPLE = 1819
8633 XML_SCHEMAV_ATTRUNKNOWN = 1820
8634 XML_SCHEMAV_ATTRINVALID = 1821
8635 XML_SCHEMAV_VALUE = 1822
8636 XML_SCHEMAV_FACET = 1823
8637 XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1 = 1824
8638 XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2 = 1825
8639 XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3 = 1826
8640 XML_SCHEMAV_CVC_TYPE_3_1_1 = 1827
8641 XML_SCHEMAV_CVC_TYPE_3_1_2 = 1828
8642 XML_SCHEMAV_CVC_FACET_VALID = 1829
8643 XML_SCHEMAV_CVC_LENGTH_VALID = 1830
8644 XML_SCHEMAV_CVC_MINLENGTH_VALID = 1831
8645 XML_SCHEMAV_CVC_MAXLENGTH_VALID = 1832
8646 XML_SCHEMAV_CVC_MININCLUSIVE_VALID = 1833
8647 XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID = 1834
8648 XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID = 1835
8649 XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID = 1836
8650 XML_SCHEMAV_CVC_TOTALDIGITS_VALID = 1837
8651 XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID = 1838
8652 XML_SCHEMAV_CVC_PATTERN_VALID = 1839
8653 XML_SCHEMAV_CVC_ENUMERATION_VALID = 1840
8654 XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1 = 1841
8655 XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2 = 1842
8656 XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3 = 1843
8657 XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4 = 1844
8658 XML_SCHEMAV_CVC_ELT_1 = 1845
8659 XML_SCHEMAV_CVC_ELT_2 = 1846
8660 XML_SCHEMAV_CVC_ELT_3_1 = 1847
8661 XML_SCHEMAV_CVC_ELT_3_2_1 = 1848
8662 XML_SCHEMAV_CVC_ELT_3_2_2 = 1849
8663 XML_SCHEMAV_CVC_ELT_4_1 = 1850
8664 XML_SCHEMAV_CVC_ELT_4_2 = 1851
8665 XML_SCHEMAV_CVC_ELT_4_3 = 1852
8666 XML_SCHEMAV_CVC_ELT_5_1_1 = 1853
8667 XML_SCHEMAV_CVC_ELT_5_1_2 = 1854
8668 XML_SCHEMAV_CVC_ELT_5_2_1 = 1855
8669 XML_SCHEMAV_CVC_ELT_5_2_2_1 = 1856
8670 XML_SCHEMAV_CVC_ELT_5_2_2_2_1 = 1857
8671 XML_SCHEMAV_CVC_ELT_5_2_2_2_2 = 1858
8672 XML_SCHEMAV_CVC_ELT_6 = 1859
8673 XML_SCHEMAV_CVC_ELT_7 = 1860
8674 XML_SCHEMAV_CVC_ATTRIBUTE_1 = 1861
8675 XML_SCHEMAV_CVC_ATTRIBUTE_2 = 1862
8676 XML_SCHEMAV_CVC_ATTRIBUTE_3 = 1863
8677 XML_SCHEMAV_CVC_ATTRIBUTE_4 = 1864
8678 XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1 = 1865
8679 XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1 = 1866
8680 XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2 = 1867
8681 XML_SCHEMAV_CVC_COMPLEX_TYPE_4 = 1868
8682 XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1 = 1869
8683 XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2 = 1870
8684 XML_SCHEMAV_ELEMENT_CONTENT = 1871
8685 XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING = 1872
8686 XML_SCHEMAV_CVC_COMPLEX_TYPE_1 = 1873
8687 XML_SCHEMAV_CVC_AU = 1874
8688 XML_SCHEMAV_CVC_TYPE_1 = 1875
8689 XML_SCHEMAV_CVC_TYPE_2 = 1876
8690 XML_SCHEMAV_CVC_IDC = 1877
8691 XML_SCHEMAV_CVC_WILDCARD = 1878
8692 XML_SCHEMAV_MISC = 1879
8693 XML_XPTR_UNKNOWN_SCHEME = 1900
8694 XML_XPTR_CHILDSEQ_START = 1901
8695 XML_XPTR_EVAL_FAILED = 1902
8696 XML_XPTR_EXTRA_OBJECTS = 1903
8697 XML_C14N_CREATE_CTXT = 1950
8698 XML_C14N_REQUIRES_UTF8 = 1951
8699 XML_C14N_CREATE_STACK = 1952
8700 XML_C14N_INVALID_NODE = 1953
8701 XML_C14N_UNKNOW_NODE = 1954
8702 XML_C14N_RELATIVE_NAMESPACE = 1955
8703 XML_FTP_PASV_ANSWER = 2000
8704 XML_FTP_EPSV_ANSWER = 2001
8705 XML_FTP_ACCNT = 2002
8706 XML_FTP_URL_SYNTAX = 2003
8707 XML_HTTP_URL_SYNTAX = 2020
8708 XML_HTTP_USE_IP = 2021
8709 XML_HTTP_UNKNOWN_HOST = 2022
8710 XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000
8711 XML_SCHEMAP_SRC_SIMPLE_TYPE_2 = 3001
8712 XML_SCHEMAP_SRC_SIMPLE_TYPE_3 = 3002
8713 XML_SCHEMAP_SRC_SIMPLE_TYPE_4 = 3003
8714 XML_SCHEMAP_SRC_RESOLVE = 3004
8715 XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE = 3005
8716 XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE = 3006
8717 XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES = 3007
8718 XML_SCHEMAP_ST_PROPS_CORRECT_1 = 3008
8719 XML_SCHEMAP_ST_PROPS_CORRECT_2 = 3009
8720 XML_SCHEMAP_ST_PROPS_CORRECT_3 = 3010
8721 XML_SCHEMAP_COS_ST_RESTRICTS_1_1 = 3011
8722 XML_SCHEMAP_COS_ST_RESTRICTS_1_2 = 3012
8723 XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1 = 3013
8724 XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2 = 3014
8725 XML_SCHEMAP_COS_ST_RESTRICTS_2_1 = 3015
8726 XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1 = 3016
8727 XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2 = 3017
8728 XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1 = 3018
8729 XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2 = 3019
8730 XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3 = 3020
8731 XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4 = 3021
8732 XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5 = 3022
8733 XML_SCHEMAP_COS_ST_RESTRICTS_3_1 = 3023
8734 XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1 = 3024
8735 XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2 = 3025
8736 XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2 = 3026
8737 XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1 = 3027
8738 XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3 = 3028
8739 XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4 = 3029
8740 XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5 = 3030
8741 XML_SCHEMAP_COS_ST_DERIVED_OK_2_1 = 3031
8742 XML_SCHEMAP_COS_ST_DERIVED_OK_2_2 = 3032
8743 XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED = 3033
8744 XML_SCHEMAP_S4S_ELEM_MISSING = 3034
8745 XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED = 3035
8746 XML_SCHEMAP_S4S_ATTR_MISSING = 3036
8747 XML_SCHEMAP_S4S_ATTR_INVALID_VALUE = 3037
8748 XML_SCHEMAP_SRC_ELEMENT_1 = 3038
8749 XML_SCHEMAP_SRC_ELEMENT_2_1 = 3039
8750 XML_SCHEMAP_SRC_ELEMENT_2_2 = 3040
8751 XML_SCHEMAP_SRC_ELEMENT_3 = 3041
8752 XML_SCHEMAP_P_PROPS_CORRECT_1 = 3042
8753 XML_SCHEMAP_P_PROPS_CORRECT_2_1 = 3043
8754 XML_SCHEMAP_P_PROPS_CORRECT_2_2 = 3044
8755 XML_SCHEMAP_E_PROPS_CORRECT_2 = 3045
8756 XML_SCHEMAP_E_PROPS_CORRECT_3 = 3046
8757 XML_SCHEMAP_E_PROPS_CORRECT_4 = 3047
8758 XML_SCHEMAP_E_PROPS_CORRECT_5 = 3048
8759 XML_SCHEMAP_E_PROPS_CORRECT_6 = 3049
8760 XML_SCHEMAP_SRC_INCLUDE = 3050
8761 XML_SCHEMAP_SRC_ATTRIBUTE_1 = 3051
8762 XML_SCHEMAP_SRC_ATTRIBUTE_2 = 3052
8763 XML_SCHEMAP_SRC_ATTRIBUTE_3_1 = 3053
8764 XML_SCHEMAP_SRC_ATTRIBUTE_3_2 = 3054
8765 XML_SCHEMAP_SRC_ATTRIBUTE_4 = 3055
8766 XML_SCHEMAP_NO_XMLNS = 3056
8767 XML_SCHEMAP_NO_XSI = 3057
8768 XML_SCHEMAP_COS_VALID_DEFAULT_1 = 3058
8769 XML_SCHEMAP_COS_VALID_DEFAULT_2_1 = 3059
8770 XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1 = 3060
8771 XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2 = 3061
8772 XML_SCHEMAP_CVC_SIMPLE_TYPE = 3062
8773 XML_SCHEMAP_COS_CT_EXTENDS_1_1 = 3063
8774 XML_SCHEMAP_SRC_IMPORT_1_1 = 3064
8775 XML_SCHEMAP_SRC_IMPORT_1_2 = 3065
8776 XML_SCHEMAP_SRC_IMPORT_2 = 3066
8777 XML_SCHEMAP_SRC_IMPORT_2_1 = 3067
8778 XML_SCHEMAP_SRC_IMPORT_2_2 = 3068
8779 XML_SCHEMAP_INTERNAL = 3069
8780 XML_SCHEMAP_NOT_DETERMINISTIC = 3070
8781 XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1 = 3071
8782 XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2 = 3072
8783 XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3 = 3073
8784 XML_SCHEMAP_MG_PROPS_CORRECT_1 = 3074
8785 XML_SCHEMAP_MG_PROPS_CORRECT_2 = 3075
8786 XML_SCHEMAP_SRC_CT_1 = 3076
8787 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3 = 3077
8788 XML_SCHEMAP_AU_PROPS_CORRECT_2 = 3078
8789 XML_SCHEMAP_A_PROPS_CORRECT_2 = 3079
8790 XML_SCHEMAP_C_PROPS_CORRECT = 3080
8791 XML_SCHEMAP_SRC_REDEFINE = 3081
8792 XML_SCHEMAP_SRC_IMPORT = 3082
8793 XML_SCHEMAP_WARN_SKIP_SCHEMA = 3083
8794 XML_SCHEMAP_WARN_UNLOCATED_SCHEMA = 3084
8795 XML_SCHEMAP_WARN_ATTR_REDECL_PROH = 3085
8796 XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH = 3086
8797 XML_SCHEMAP_AG_PROPS_CORRECT = 3087
8798 XML_SCHEMAP_COS_CT_EXTENDS_1_2 = 3088
8799 XML_SCHEMAP_AU_PROPS_CORRECT = 3089
8800 XML_SCHEMAP_A_PROPS_CORRECT_3 = 3090
8801 XML_SCHEMAP_COS_ALL_LIMITED = 3091
8802 XML_SCHEMATRONV_ASSERT = 4000
8803 XML_SCHEMATRONV_REPORT = 4001
8804 XML_MODULE_OPEN = 4900
8805 XML_MODULE_CLOSE = 4901
8806 XML_CHECK_FOUND_ELEMENT = 5000
8807 XML_CHECK_FOUND_ATTRIBUTE = 5001
8808 XML_CHECK_FOUND_TEXT = 5002
8809 XML_CHECK_FOUND_CDATA = 5003
8810 XML_CHECK_FOUND_ENTITYREF = 5004
8811 XML_CHECK_FOUND_ENTITY = 5005
8812 XML_CHECK_FOUND_PI = 5006
8813 XML_CHECK_FOUND_COMMENT = 5007
8814 XML_CHECK_FOUND_DOCTYPE = 5008
8815 XML_CHECK_FOUND_FRAGMENT = 5009
8816 XML_CHECK_FOUND_NOTATION = 5010
8817 XML_CHECK_UNKNOWN_NODE = 5011
8818 XML_CHECK_ENTITY_TYPE = 5012
8819 XML_CHECK_NO_PARENT = 5013
8820 XML_CHECK_NO_DOC = 5014
8821 XML_CHECK_NO_NAME = 5015
8822 XML_CHECK_NO_ELEM = 5016
8823 XML_CHECK_WRONG_DOC = 5017
8824 XML_CHECK_NO_PREV = 5018
8825 XML_CHECK_WRONG_PREV = 5019
8826 XML_CHECK_NO_NEXT = 5020
8827 XML_CHECK_WRONG_NEXT = 5021
8828 XML_CHECK_NOT_DTD = 5022
8829 XML_CHECK_NOT_ATTR = 5023
8830 XML_CHECK_NOT_ATTR_DECL = 5024
8831 XML_CHECK_NOT_ELEM_DECL = 5025
8832 XML_CHECK_NOT_ENTITY_DECL = 5026
8833 XML_CHECK_NOT_NS_DECL = 5027
8834 XML_CHECK_NO_HREF = 5028
8835 XML_CHECK_WRONG_PARENT = 5029
8836 XML_CHECK_NS_SCOPE = 5030
8837 XML_CHECK_NS_ANCESTOR = 5031
8838 XML_CHECK_NOT_UTF8 = 5032
8839 XML_CHECK_NO_DICT = 5033
8840 XML_CHECK_NOT_NCNAME = 5034
8841 XML_CHECK_OUTSIDE_DICT = 5035
8842 XML_CHECK_WRONG_NAME = 5036
8843 XML_CHECK_NAME_NOT_NULL = 5037
8844 XML_I18N_NO_NAME = 6000
8845 XML_I18N_NO_HANDLER = 6001
8846 XML_I18N_EXCESS_HANDLER = 6002
8847 XML_I18N_CONV_FAILED = 6003
8848 XML_I18N_NO_OUTPUT = 6004
8849 XML_BUF_OVERFLOW = 7000
8859 # xmlElementContentType
8860 XML_ELEMENT_CONTENT_PCDATA = 1
8861 XML_ELEMENT_CONTENT_ELEMENT = 2
8862 XML_ELEMENT_CONTENT_SEQ = 3
8863 XML_ELEMENT_CONTENT_OR = 4
8865 # xmlParserProperties
8866 XML_PARSER_LOADDTD = 1
8867 XML_PARSER_DEFAULTATTRS = 2
8868 XML_PARSER_VALIDATE = 3
8869 XML_PARSER_SUBST_ENTITIES = 4
8872 XML_READER_TYPE_NONE = 0
8873 XML_READER_TYPE_ELEMENT = 1
8874 XML_READER_TYPE_ATTRIBUTE = 2
8875 XML_READER_TYPE_TEXT = 3
8876 XML_READER_TYPE_CDATA = 4
8877 XML_READER_TYPE_ENTITY_REFERENCE = 5
8878 XML_READER_TYPE_ENTITY = 6
8879 XML_READER_TYPE_PROCESSING_INSTRUCTION = 7
8880 XML_READER_TYPE_COMMENT = 8
8881 XML_READER_TYPE_DOCUMENT = 9
8882 XML_READER_TYPE_DOCUMENT_TYPE = 10
8883 XML_READER_TYPE_DOCUMENT_FRAGMENT = 11
8884 XML_READER_TYPE_NOTATION = 12
8885 XML_READER_TYPE_WHITESPACE = 13
8886 XML_READER_TYPE_SIGNIFICANT_WHITESPACE = 14
8887 XML_READER_TYPE_END_ELEMENT = 15
8888 XML_READER_TYPE_END_ENTITY = 16
8889 XML_READER_TYPE_XML_DECLARATION = 17
8892 XML_CATA_PREFER_NONE = 0
8893 XML_CATA_PREFER_PUBLIC = 1
8894 XML_CATA_PREFER_SYSTEM = 2
8897 XML_ELEMENT_NODE = 1
8898 XML_ATTRIBUTE_NODE = 2
8900 XML_CDATA_SECTION_NODE = 4
8901 XML_ENTITY_REF_NODE = 5
8904 XML_COMMENT_NODE = 8
8905 XML_DOCUMENT_NODE = 9
8906 XML_DOCUMENT_TYPE_NODE = 10
8907 XML_DOCUMENT_FRAG_NODE = 11
8908 XML_NOTATION_NODE = 12
8909 XML_HTML_DOCUMENT_NODE = 13
8911 XML_ELEMENT_DECL = 15
8912 XML_ATTRIBUTE_DECL = 16
8913 XML_ENTITY_DECL = 17
8914 XML_NAMESPACE_DECL = 18
8915 XML_XINCLUDE_START = 19
8916 XML_XINCLUDE_END = 20
8917 XML_DOCB_DOCUMENT_NODE = 21
8920 XLINK_ACTUATE_NONE = 0
8921 XLINK_ACTUATE_AUTO = 1
8922 XLINK_ACTUATE_ONREQUEST = 2
8930 XML_WITH_PATTERN = 6
8937 XML_WITH_LEGACY = 13
8939 XML_WITH_CATALOG = 15
8942 XML_WITH_XINCLUDE = 18
8944 XML_WITH_ISO8859X = 20
8945 XML_WITH_UNICODE = 21
8946 XML_WITH_REGEXP = 22
8947 XML_WITH_AUTOMATA = 23
8949 XML_WITH_SCHEMAS = 25
8950 XML_WITH_SCHEMATRON = 26
8951 XML_WITH_MODULES = 27
8953 XML_WITH_DEBUG_MEM = 29
8954 XML_WITH_DEBUG_RUN = 30
8958 XML_WITH_NONE = 99999
8960 # xmlElementContentOccur
8961 XML_ELEMENT_CONTENT_ONCE = 1
8962 XML_ELEMENT_CONTENT_OPT = 2
8963 XML_ELEMENT_CONTENT_MULT = 3
8964 XML_ELEMENT_CONTENT_PLUS = 4
8967 XPATH_EXPRESSION_OK = 0
8968 XPATH_NUMBER_ERROR = 1
8969 XPATH_UNFINISHED_LITERAL_ERROR = 2
8970 XPATH_START_LITERAL_ERROR = 3
8971 XPATH_VARIABLE_REF_ERROR = 4
8972 XPATH_UNDEF_VARIABLE_ERROR = 5
8973 XPATH_INVALID_PREDICATE_ERROR = 6
8974 XPATH_EXPR_ERROR = 7
8975 XPATH_UNCLOSED_ERROR = 8
8976 XPATH_UNKNOWN_FUNC_ERROR = 9
8977 XPATH_INVALID_OPERAND = 10
8978 XPATH_INVALID_TYPE = 11
8979 XPATH_INVALID_ARITY = 12
8980 XPATH_INVALID_CTXT_SIZE = 13
8981 XPATH_INVALID_CTXT_POSITION = 14
8982 XPATH_MEMORY_ERROR = 15
8983 XPTR_SYNTAX_ERROR = 16
8984 XPTR_RESOURCE_ERROR = 17
8985 XPTR_SUB_RESOURCE_ERROR = 18
8986 XPATH_UNDEF_PREFIX_ERROR = 19
8987 XPATH_ENCODING_ERROR = 20
8988 XPATH_INVALID_CHAR_ERROR = 21
8989 XPATH_INVALID_CTXT = 22
8990 XPATH_STACK_ERROR = 23
8991 XPATH_FORBID_VARIABLE_ERROR = 24
8994 XML_TEXTREADER_MODE_INITIAL = 0
8995 XML_TEXTREADER_MODE_INTERACTIVE = 1
8996 XML_TEXTREADER_MODE_ERROR = 2
8997 XML_TEXTREADER_MODE_EOF = 3
8998 XML_TEXTREADER_MODE_CLOSED = 4
8999 XML_TEXTREADER_MODE_READING = 5
9008 XML_CHAR_ENCODING_ERROR = -1
9009 XML_CHAR_ENCODING_NONE = 0
9010 XML_CHAR_ENCODING_UTF8 = 1
9011 XML_CHAR_ENCODING_UTF16LE = 2
9012 XML_CHAR_ENCODING_UTF16BE = 3
9013 XML_CHAR_ENCODING_UCS4LE = 4
9014 XML_CHAR_ENCODING_UCS4BE = 5
9015 XML_CHAR_ENCODING_EBCDIC = 6
9016 XML_CHAR_ENCODING_UCS4_2143 = 7
9017 XML_CHAR_ENCODING_UCS4_3412 = 8
9018 XML_CHAR_ENCODING_UCS2 = 9
9019 XML_CHAR_ENCODING_8859_1 = 10
9020 XML_CHAR_ENCODING_8859_2 = 11
9021 XML_CHAR_ENCODING_8859_3 = 12
9022 XML_CHAR_ENCODING_8859_4 = 13
9023 XML_CHAR_ENCODING_8859_5 = 14
9024 XML_CHAR_ENCODING_8859_6 = 15
9025 XML_CHAR_ENCODING_8859_7 = 16
9026 XML_CHAR_ENCODING_8859_8 = 17
9027 XML_CHAR_ENCODING_8859_9 = 18
9028 XML_CHAR_ENCODING_2022_JP = 19
9029 XML_CHAR_ENCODING_SHIFT_JIS = 20
9030 XML_CHAR_ENCODING_EUC_JP = 21
9031 XML_CHAR_ENCODING_ASCII = 22
9037 XML_FROM_NAMESPACE = 3
9045 XML_FROM_XINCLUDE = 11
9047 XML_FROM_XPOINTER = 13
9048 XML_FROM_REGEXP = 14
9049 XML_FROM_DATATYPE = 15
9050 XML_FROM_SCHEMASP = 16
9051 XML_FROM_SCHEMASV = 17
9052 XML_FROM_RELAXNGP = 18
9053 XML_FROM_RELAXNGV = 19
9054 XML_FROM_CATALOG = 20
9059 XML_FROM_WRITER = 25
9060 XML_FROM_MODULE = 26
9062 XML_FROM_SCHEMATRONV = 28
9063 XML_FROM_BUFFER = 29
9073 # xmlSchemaValidOption
9074 XML_SCHEMA_VAL_VC_I_CREATE = 1
9076 # xmlSchemaWhitespaceValueType
9077 XML_SCHEMA_WHITESPACE_UNKNOWN = 0
9078 XML_SCHEMA_WHITESPACE_PRESERVE = 1
9079 XML_SCHEMA_WHITESPACE_REPLACE = 2
9080 XML_SCHEMA_WHITESPACE_COLLAPSE = 3
9083 HTML_PARSE_RECOVER = 1
9084 HTML_PARSE_NODEFDTD = 4
9085 HTML_PARSE_NOERROR = 32
9086 HTML_PARSE_NOWARNING = 64
9087 HTML_PARSE_PEDANTIC = 128
9088 HTML_PARSE_NOBLANKS = 256
9089 HTML_PARSE_NONET = 2048
9090 HTML_PARSE_NOIMPLIED = 8192
9091 HTML_PARSE_COMPACT = 65536
9092 HTML_PARSE_IGNORE_ENC = 2097152
9094 # xmlRelaxNGValidErr
9096 XML_RELAXNG_ERR_MEMORY = 1
9097 XML_RELAXNG_ERR_TYPE = 2
9098 XML_RELAXNG_ERR_TYPEVAL = 3
9099 XML_RELAXNG_ERR_DUPID = 4
9100 XML_RELAXNG_ERR_TYPECMP = 5
9101 XML_RELAXNG_ERR_NOSTATE = 6
9102 XML_RELAXNG_ERR_NODEFINE = 7
9103 XML_RELAXNG_ERR_LISTEXTRA = 8
9104 XML_RELAXNG_ERR_LISTEMPTY = 9
9105 XML_RELAXNG_ERR_INTERNODATA = 10
9106 XML_RELAXNG_ERR_INTERSEQ = 11
9107 XML_RELAXNG_ERR_INTEREXTRA = 12
9108 XML_RELAXNG_ERR_ELEMNAME = 13
9109 XML_RELAXNG_ERR_ATTRNAME = 14
9110 XML_RELAXNG_ERR_ELEMNONS = 15
9111 XML_RELAXNG_ERR_ATTRNONS = 16
9112 XML_RELAXNG_ERR_ELEMWRONGNS = 17
9113 XML_RELAXNG_ERR_ATTRWRONGNS = 18
9114 XML_RELAXNG_ERR_ELEMEXTRANS = 19
9115 XML_RELAXNG_ERR_ATTREXTRANS = 20
9116 XML_RELAXNG_ERR_ELEMNOTEMPTY = 21
9117 XML_RELAXNG_ERR_NOELEM = 22
9118 XML_RELAXNG_ERR_NOTELEM = 23
9119 XML_RELAXNG_ERR_ATTRVALID = 24
9120 XML_RELAXNG_ERR_CONTENTVALID = 25
9121 XML_RELAXNG_ERR_EXTRACONTENT = 26
9122 XML_RELAXNG_ERR_INVALIDATTR = 27
9123 XML_RELAXNG_ERR_DATAELEM = 28
9124 XML_RELAXNG_ERR_VALELEM = 29
9125 XML_RELAXNG_ERR_LISTELEM = 30
9126 XML_RELAXNG_ERR_DATATYPE = 31
9127 XML_RELAXNG_ERR_VALUE = 32
9128 XML_RELAXNG_ERR_LIST = 33
9129 XML_RELAXNG_ERR_NOGRAMMAR = 34
9130 XML_RELAXNG_ERR_EXTRADATA = 35
9131 XML_RELAXNG_ERR_LACKDATA = 36
9132 XML_RELAXNG_ERR_INTERNAL = 37
9133 XML_RELAXNG_ERR_ELEMWRONG = 38
9134 XML_RELAXNG_ERR_TEXTWRONG = 39
9137 XML_CATA_ALLOW_NONE = 0
9138 XML_CATA_ALLOW_GLOBAL = 1
9139 XML_CATA_ALLOW_DOCUMENT = 2
9140 XML_CATA_ALLOW_ALL = 3
9143 XML_ATTRIBUTE_CDATA = 1
9144 XML_ATTRIBUTE_ID = 2
9145 XML_ATTRIBUTE_IDREF = 3
9146 XML_ATTRIBUTE_IDREFS = 4
9147 XML_ATTRIBUTE_ENTITY = 5
9148 XML_ATTRIBUTE_ENTITIES = 6
9149 XML_ATTRIBUTE_NMTOKEN = 7
9150 XML_ATTRIBUTE_NMTOKENS = 8
9151 XML_ATTRIBUTE_ENUMERATION = 9
9152 XML_ATTRIBUTE_NOTATION = 10
9154 # xmlSchematronValidOptions
9155 XML_SCHEMATRON_OUT_QUIET = 1
9156 XML_SCHEMATRON_OUT_TEXT = 2
9157 XML_SCHEMATRON_OUT_XML = 4
9158 XML_SCHEMATRON_OUT_ERROR = 8
9159 XML_SCHEMATRON_OUT_FILE = 256
9160 XML_SCHEMATRON_OUT_BUFFER = 512
9161 XML_SCHEMATRON_OUT_IO = 1024
9163 # xmlSchemaContentType
9164 XML_SCHEMA_CONTENT_UNKNOWN = 0
9165 XML_SCHEMA_CONTENT_EMPTY = 1
9166 XML_SCHEMA_CONTENT_ELEMENTS = 2
9167 XML_SCHEMA_CONTENT_MIXED = 3
9168 XML_SCHEMA_CONTENT_SIMPLE = 4
9169 XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS = 5
9170 XML_SCHEMA_CONTENT_BASIC = 6
9171 XML_SCHEMA_CONTENT_ANY = 7
9174 XML_SCHEMA_TYPE_BASIC = 1
9175 XML_SCHEMA_TYPE_ANY = 2
9176 XML_SCHEMA_TYPE_FACET = 3
9177 XML_SCHEMA_TYPE_SIMPLE = 4
9178 XML_SCHEMA_TYPE_COMPLEX = 5
9179 XML_SCHEMA_TYPE_SEQUENCE = 6
9180 XML_SCHEMA_TYPE_CHOICE = 7
9181 XML_SCHEMA_TYPE_ALL = 8
9182 XML_SCHEMA_TYPE_SIMPLE_CONTENT = 9
9183 XML_SCHEMA_TYPE_COMPLEX_CONTENT = 10
9184 XML_SCHEMA_TYPE_UR = 11
9185 XML_SCHEMA_TYPE_RESTRICTION = 12
9186 XML_SCHEMA_TYPE_EXTENSION = 13
9187 XML_SCHEMA_TYPE_ELEMENT = 14
9188 XML_SCHEMA_TYPE_ATTRIBUTE = 15
9189 XML_SCHEMA_TYPE_ATTRIBUTEGROUP = 16
9190 XML_SCHEMA_TYPE_GROUP = 17
9191 XML_SCHEMA_TYPE_NOTATION = 18
9192 XML_SCHEMA_TYPE_LIST = 19
9193 XML_SCHEMA_TYPE_UNION = 20
9194 XML_SCHEMA_TYPE_ANY_ATTRIBUTE = 21
9195 XML_SCHEMA_TYPE_IDC_UNIQUE = 22
9196 XML_SCHEMA_TYPE_IDC_KEY = 23
9197 XML_SCHEMA_TYPE_IDC_KEYREF = 24
9198 XML_SCHEMA_TYPE_PARTICLE = 25
9199 XML_SCHEMA_TYPE_ATTRIBUTE_USE = 26
9200 XML_SCHEMA_FACET_MININCLUSIVE = 1000
9201 XML_SCHEMA_FACET_MINEXCLUSIVE = 1001
9202 XML_SCHEMA_FACET_MAXINCLUSIVE = 1002
9203 XML_SCHEMA_FACET_MAXEXCLUSIVE = 1003
9204 XML_SCHEMA_FACET_TOTALDIGITS = 1004
9205 XML_SCHEMA_FACET_FRACTIONDIGITS = 1005
9206 XML_SCHEMA_FACET_PATTERN = 1006
9207 XML_SCHEMA_FACET_ENUMERATION = 1007
9208 XML_SCHEMA_FACET_WHITESPACE = 1008
9209 XML_SCHEMA_FACET_LENGTH = 1009
9210 XML_SCHEMA_FACET_MAXLENGTH = 1010
9211 XML_SCHEMA_FACET_MINLENGTH = 1011
9212 XML_SCHEMA_EXTRA_QNAMEREF = 2000
9213 XML_SCHEMA_EXTRA_ATTR_USE_PROHIB = 2001
9217 XML_MODULE_LOCAL = 2
9220 XML_PARSE_UNKNOWN = 0
9223 XML_PARSE_PUSH_DOM = 3
9224 XML_PARSE_PUSH_SAX = 4
9225 XML_PARSE_READER = 5
9229 XML_C14N_EXCLUSIVE_1_0 = 1
9233 XML_PARSE_RECOVER = 1
9235 XML_PARSE_DTDLOAD = 4
9236 XML_PARSE_DTDATTR = 8
9237 XML_PARSE_DTDVALID = 16
9238 XML_PARSE_NOERROR = 32
9239 XML_PARSE_NOWARNING = 64
9240 XML_PARSE_PEDANTIC = 128
9241 XML_PARSE_NOBLANKS = 256
9242 XML_PARSE_SAX1 = 512
9243 XML_PARSE_XINCLUDE = 1024
9244 XML_PARSE_NONET = 2048
9245 XML_PARSE_NODICT = 4096
9246 XML_PARSE_NSCLEAN = 8192
9247 XML_PARSE_NOCDATA = 16384
9248 XML_PARSE_NOXINCNODE = 32768
9249 XML_PARSE_COMPACT = 65536
9250 XML_PARSE_OLD10 = 131072
9251 XML_PARSE_NOBASEFIX = 262144
9252 XML_PARSE_HUGE = 524288
9253 XML_PARSE_OLDSAX = 1048576
9254 XML_PARSE_IGNORE_ENC = 2097152
9255 XML_PARSE_BIG_LINES = 4194304
9258 XML_ELEMENT_TYPE_UNDEFINED = 0
9259 XML_ELEMENT_TYPE_EMPTY = 1
9260 XML_ELEMENT_TYPE_ANY = 2
9261 XML_ELEMENT_TYPE_MIXED = 3
9262 XML_ELEMENT_TYPE_ELEMENT = 4
9265 XML_DOC_WELLFORMED = 1
9268 XML_DOC_DTDVALID = 8
9269 XML_DOC_XINCLUDE = 16
9270 XML_DOC_USERBUILT = 32
9271 XML_DOC_INTERNAL = 64
9276 XLINK_TYPE_SIMPLE = 1
9277 XLINK_TYPE_EXTENDED = 2
9278 XLINK_TYPE_EXTENDED_SET = 3
9280 # xmlXPathObjectType
9288 XPATH_LOCATIONSET = 7
9292 # xmlSchemaValidError
9293 XML_SCHEMAS_ERR_OK = 0
9294 XML_SCHEMAS_ERR_NOROOT = 1
9295 XML_SCHEMAS_ERR_UNDECLAREDELEM = 2
9296 XML_SCHEMAS_ERR_NOTTOPLEVEL = 3
9297 XML_SCHEMAS_ERR_MISSING = 4
9298 XML_SCHEMAS_ERR_WRONGELEM = 5
9299 XML_SCHEMAS_ERR_NOTYPE = 6
9300 XML_SCHEMAS_ERR_NOROLLBACK = 7
9301 XML_SCHEMAS_ERR_ISABSTRACT = 8
9302 XML_SCHEMAS_ERR_NOTEMPTY = 9
9303 XML_SCHEMAS_ERR_ELEMCONT = 10
9304 XML_SCHEMAS_ERR_HAVEDEFAULT = 11
9305 XML_SCHEMAS_ERR_NOTNILLABLE = 12
9306 XML_SCHEMAS_ERR_EXTRACONTENT = 13
9307 XML_SCHEMAS_ERR_INVALIDATTR = 14
9308 XML_SCHEMAS_ERR_INVALIDELEM = 15
9309 XML_SCHEMAS_ERR_NOTDETERMINIST = 16
9310 XML_SCHEMAS_ERR_CONSTRUCT = 17
9311 XML_SCHEMAS_ERR_INTERNAL = 18
9312 XML_SCHEMAS_ERR_NOTSIMPLE = 19
9313 XML_SCHEMAS_ERR_ATTRUNKNOWN = 20
9314 XML_SCHEMAS_ERR_ATTRINVALID = 21
9315 XML_SCHEMAS_ERR_VALUE = 22
9316 XML_SCHEMAS_ERR_FACET = 23
9317 XML_SCHEMAS_ERR_ = 24
9318 XML_SCHEMAS_ERR_XXX = 25