Return to libxml2class.py CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2 / python

libxml2 2.9.1

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