python/libxml2.py

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