| # |
| # Functions from module HTMLparser |
| # |
| |
| def htmlCreateMemoryParserCtxt(buffer, size): |
| """Create a parser context for an HTML in-memory document. """ |
| ret = libxml2mod.htmlCreateMemoryParserCtxt(buffer, size) |
| if ret is None:raise parserError('htmlCreateMemoryParserCtxt() failed') |
| return parserCtxt(_obj=ret) |
| |
| def htmlHandleOmittedElem(val): |
| """Set and return the previous value for handling HTML omitted |
| tags. """ |
| ret = libxml2mod.htmlHandleOmittedElem(val) |
| return ret |
| |
| def htmlIsScriptAttribute(name): |
| """Check if an attribute is of content type Script """ |
| ret = libxml2mod.htmlIsScriptAttribute(name) |
| return ret |
| |
| def htmlNewParserCtxt(): |
| """Allocate and initialize a new parser context. """ |
| ret = libxml2mod.htmlNewParserCtxt() |
| if ret is None:raise parserError('htmlNewParserCtxt() failed') |
| return parserCtxt(_obj=ret) |
| |
| def htmlParseDoc(cur, encoding): |
| """parse an HTML in-memory document and build a tree. """ |
| ret = libxml2mod.htmlParseDoc(cur, encoding) |
| if ret is None:raise parserError('htmlParseDoc() failed') |
| return xmlDoc(_obj=ret) |
| |
| def htmlParseFile(filename, encoding): |
| """parse an HTML file and build a tree. Automatic support for |
| ZLIB/Compress compressed document is provided by default if |
| found at compile-time. """ |
| ret = libxml2mod.htmlParseFile(filename, encoding) |
| if ret is None:raise parserError('htmlParseFile() failed') |
| return xmlDoc(_obj=ret) |
| |
| def htmlReadDoc(cur, URL, encoding, options): |
| """parse an XML in-memory document and build a tree. """ |
| ret = libxml2mod.htmlReadDoc(cur, URL, encoding, options) |
| if ret is None:raise treeError('htmlReadDoc() failed') |
| return xmlDoc(_obj=ret) |
| |
| def htmlReadFd(fd, URL, encoding, options): |
| """parse an XML from a file descriptor and build a tree. """ |
| ret = libxml2mod.htmlReadFd(fd, URL, encoding, options) |
| if ret is None:raise treeError('htmlReadFd() failed') |
| return xmlDoc(_obj=ret) |
| |
| def htmlReadFile(filename, encoding, options): |
| """parse an XML file from the filesystem or the network. """ |
| ret = libxml2mod.htmlReadFile(filename, encoding, options) |
| if ret is None:raise treeError('htmlReadFile() failed') |
| return xmlDoc(_obj=ret) |
| |
| def htmlReadMemory(buffer, size, URL, encoding, options): |
| """parse an XML in-memory document and build a tree. """ |
| ret = libxml2mod.htmlReadMemory(buffer, size, URL, encoding, options) |
| if ret is None:raise treeError('htmlReadMemory() failed') |
| return xmlDoc(_obj=ret) |
| |
| # |
| # Functions from module HTMLtree |
| # |
| |
| def htmlIsBooleanAttr(name): |
| """Determine if a given attribute is a boolean attribute. """ |
| ret = libxml2mod.htmlIsBooleanAttr(name) |
| return ret |
| |
| def htmlNewDoc(URI, ExternalID): |
| """Creates a new HTML document """ |
| ret = libxml2mod.htmlNewDoc(URI, ExternalID) |
| if ret is None:raise treeError('htmlNewDoc() failed') |
| return xmlDoc(_obj=ret) |
| |
| def htmlNewDocNoDtD(URI, ExternalID): |
| """Creates a new HTML document without a DTD node if @URI and |
| @ExternalID are None """ |
| ret = libxml2mod.htmlNewDocNoDtD(URI, ExternalID) |
| if ret is None:raise treeError('htmlNewDocNoDtD() failed') |
| return xmlDoc(_obj=ret) |
| |
| # |
| # Functions from module SAX2 |
| # |
| |
| def SAXDefaultVersion(version): |
| """Set the default version of SAX used globally by the |
| library. By default, during initialization the default is |
| set to 2. Note that it is generally a better coding style |
| to use xmlSAXVersion() to set up the version explicitly for |
| a given parsing context. """ |
| ret = libxml2mod.xmlSAXDefaultVersion(version) |
| return ret |
| |
| def defaultSAXHandlerInit(): |
| """Initialize the default SAX2 handler """ |
| libxml2mod.xmlDefaultSAXHandlerInit() |
| |
| def docbDefaultSAXHandlerInit(): |
| """Initialize the default SAX handler """ |
| libxml2mod.docbDefaultSAXHandlerInit() |
| |
| def htmlDefaultSAXHandlerInit(): |
| """Initialize the default SAX handler """ |
| libxml2mod.htmlDefaultSAXHandlerInit() |
| |
| # |
| # Functions from module catalog |
| # |
| |
| def catalogAdd(type, orig, replace): |
| """Add an entry in the catalog, it may overwrite existing but |
| different entries. If called before any other catalog |
| routine, allows to override the default shared catalog put |
| in place by xmlInitializeCatalog(); """ |
| ret = libxml2mod.xmlCatalogAdd(type, orig, replace) |
| return ret |
| |
| def catalogCleanup(): |
| """Free up all the memory associated with catalogs """ |
| libxml2mod.xmlCatalogCleanup() |
| |
| def catalogConvert(): |
| """Convert all the SGML catalog entries as XML ones """ |
| ret = libxml2mod.xmlCatalogConvert() |
| return ret |
| |
| def catalogDump(out): |
| """Dump all the global catalog content to the given file. """ |
| if out is not None: out.flush() |
| libxml2mod.xmlCatalogDump(out) |
| |
| def catalogGetPublic(pubID): |
| """Try to lookup the catalog reference associated to a public |
| ID DEPRECATED, use xmlCatalogResolvePublic() """ |
| ret = libxml2mod.xmlCatalogGetPublic(pubID) |
| return ret |
| |
| def catalogGetSystem(sysID): |
| """Try to lookup the catalog reference associated to a system |
| ID DEPRECATED, use xmlCatalogResolveSystem() """ |
| ret = libxml2mod.xmlCatalogGetSystem(sysID) |
| return ret |
| |
| def catalogRemove(value): |
| """Remove an entry from the catalog """ |
| ret = libxml2mod.xmlCatalogRemove(value) |
| return ret |
| |
| def catalogResolve(pubID, sysID): |
| """Do a complete resolution lookup of an External Identifier """ |
| ret = libxml2mod.xmlCatalogResolve(pubID, sysID) |
| return ret |
| |
| def catalogResolvePublic(pubID): |
| """Try to lookup the catalog reference associated to a public |
| ID """ |
| ret = libxml2mod.xmlCatalogResolvePublic(pubID) |
| return ret |
| |
| def catalogResolveSystem(sysID): |
| """Try to lookup the catalog resource for a system ID """ |
| ret = libxml2mod.xmlCatalogResolveSystem(sysID) |
| return ret |
| |
| def catalogResolveURI(URI): |
| """Do a complete resolution lookup of an URI """ |
| ret = libxml2mod.xmlCatalogResolveURI(URI) |
| return ret |
| |
| def catalogSetDebug(level): |
| """Used to set the debug level for catalog operation, 0 |
| disable debugging, 1 enable it """ |
| ret = libxml2mod.xmlCatalogSetDebug(level) |
| return ret |
| |
| def initializeCatalog(): |
| """Do the catalog initialization. this function is not thread |
| safe, catalog initialization should preferably be done once |
| at startup """ |
| libxml2mod.xmlInitializeCatalog() |
| |
| def loadACatalog(filename): |
| """Load the catalog and build the associated data structures. |
| This can be either an XML Catalog or an SGML Catalog It |
| will recurse in SGML CATALOG entries. On the other hand XML |
| Catalogs are not handled recursively. """ |
| ret = libxml2mod.xmlLoadACatalog(filename) |
| if ret is None:raise treeError('xmlLoadACatalog() failed') |
| return catalog(_obj=ret) |
| |
| def loadCatalog(filename): |
| """Load the catalog and makes its definitions effective for |
| the default external entity loader. It will recurse in SGML |
| CATALOG entries. this function is not thread safe, catalog |
| initialization should preferably be done once at startup """ |
| ret = libxml2mod.xmlLoadCatalog(filename) |
| return ret |
| |
| def loadCatalogs(pathss): |
| """Load the catalogs and makes their definitions effective for |
| the default external entity loader. this function is not |
| thread safe, catalog initialization should preferably be |
| done once at startup """ |
| libxml2mod.xmlLoadCatalogs(pathss) |
| |
| def loadSGMLSuperCatalog(filename): |
| """Load an SGML super catalog. It won't expand CATALOG or |
| DELEGATE references. This is only needed for manipulating |
| SGML Super Catalogs like adding and removing CATALOG or |
| DELEGATE entries. """ |
| ret = libxml2mod.xmlLoadSGMLSuperCatalog(filename) |
| if ret is None:raise treeError('xmlLoadSGMLSuperCatalog() failed') |
| return catalog(_obj=ret) |
| |
| def newCatalog(sgml): |
| """create a new Catalog. """ |
| ret = libxml2mod.xmlNewCatalog(sgml) |
| if ret is None:raise treeError('xmlNewCatalog() failed') |
| return catalog(_obj=ret) |
| |
| def parseCatalogFile(filename): |
| """parse an XML file and build a tree. It's like |
| xmlParseFile() except it bypass all catalog lookups. """ |
| ret = libxml2mod.xmlParseCatalogFile(filename) |
| if ret is None:raise parserError('xmlParseCatalogFile() failed') |
| return xmlDoc(_obj=ret) |
| |
| # |
| # Functions from module chvalid |
| # |
| |
| def isBaseChar(ch): |
| """This function is DEPRECATED. Use xmlIsBaseChar_ch or |
| xmlIsBaseCharQ instead """ |
| ret = libxml2mod.xmlIsBaseChar(ch) |
| return ret |
| |
| def isBlank(ch): |
| """This function is DEPRECATED. Use xmlIsBlank_ch or |
| xmlIsBlankQ instead """ |
| ret = libxml2mod.xmlIsBlank(ch) |
| return ret |
| |
| def isChar(ch): |
| """This function is DEPRECATED. Use xmlIsChar_ch or xmlIsCharQ |
| instead """ |
| ret = libxml2mod.xmlIsChar(ch) |
| return ret |
| |
| def isCombining(ch): |
| """This function is DEPRECATED. Use xmlIsCombiningQ instead """ |
| ret = libxml2mod.xmlIsCombining(ch) |
| return ret |
| |
| def isDigit(ch): |
| """This function is DEPRECATED. Use xmlIsDigit_ch or |
| xmlIsDigitQ instead """ |
| ret = libxml2mod.xmlIsDigit(ch) |
| return ret |
| |
| def isExtender(ch): |
| """This function is DEPRECATED. Use xmlIsExtender_ch or |
| xmlIsExtenderQ instead """ |
| ret = libxml2mod.xmlIsExtender(ch) |
| return ret |
| |
| def isIdeographic(ch): |
| """This function is DEPRECATED. Use xmlIsIdeographicQ instead """ |
| ret = libxml2mod.xmlIsIdeographic(ch) |
| return ret |
| |
| def isPubidChar(ch): |
| """This function is DEPRECATED. Use xmlIsPubidChar_ch or |
| xmlIsPubidCharQ instead """ |
| ret = libxml2mod.xmlIsPubidChar(ch) |
| return ret |
| |
| # |
| # Functions from module debugXML |
| # |
| |
| def boolToText(boolval): |
| """Convenient way to turn bool into text """ |
| ret = libxml2mod.xmlBoolToText(boolval) |
| return ret |
| |
| def debugDumpString(output, str): |
| """Dumps informations about the string, shorten it if necessary """ |
| if output is not None: output.flush() |
| libxml2mod.xmlDebugDumpString(output, str) |
| |
| def shellPrintXPathError(errorType, arg): |
| """Print the xpath error to libxml default error channel """ |
| libxml2mod.xmlShellPrintXPathError(errorType, arg) |
| |
| # |
| # Functions from module dict |
| # |
| |
| def dictCleanup(): |
| """Free the dictionary mutex. Do not call unless sure the |
| library is not in use anymore ! """ |
| libxml2mod.xmlDictCleanup() |
| |
| def initializeDict(): |
| """Do the dictionary mutex initialization. this function is |
| deprecated """ |
| ret = libxml2mod.xmlInitializeDict() |
| return ret |
| |
| # |
| # Functions from module encoding |
| # |
| |
| def addEncodingAlias(name, alias): |
| """Registers an alias @alias for an encoding named @name. |
| Existing alias will be overwritten. """ |
| ret = libxml2mod.xmlAddEncodingAlias(name, alias) |
| return ret |
| |
| def cleanupCharEncodingHandlers(): |
| """Cleanup the memory allocated for the char encoding support, |
| it unregisters all the encoding handlers and the aliases. """ |
| libxml2mod.xmlCleanupCharEncodingHandlers() |
| |
| def cleanupEncodingAliases(): |
| """Unregisters all aliases """ |
| libxml2mod.xmlCleanupEncodingAliases() |
| |
| def delEncodingAlias(alias): |
| """Unregisters an encoding alias @alias """ |
| ret = libxml2mod.xmlDelEncodingAlias(alias) |
| return ret |
| |
| def encodingAlias(alias): |
| """Lookup an encoding name for the given alias. """ |
| ret = libxml2mod.xmlGetEncodingAlias(alias) |
| return ret |
| |
| def initCharEncodingHandlers(): |
| """Initialize the char encoding support, it registers the |
| default encoding supported. NOTE: while public, this |
| function usually doesn't need to be called in normal |
| processing. """ |
| libxml2mod.xmlInitCharEncodingHandlers() |
| |
| # |
| # Functions from module entities |
| # |
| |
| def cleanupPredefinedEntities(): |
| """Cleanup up the predefined entities table. Deprecated call """ |
| libxml2mod.xmlCleanupPredefinedEntities() |
| |
| def initializePredefinedEntities(): |
| """Set up the predefined entities. Deprecated call """ |
| libxml2mod.xmlInitializePredefinedEntities() |
| |
| def predefinedEntity(name): |
| """Check whether this name is an predefined entity. """ |
| ret = libxml2mod.xmlGetPredefinedEntity(name) |
| if ret is None:raise treeError('xmlGetPredefinedEntity() failed') |
| return xmlEntity(_obj=ret) |
| |
| # |
| # Functions from module globals |
| # |
| |
| def cleanupGlobals(): |
| """Additional cleanup for multi-threading """ |
| libxml2mod.xmlCleanupGlobals() |
| |
| def initGlobals(): |
| """Additional initialisation for multi-threading """ |
| libxml2mod.xmlInitGlobals() |
| |
| def thrDefDefaultBufferSize(v): |
| ret = libxml2mod.xmlThrDefDefaultBufferSize(v) |
| return ret |
| |
| def thrDefDoValidityCheckingDefaultValue(v): |
| ret = libxml2mod.xmlThrDefDoValidityCheckingDefaultValue(v) |
| return ret |
| |
| def thrDefGetWarningsDefaultValue(v): |
| ret = libxml2mod.xmlThrDefGetWarningsDefaultValue(v) |
| return ret |
| |
| def thrDefIndentTreeOutput(v): |
| ret = libxml2mod.xmlThrDefIndentTreeOutput(v) |
| return ret |
| |
| def thrDefKeepBlanksDefaultValue(v): |
| ret = libxml2mod.xmlThrDefKeepBlanksDefaultValue(v) |
| return ret |
| |
| def thrDefLineNumbersDefaultValue(v): |
| ret = libxml2mod.xmlThrDefLineNumbersDefaultValue(v) |
| return ret |
| |
| def thrDefLoadExtDtdDefaultValue(v): |
| ret = libxml2mod.xmlThrDefLoadExtDtdDefaultValue(v) |
| return ret |
| |
| def thrDefParserDebugEntities(v): |
| ret = libxml2mod.xmlThrDefParserDebugEntities(v) |
| return ret |
| |
| def thrDefPedanticParserDefaultValue(v): |
| ret = libxml2mod.xmlThrDefPedanticParserDefaultValue(v) |
| return ret |
| |
| def thrDefSaveNoEmptyTags(v): |
| ret = libxml2mod.xmlThrDefSaveNoEmptyTags(v) |
| return ret |
| |
| def thrDefSubstituteEntitiesDefaultValue(v): |
| ret = libxml2mod.xmlThrDefSubstituteEntitiesDefaultValue(v) |
| return ret |
| |
| def thrDefTreeIndentString(v): |
| ret = libxml2mod.xmlThrDefTreeIndentString(v) |
| return ret |
| |
| # |
| # Functions from module nanoftp |
| # |
| |
| def nanoFTPCleanup(): |
| """Cleanup the FTP protocol layer. This cleanup proxy |
| informations. """ |
| libxml2mod.xmlNanoFTPCleanup() |
| |
| def nanoFTPInit(): |
| """Initialize the FTP protocol layer. Currently it just checks |
| for proxy informations, and get the hostname """ |
| libxml2mod.xmlNanoFTPInit() |
| |
| def nanoFTPProxy(host, port, user, passwd, type): |
| """Setup the FTP proxy informations. This can also be done by |
| using ftp_proxy ftp_proxy_user and ftp_proxy_password |
| environment variables. """ |
| libxml2mod.xmlNanoFTPProxy(host, port, user, passwd, type) |
| |
| def nanoFTPScanProxy(URL): |
| """(Re)Initialize the FTP Proxy context by parsing the URL and |
| finding the protocol host port it indicates. Should be like |
| ftp://myproxy/ or ftp://myproxy:3128/ A None URL cleans up |
| proxy informations. """ |
| libxml2mod.xmlNanoFTPScanProxy(URL) |
| |
| # |
| # Functions from module nanohttp |
| # |
| |
| def nanoHTTPCleanup(): |
| """Cleanup the HTTP protocol layer. """ |
| libxml2mod.xmlNanoHTTPCleanup() |
| |
| def nanoHTTPInit(): |
| """Initialize the HTTP protocol layer. Currently it just |
| checks for proxy informations """ |
| libxml2mod.xmlNanoHTTPInit() |
| |
| def nanoHTTPScanProxy(URL): |
| """(Re)Initialize the HTTP Proxy context by parsing the URL |
| and finding the protocol host port it indicates. Should be |
| like http://myproxy/ or http://myproxy:3128/ A None URL |
| cleans up proxy informations. """ |
| libxml2mod.xmlNanoHTTPScanProxy(URL) |
| |
| # |
| # Functions from module parser |
| # |
| |
| def createDocParserCtxt(cur): |
| """Creates a parser context for an XML in-memory document. """ |
| ret = libxml2mod.xmlCreateDocParserCtxt(cur) |
| if ret is None:raise parserError('xmlCreateDocParserCtxt() failed') |
| return parserCtxt(_obj=ret) |
| |
| def initParser(): |
| """Initialization function for the XML parser. This is not |
| reentrant. Call once before processing in case of use in |
| multithreaded programs. """ |
| libxml2mod.xmlInitParser() |
| |
| def keepBlanksDefault(val): |
| """Set and return the previous value for default blanks text |
| nodes support. The 1.x version of the parser used an |
| heuristic to try to detect ignorable white spaces. As a |
| result the SAX callback was generating |
| xmlSAX2IgnorableWhitespace() callbacks instead of |
| characters() one, and when using the DOM output text nodes |
| containing those blanks were not generated. The 2.x and |
| later version will switch to the XML standard way and |
| ignorableWhitespace() are only generated when running the |
| parser in validating mode and when the current element |
| doesn't allow CDATA or mixed content. This function is |
| provided as a way to force the standard behavior on 1.X |
| libs and to switch back to the old mode for compatibility |
| when running 1.X client code on 2.X . Upgrade of 1.X code |
| should be done by using xmlIsBlankNode() commodity function |
| to detect the "empty" nodes generated. This value also |
| affect autogeneration of indentation when saving code if |
| blanks sections are kept, indentation is not generated. """ |
| ret = libxml2mod.xmlKeepBlanksDefault(val) |
| return ret |
| |
| def lineNumbersDefault(val): |
| """Set and return the previous value for enabling line numbers |
| in elements contents. This may break on old application and |
| is turned off by default. """ |
| ret = libxml2mod.xmlLineNumbersDefault(val) |
| return ret |
| |
| def newParserCtxt(): |
| """Allocate and initialize a new parser context. """ |
| ret = libxml2mod.xmlNewParserCtxt() |
| if ret is None:raise parserError('xmlNewParserCtxt() failed') |
| return parserCtxt(_obj=ret) |
| |
| def parseDTD(ExternalID, SystemID): |
| """Load and parse an external subset. """ |
| ret = libxml2mod.xmlParseDTD(ExternalID, SystemID) |
| if ret is None:raise parserError('xmlParseDTD() failed') |
| return xmlDtd(_obj=ret) |
| |
| def parseDoc(cur): |
| """parse an XML in-memory document and build a tree. """ |
| ret = libxml2mod.xmlParseDoc(cur) |
| if ret is None:raise parserError('xmlParseDoc() failed') |
| return xmlDoc(_obj=ret) |
| |
| def parseEntity(filename): |
| """parse an XML external entity out of context and build a |
| tree. [78] extParsedEnt ::= TextDecl? content This |
| correspond to a "Well Balanced" chunk """ |
| ret = libxml2mod.xmlParseEntity(filename) |
| if ret is None:raise parserError('xmlParseEntity() failed') |
| return xmlDoc(_obj=ret) |
| |
| def parseFile(filename): |
| """parse an XML file and build a tree. Automatic support for |
| ZLIB/Compress compressed document is provided by default if |
| found at compile-time. """ |
| ret = libxml2mod.xmlParseFile(filename) |
| if ret is None:raise parserError('xmlParseFile() failed') |
| return xmlDoc(_obj=ret) |
| |
| def parseMemory(buffer, size): |
| """parse an XML in-memory block and build a tree. """ |
| ret = libxml2mod.xmlParseMemory(buffer, size) |
| if ret is None:raise parserError('xmlParseMemory() failed') |
| return xmlDoc(_obj=ret) |
| |
| def pedanticParserDefault(val): |
| """Set and return the previous value for enabling pedantic |
| warnings. """ |
| ret = libxml2mod.xmlPedanticParserDefault(val) |
| return ret |
| |
| def readDoc(cur, URL, encoding, options): |
| """parse an XML in-memory document and build a tree. """ |
| ret = libxml2mod.xmlReadDoc(cur, URL, encoding, options) |
| if ret is None:raise treeError('xmlReadDoc() failed') |
| return xmlDoc(_obj=ret) |
| |
| def readFd(fd, URL, encoding, options): |
| """parse an XML from a file descriptor and build a tree. NOTE |
| that the file descriptor will not be closed when the reader |
| is closed or reset. """ |
| ret = libxml2mod.xmlReadFd(fd, URL, encoding, options) |
| if ret is None:raise treeError('xmlReadFd() failed') |
| return xmlDoc(_obj=ret) |
| |
| def readFile(filename, encoding, options): |
| """parse an XML file from the filesystem or the network. """ |
| ret = libxml2mod.xmlReadFile(filename, encoding, options) |
| if ret is None:raise treeError('xmlReadFile() failed') |
| return xmlDoc(_obj=ret) |
| |
| def readMemory(buffer, size, URL, encoding, options): |
| """parse an XML in-memory document and build a tree. """ |
| ret = libxml2mod.xmlReadMemory(buffer, size, URL, encoding, options) |
| if ret is None:raise treeError('xmlReadMemory() failed') |
| return xmlDoc(_obj=ret) |
| |
| def recoverDoc(cur): |
| """parse an XML in-memory document and build a tree. In the |
| case the document is not Well Formed, a attempt to build a |
| tree is tried anyway """ |
| ret = libxml2mod.xmlRecoverDoc(cur) |
| if ret is None:raise treeError('xmlRecoverDoc() failed') |
| return xmlDoc(_obj=ret) |
| |
| def recoverFile(filename): |
| """parse an XML file and build a tree. Automatic support for |
| ZLIB/Compress compressed document is provided by default if |
| found at compile-time. In the case the document is not Well |
| Formed, it attempts to build a tree anyway """ |
| ret = libxml2mod.xmlRecoverFile(filename) |
| if ret is None:raise treeError('xmlRecoverFile() failed') |
| return xmlDoc(_obj=ret) |
| |
| def recoverMemory(buffer, size): |
| """parse an XML in-memory block and build a tree. In the case |
| the document is not Well Formed, an attempt to build a tree |
| is tried anyway """ |
| ret = libxml2mod.xmlRecoverMemory(buffer, size) |
| if ret is None:raise treeError('xmlRecoverMemory() failed') |
| return xmlDoc(_obj=ret) |
| |
| def substituteEntitiesDefault(val): |
| """Set and return the previous value for default entity |
| support. Initially the parser always keep entity references |
| instead of substituting entity values in the output. This |
| function has to be used to change the default parser |
| behavior SAX::substituteEntities() has to be used for |
| changing that on a file by file basis. """ |
| ret = libxml2mod.xmlSubstituteEntitiesDefault(val) |
| return ret |
| |
| # |
| # Functions from module parserInternals |
| # |
| |
| def checkLanguageID(lang): |
| """Checks that the value conforms to the LanguageID |
| production: NOTE: this is somewhat deprecated, those |
| productions were removed from the XML Second edition. [33] |
| LanguageID ::= Langcode ('-' Subcode)* [34] Langcode ::= |
| ISO639Code | IanaCode | UserCode [35] ISO639Code ::= |
| ([a-z] | [A-Z]) ([a-z] | [A-Z]) [36] IanaCode ::= ('i' | |
| 'I') '-' ([a-z] | [A-Z])+ [37] UserCode ::= ('x' | 'X') '-' |
| ([a-z] | [A-Z])+ [38] Subcode ::= ([a-z] | [A-Z])+ The |
| current REC reference the sucessors of RFC 1766, currently |
| 5646 http://www.rfc-editor.org/rfc/rfc5646.txt langtag |
| = language ["-" script] ["-" region] *("-" variant) *("-" |
| extension) ["-" privateuse] language = 2*3ALPHA |
| ; shortest ISO 639 code ["-" extlang] ; sometimes |
| followed by ; extended language subtags / 4ALPHA |
| ; or reserved for future use / 5*8ALPHA ; or |
| registered language subtag extlang = 3ALPHA |
| ; selected ISO 639 codes *2("-" 3ALPHA) ; permanently |
| reserved script = 4ALPHA ; ISO 15924 |
| code region = 2ALPHA ; ISO 3166-1 code |
| / 3DIGIT ; UN M.49 code variant = |
| 5*8alphanum ; registered variants / (DIGIT |
| 3alphanum) extension = singleton 1*("-" (2*8alphanum)) |
| ; Single alphanumerics ; "x" reserved for private use |
| singleton = DIGIT ; 0 - 9 / %x41-57 |
| ; A - W / %x59-5A ; Y - Z / %x61-77 |
| ; a - w / %x79-7A ; y - z it sounds right to |
| still allow Irregular i-xxx IANA and user codes too The |
| parser below doesn't try to cope with extension or |
| privateuse that could be added but that's not interoperable |
| anyway """ |
| ret = libxml2mod.xmlCheckLanguageID(lang) |
| return ret |
| |
| def copyChar(len, out, val): |
| """append the char value in the array """ |
| ret = libxml2mod.xmlCopyChar(len, out, val) |
| return ret |
| |
| def copyCharMultiByte(out, val): |
| """append the char value in the array """ |
| ret = libxml2mod.xmlCopyCharMultiByte(out, val) |
| return ret |
| |
| def createEntityParserCtxt(URL, ID, base): |
| """Create a parser context for an external entity Automatic |
| support for ZLIB/Compress compressed document is provided |
| by default if found at compile-time. """ |
| ret = libxml2mod.xmlCreateEntityParserCtxt(URL, ID, base) |
| if ret is None:raise parserError('xmlCreateEntityParserCtxt() failed') |
| return parserCtxt(_obj=ret) |
| |
| def createFileParserCtxt(filename): |
| """Create a parser context for a file content. Automatic |
| support for ZLIB/Compress compressed document is provided |
| by default if found at compile-time. """ |
| ret = libxml2mod.xmlCreateFileParserCtxt(filename) |
| if ret is None:raise parserError('xmlCreateFileParserCtxt() failed') |
| return parserCtxt(_obj=ret) |
| |
| def createMemoryParserCtxt(buffer, size): |
| """Create a parser context for an XML in-memory document. """ |
| ret = libxml2mod.xmlCreateMemoryParserCtxt(buffer, size) |
| if ret is None:raise parserError('xmlCreateMemoryParserCtxt() failed') |
| return parserCtxt(_obj=ret) |
| |
| def createURLParserCtxt(filename, options): |
| """Create a parser context for a file or URL content. |
| Automatic support for ZLIB/Compress compressed document is |
| provided by default if found at compile-time and for file |
| accesses """ |
| ret = libxml2mod.xmlCreateURLParserCtxt(filename, options) |
| if ret is None:raise parserError('xmlCreateURLParserCtxt() failed') |
| return parserCtxt(_obj=ret) |
| |
| def htmlCreateFileParserCtxt(filename, encoding): |
| """Create a parser context for a file content. Automatic |
| support for ZLIB/Compress compressed document is provided |
| by default if found at compile-time. """ |
| ret = libxml2mod.htmlCreateFileParserCtxt(filename, encoding) |
| if ret is None:raise parserError('htmlCreateFileParserCtxt() failed') |
| return parserCtxt(_obj=ret) |
| |
| def htmlInitAutoClose(): |
| """Initialize the htmlStartCloseIndex for fast lookup of |
| closing tags names. This is not reentrant. Call |
| xmlInitParser() once before processing in case of use in |
| multithreaded programs. """ |
| libxml2mod.htmlInitAutoClose() |
| |
| def isLetter(c): |
| """Check whether the character is allowed by the production |
| [84] Letter ::= BaseChar | Ideographic """ |
| ret = libxml2mod.xmlIsLetter(c) |
| return ret |
| |
| def namePop(ctxt): |
| """Pops the top element name from the name stack """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.namePop(ctxt__o) |
| return ret |
| |
| def namePush(ctxt, value): |
| """Pushes a new element name on top of the name stack """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.namePush(ctxt__o, value) |
| return ret |
| |
| def nodePop(ctxt): |
| """Pops the top element node from the node stack """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.nodePop(ctxt__o) |
| if ret is None:raise treeError('nodePop() failed') |
| return xmlNode(_obj=ret) |
| |
| def nodePush(ctxt, value): |
| """Pushes a new element node on top of the node stack """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if value is None: value__o = None |
| else: value__o = value._o |
| ret = libxml2mod.nodePush(ctxt__o, value__o) |
| return ret |
| |
| # |
| # Functions from module python |
| # |
| |
| def SAXParseFile(SAX, URI, recover): |
| """Interface to parse an XML file or resource pointed by an |
| URI to build an event flow to the SAX object """ |
| libxml2mod.xmlSAXParseFile(SAX, URI, recover) |
| |
| def createInputBuffer(file, encoding): |
| """Create a libxml2 input buffer from a Python file """ |
| ret = libxml2mod.xmlCreateInputBuffer(file, encoding) |
| if ret is None:raise treeError('xmlCreateInputBuffer() failed') |
| return inputBuffer(_obj=ret) |
| |
| def createOutputBuffer(file, encoding): |
| """Create a libxml2 output buffer from a Python file """ |
| ret = libxml2mod.xmlCreateOutputBuffer(file, encoding) |
| if ret is None:raise treeError('xmlCreateOutputBuffer() failed') |
| return outputBuffer(_obj=ret) |
| |
| def createPushParser(SAX, chunk, size, URI): |
| """Create a progressive XML parser context to build either an |
| event flow if the SAX object is not None, or a DOM tree |
| otherwise. """ |
| ret = libxml2mod.xmlCreatePushParser(SAX, chunk, size, URI) |
| if ret is None:raise parserError('xmlCreatePushParser() failed') |
| return parserCtxt(_obj=ret) |
| |
| def debugMemory(activate): |
| """Switch on the generation of line number for elements nodes. |
| Also returns the number of bytes allocated and not freed by |
| libxml2 since memory debugging was switched on. """ |
| ret = libxml2mod.xmlDebugMemory(activate) |
| return ret |
| |
| def dumpMemory(): |
| """dump the memory allocated in the file .memdump """ |
| libxml2mod.xmlDumpMemory() |
| |
| def htmlCreatePushParser(SAX, chunk, size, URI): |
| """Create a progressive HTML parser context to build either an |
| event flow if the SAX object is not None, or a DOM tree |
| otherwise. """ |
| ret = libxml2mod.htmlCreatePushParser(SAX, chunk, size, URI) |
| if ret is None:raise parserError('htmlCreatePushParser() failed') |
| return parserCtxt(_obj=ret) |
| |
| def htmlSAXParseFile(SAX, URI, encoding): |
| """Interface to parse an HTML file or resource pointed by an |
| URI to build an event flow to the SAX object """ |
| libxml2mod.htmlSAXParseFile(SAX, URI, encoding) |
| |
| def memoryUsed(): |
| """Returns the total amount of memory allocated by libxml2 """ |
| ret = libxml2mod.xmlMemoryUsed() |
| return ret |
| |
| def newNode(name): |
| """Create a new Node """ |
| ret = libxml2mod.xmlNewNode(name) |
| if ret is None:raise treeError('xmlNewNode() failed') |
| return xmlNode(_obj=ret) |
| |
| def pythonCleanupParser(): |
| """Cleanup function for the XML library. It tries to reclaim |
| all parsing related global memory allocated for the library |
| processing. It doesn't deallocate any document related |
| memory. Calling this function should not prevent reusing |
| the library but one should call xmlCleanupParser() only |
| when the process has finished using the library or XML |
| document built with it. """ |
| libxml2mod.xmlPythonCleanupParser() |
| |
| def setEntityLoader(resolver): |
| """Set the entity resolver as a python function """ |
| ret = libxml2mod.xmlSetEntityLoader(resolver) |
| return ret |
| |
| # |
| # Functions from module relaxng |
| # |
| |
| def relaxNGCleanupTypes(): |
| """Cleanup the default Schemas type library associated to |
| RelaxNG """ |
| libxml2mod.xmlRelaxNGCleanupTypes() |
| |
| def relaxNGInitTypes(): |
| """Initilize the default type libraries. """ |
| ret = libxml2mod.xmlRelaxNGInitTypes() |
| return ret |
| |
| def relaxNGNewMemParserCtxt(buffer, size): |
| """Create an XML RelaxNGs parse context for that memory buffer |
| expected to contain an XML RelaxNGs file. """ |
| ret = libxml2mod.xmlRelaxNGNewMemParserCtxt(buffer, size) |
| if ret is None:raise parserError('xmlRelaxNGNewMemParserCtxt() failed') |
| return relaxNgParserCtxt(_obj=ret) |
| |
| def relaxNGNewParserCtxt(URL): |
| """Create an XML RelaxNGs parse context for that file/resource |
| expected to contain an XML RelaxNGs file. """ |
| ret = libxml2mod.xmlRelaxNGNewParserCtxt(URL) |
| if ret is None:raise parserError('xmlRelaxNGNewParserCtxt() failed') |
| return relaxNgParserCtxt(_obj=ret) |
| |
| # |
| # Functions from module tree |
| # |
| |
| def buildQName(ncname, prefix, memory, len): |
| """Builds the QName @prefix:@ncname in @memory if there is |
| enough space and prefix is not None nor empty, otherwise |
| allocate a new string. If prefix is None or empty it |
| returns ncname. """ |
| ret = libxml2mod.xmlBuildQName(ncname, prefix, memory, len) |
| return ret |
| |
| def compressMode(): |
| """get the default compression mode used, ZLIB based. """ |
| ret = libxml2mod.xmlGetCompressMode() |
| return ret |
| |
| def isXHTML(systemID, publicID): |
| """Try to find if the document correspond to an XHTML DTD """ |
| ret = libxml2mod.xmlIsXHTML(systemID, publicID) |
| return ret |
| |
| def newComment(content): |
| """Creation of a new node containing a comment. """ |
| ret = libxml2mod.xmlNewComment(content) |
| if ret is None:raise treeError('xmlNewComment() failed') |
| return xmlNode(_obj=ret) |
| |
| def newDoc(version): |
| """Creates a new XML document """ |
| ret = libxml2mod.xmlNewDoc(version) |
| if ret is None:raise treeError('xmlNewDoc() failed') |
| return xmlDoc(_obj=ret) |
| |
| def newPI(name, content): |
| """Creation of a processing instruction element. Use |
| xmlDocNewPI preferably to get string interning """ |
| ret = libxml2mod.xmlNewPI(name, content) |
| if ret is None:raise treeError('xmlNewPI() failed') |
| return xmlNode(_obj=ret) |
| |
| def newText(content): |
| """Creation of a new text node. """ |
| ret = libxml2mod.xmlNewText(content) |
| if ret is None:raise treeError('xmlNewText() failed') |
| return xmlNode(_obj=ret) |
| |
| def newTextLen(content, len): |
| """Creation of a new text node with an extra parameter for the |
| content's length """ |
| ret = libxml2mod.xmlNewTextLen(content, len) |
| if ret is None:raise treeError('xmlNewTextLen() failed') |
| return xmlNode(_obj=ret) |
| |
| def setCompressMode(mode): |
| """set the default compression mode used, ZLIB based Correct |
| values: 0 (uncompressed) to 9 (max compression) """ |
| libxml2mod.xmlSetCompressMode(mode) |
| |
| def validateNCName(value, space): |
| """Check that a value conforms to the lexical space of NCName """ |
| ret = libxml2mod.xmlValidateNCName(value, space) |
| return ret |
| |
| def validateNMToken(value, space): |
| """Check that a value conforms to the lexical space of NMToken """ |
| ret = libxml2mod.xmlValidateNMToken(value, space) |
| return ret |
| |
| def validateName(value, space): |
| """Check that a value conforms to the lexical space of Name """ |
| ret = libxml2mod.xmlValidateName(value, space) |
| return ret |
| |
| def validateQName(value, space): |
| """Check that a value conforms to the lexical space of QName """ |
| ret = libxml2mod.xmlValidateQName(value, space) |
| return ret |
| |
| # |
| # Functions from module uri |
| # |
| |
| def URIEscape(str): |
| """Escaping routine, does not do validity checks ! It will try |
| to escape the chars needing this, but this is heuristic |
| based it's impossible to be sure. """ |
| ret = libxml2mod.xmlURIEscape(str) |
| return ret |
| |
| def URIEscapeStr(str, list): |
| """This routine escapes a string to hex, ignoring reserved |
| characters (a-z) and the characters in the exception list. """ |
| ret = libxml2mod.xmlURIEscapeStr(str, list) |
| return ret |
| |
| def URIUnescapeString(str, len, target): |
| """Unescaping routine, but does not check that the string is |
| an URI. The output is a direct unsigned char translation of |
| %XX values (no encoding) Note that the length of the result |
| can only be smaller or same size as the input string. """ |
| ret = libxml2mod.xmlURIUnescapeString(str, len, target) |
| return ret |
| |
| def buildRelativeURI(URI, base): |
| """Expresses the URI of the reference in terms relative to the |
| base. Some examples of this operation include: base = |
| "http://site1.com/docs/book1.html" URI input |
| URI returned docs/pic1.gif pic1.gif |
| docs/img/pic1.gif img/pic1.gif img/pic1.gif |
| ../img/pic1.gif http://site1.com/docs/pic1.gif pic1.gif |
| http://site2.com/docs/pic1.gif |
| http://site2.com/docs/pic1.gif base = "docs/book1.html" |
| URI input URI returned docs/pic1.gif |
| pic1.gif docs/img/pic1.gif img/pic1.gif |
| img/pic1.gif ../img/pic1.gif |
| http://site1.com/docs/pic1.gif |
| http://site1.com/docs/pic1.gif Note: if the URI reference |
| is really wierd or complicated, it may be worthwhile to |
| first convert it into a "nice" one by calling xmlBuildURI |
| (using 'base') before calling this routine, since this |
| routine (for reasonable efficiency) assumes URI has already |
| been through some validation. """ |
| ret = libxml2mod.xmlBuildRelativeURI(URI, base) |
| return ret |
| |
| def buildURI(URI, base): |
| """Computes he final URI of the reference done by checking |
| that the given URI is valid, and building the final URI |
| using the base URI. This is processed according to section |
| 5.2 of the RFC 2396 5.2. Resolving Relative References to |
| Absolute Form """ |
| ret = libxml2mod.xmlBuildURI(URI, base) |
| return ret |
| |
| def canonicPath(path): |
| """Constructs a canonic path from the specified path. """ |
| ret = libxml2mod.xmlCanonicPath(path) |
| return ret |
| |
| def createURI(): |
| """Simply creates an empty xmlURI """ |
| ret = libxml2mod.xmlCreateURI() |
| if ret is None:raise uriError('xmlCreateURI() failed') |
| return URI(_obj=ret) |
| |
| def normalizeURIPath(path): |
| """Applies the 5 normalization steps to a path string--that |
| is, RFC 2396 Section 5.2, steps 6.c through 6.g. |
| Normalization occurs directly on the string, no new |
| allocation is done """ |
| ret = libxml2mod.xmlNormalizeURIPath(path) |
| return ret |
| |
| def parseURI(str): |
| """Parse an URI based on RFC 3986 URI-reference = [ |
| absoluteURI | relativeURI ] [ "#" fragment ] """ |
| ret = libxml2mod.xmlParseURI(str) |
| if ret is None:raise uriError('xmlParseURI() failed') |
| return URI(_obj=ret) |
| |
| def parseURIRaw(str, raw): |
| """Parse an URI but allows to keep intact the original |
| fragments. URI-reference = URI / relative-ref """ |
| ret = libxml2mod.xmlParseURIRaw(str, raw) |
| if ret is None:raise uriError('xmlParseURIRaw() failed') |
| return URI(_obj=ret) |
| |
| def pathToURI(path): |
| """Constructs an URI expressing the existing path """ |
| ret = libxml2mod.xmlPathToURI(path) |
| return ret |
| |
| # |
| # Functions from module valid |
| # |
| |
| def newValidCtxt(): |
| """Allocate a validation context structure. """ |
| ret = libxml2mod.xmlNewValidCtxt() |
| if ret is None:raise treeError('xmlNewValidCtxt() failed') |
| return ValidCtxt(_obj=ret) |
| |
| def validateNameValue(value): |
| """Validate that the given value match Name production """ |
| ret = libxml2mod.xmlValidateNameValue(value) |
| return ret |
| |
| def validateNamesValue(value): |
| """Validate that the given value match Names production """ |
| ret = libxml2mod.xmlValidateNamesValue(value) |
| return ret |
| |
| def validateNmtokenValue(value): |
| """Validate that the given value match Nmtoken production [ |
| VC: Name Token ] """ |
| ret = libxml2mod.xmlValidateNmtokenValue(value) |
| return ret |
| |
| def validateNmtokensValue(value): |
| """Validate that the given value match Nmtokens production [ |
| VC: Name Token ] """ |
| ret = libxml2mod.xmlValidateNmtokensValue(value) |
| return ret |
| |
| # |
| # Functions from module xmlIO |
| # |
| |
| def checkFilename(path): |
| """function checks to see if @path is a valid source (file, |
| socket...) for XML. if stat is not available on the target |
| machine, """ |
| ret = libxml2mod.xmlCheckFilename(path) |
| return ret |
| |
| def cleanupInputCallbacks(): |
| """clears the entire input callback table. this includes the |
| compiled-in I/O. """ |
| libxml2mod.xmlCleanupInputCallbacks() |
| |
| def cleanupOutputCallbacks(): |
| """clears the entire output callback table. this includes the |
| compiled-in I/O callbacks. """ |
| libxml2mod.xmlCleanupOutputCallbacks() |
| |
| def fileMatch(filename): |
| """input from FILE * """ |
| ret = libxml2mod.xmlFileMatch(filename) |
| return ret |
| |
| def iOFTPMatch(filename): |
| """check if the URI matches an FTP one """ |
| ret = libxml2mod.xmlIOFTPMatch(filename) |
| return ret |
| |
| def iOHTTPMatch(filename): |
| """check if the URI matches an HTTP one """ |
| ret = libxml2mod.xmlIOHTTPMatch(filename) |
| return ret |
| |
| def normalizeWindowsPath(path): |
| """This function is obsolete. Please see xmlURIFromPath in |
| uri.c for a better solution. """ |
| ret = libxml2mod.xmlNormalizeWindowsPath(path) |
| return ret |
| |
| def parserGetDirectory(filename): |
| """lookup the directory for that file """ |
| ret = libxml2mod.xmlParserGetDirectory(filename) |
| return ret |
| |
| def registerDefaultInputCallbacks(): |
| """Registers the default compiled-in I/O handlers. """ |
| libxml2mod.xmlRegisterDefaultInputCallbacks() |
| |
| def registerDefaultOutputCallbacks(): |
| """Registers the default compiled-in I/O handlers. """ |
| libxml2mod.xmlRegisterDefaultOutputCallbacks() |
| |
| def registerHTTPPostCallbacks(): |
| """By default, libxml submits HTTP output requests using the |
| "PUT" method. Calling this method changes the HTTP output |
| method to use the "POST" method instead. """ |
| libxml2mod.xmlRegisterHTTPPostCallbacks() |
| |
| # |
| # Functions from module xmlerror |
| # |
| |
| def lastError(): |
| """Get the last global error registered. This is per thread if |
| compiled with thread support. """ |
| ret = libxml2mod.xmlGetLastError() |
| if ret is None:raise treeError('xmlGetLastError() failed') |
| return Error(_obj=ret) |
| |
| def resetLastError(): |
| """Cleanup the last global error registered. For parsing error |
| this does not change the well-formedness result. """ |
| libxml2mod.xmlResetLastError() |
| |
| # |
| # Functions from module xmlreader |
| # |
| |
| def newTextReaderFilename(URI): |
| """Create an xmlTextReader structure fed with the resource at |
| @URI """ |
| ret = libxml2mod.xmlNewTextReaderFilename(URI) |
| if ret is None:raise treeError('xmlNewTextReaderFilename() failed') |
| return xmlTextReader(_obj=ret) |
| |
| def readerForDoc(cur, URL, encoding, options): |
| """Create an xmltextReader for an XML in-memory document. The |
| parsing flags @options are a combination of xmlParserOption. """ |
| ret = libxml2mod.xmlReaderForDoc(cur, URL, encoding, options) |
| if ret is None:raise treeError('xmlReaderForDoc() failed') |
| return xmlTextReader(_obj=ret) |
| |
| def readerForFd(fd, URL, encoding, options): |
| """Create an xmltextReader for an XML from a file descriptor. |
| The parsing flags @options are a combination of |
| xmlParserOption. NOTE that the file descriptor will not be |
| closed when the reader is closed or reset. """ |
| ret = libxml2mod.xmlReaderForFd(fd, URL, encoding, options) |
| if ret is None:raise treeError('xmlReaderForFd() failed') |
| return xmlTextReader(_obj=ret) |
| |
| def readerForFile(filename, encoding, options): |
| """parse an XML file from the filesystem or the network. The |
| parsing flags @options are a combination of xmlParserOption. """ |
| ret = libxml2mod.xmlReaderForFile(filename, encoding, options) |
| if ret is None:raise treeError('xmlReaderForFile() failed') |
| return xmlTextReader(_obj=ret) |
| |
| def readerForMemory(buffer, size, URL, encoding, options): |
| """Create an xmltextReader for an XML in-memory document. The |
| parsing flags @options are a combination of xmlParserOption. """ |
| ret = libxml2mod.xmlReaderForMemory(buffer, size, URL, encoding, options) |
| if ret is None:raise treeError('xmlReaderForMemory() failed') |
| return xmlTextReader(_obj=ret) |
| |
| # |
| # Functions from module xmlregexp |
| # |
| |
| def regexpCompile(regexp): |
| """Parses a regular expression conforming to XML Schemas Part |
| 2 Datatype Appendix F and builds an automata suitable for |
| testing strings against that regular expression """ |
| ret = libxml2mod.xmlRegexpCompile(regexp) |
| if ret is None:raise treeError('xmlRegexpCompile() failed') |
| return xmlReg(_obj=ret) |
| |
| # |
| # Functions from module xmlschemas |
| # |
| |
| def schemaNewMemParserCtxt(buffer, size): |
| """Create an XML Schemas parse context for that memory buffer |
| expected to contain an XML Schemas file. """ |
| ret = libxml2mod.xmlSchemaNewMemParserCtxt(buffer, size) |
| if ret is None:raise parserError('xmlSchemaNewMemParserCtxt() failed') |
| return SchemaParserCtxt(_obj=ret) |
| |
| def schemaNewParserCtxt(URL): |
| """Create an XML Schemas parse context for that file/resource |
| expected to contain an XML Schemas file. """ |
| ret = libxml2mod.xmlSchemaNewParserCtxt(URL) |
| if ret is None:raise parserError('xmlSchemaNewParserCtxt() failed') |
| return SchemaParserCtxt(_obj=ret) |
| |
| # |
| # Functions from module xmlschemastypes |
| # |
| |
| def schemaCleanupTypes(): |
| """Cleanup the default XML Schemas type library """ |
| libxml2mod.xmlSchemaCleanupTypes() |
| |
| def schemaCollapseString(value): |
| """Removes and normalize white spaces in the string """ |
| ret = libxml2mod.xmlSchemaCollapseString(value) |
| return ret |
| |
| def schemaInitTypes(): |
| """Initialize the default XML Schemas type library """ |
| libxml2mod.xmlSchemaInitTypes() |
| |
| def schemaWhiteSpaceReplace(value): |
| """Replaces 0xd, 0x9 and 0xa with a space. """ |
| ret = libxml2mod.xmlSchemaWhiteSpaceReplace(value) |
| return ret |
| |
| # |
| # Functions from module xmlstring |
| # |
| |
| def UTF8Charcmp(utf1, utf2): |
| """compares the two UCS4 values """ |
| ret = libxml2mod.xmlUTF8Charcmp(utf1, utf2) |
| return ret |
| |
| def UTF8Size(utf): |
| """calculates the internal size of a UTF8 character """ |
| ret = libxml2mod.xmlUTF8Size(utf) |
| return ret |
| |
| def UTF8Strlen(utf): |
| """compute the length of an UTF8 string, it doesn't do a full |
| UTF8 checking of the content of the string. """ |
| ret = libxml2mod.xmlUTF8Strlen(utf) |
| return ret |
| |
| def UTF8Strloc(utf, utfchar): |
| """a function to provide the relative location of a UTF8 char """ |
| ret = libxml2mod.xmlUTF8Strloc(utf, utfchar) |
| return ret |
| |
| def UTF8Strndup(utf, len): |
| """a strndup for array of UTF8's """ |
| ret = libxml2mod.xmlUTF8Strndup(utf, len) |
| return ret |
| |
| def UTF8Strpos(utf, pos): |
| """a function to provide the equivalent of fetching a |
| character from a string array """ |
| ret = libxml2mod.xmlUTF8Strpos(utf, pos) |
| return ret |
| |
| def UTF8Strsize(utf, len): |
| """storage size of an UTF8 string the behaviour is not |
| garanteed if the input string is not UTF-8 """ |
| ret = libxml2mod.xmlUTF8Strsize(utf, len) |
| return ret |
| |
| def UTF8Strsub(utf, start, len): |
| """Create a substring from a given UTF-8 string Note: |
| positions are given in units of UTF-8 chars """ |
| ret = libxml2mod.xmlUTF8Strsub(utf, start, len) |
| return ret |
| |
| def checkUTF8(utf): |
| """Checks @utf for being valid UTF-8. @utf is assumed to be |
| null-terminated. This function is not super-strict, as it |
| will allow longer UTF-8 sequences than necessary. Note that |
| Java is capable of producing these sequences if provoked. |
| Also note, this routine checks for the 4-byte maximum size, |
| but does not check for 0x10ffff maximum value. """ |
| ret = libxml2mod.xmlCheckUTF8(utf) |
| return ret |
| |
| # |
| # Functions from module xmlunicode |
| # |
| |
| def uCSIsAegeanNumbers(code): |
| """Check whether the character is part of AegeanNumbers UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsAegeanNumbers(code) |
| return ret |
| |
| def uCSIsAlphabeticPresentationForms(code): |
| """Check whether the character is part of |
| AlphabeticPresentationForms UCS Block """ |
| ret = libxml2mod.xmlUCSIsAlphabeticPresentationForms(code) |
| return ret |
| |
| def uCSIsArabic(code): |
| """Check whether the character is part of Arabic UCS Block """ |
| ret = libxml2mod.xmlUCSIsArabic(code) |
| return ret |
| |
| def uCSIsArabicPresentationFormsA(code): |
| """Check whether the character is part of |
| ArabicPresentationForms-A UCS Block """ |
| ret = libxml2mod.xmlUCSIsArabicPresentationFormsA(code) |
| return ret |
| |
| def uCSIsArabicPresentationFormsB(code): |
| """Check whether the character is part of |
| ArabicPresentationForms-B UCS Block """ |
| ret = libxml2mod.xmlUCSIsArabicPresentationFormsB(code) |
| return ret |
| |
| def uCSIsArmenian(code): |
| """Check whether the character is part of Armenian UCS Block """ |
| ret = libxml2mod.xmlUCSIsArmenian(code) |
| return ret |
| |
| def uCSIsArrows(code): |
| """Check whether the character is part of Arrows UCS Block """ |
| ret = libxml2mod.xmlUCSIsArrows(code) |
| return ret |
| |
| def uCSIsBasicLatin(code): |
| """Check whether the character is part of BasicLatin UCS Block """ |
| ret = libxml2mod.xmlUCSIsBasicLatin(code) |
| return ret |
| |
| def uCSIsBengali(code): |
| """Check whether the character is part of Bengali UCS Block """ |
| ret = libxml2mod.xmlUCSIsBengali(code) |
| return ret |
| |
| def uCSIsBlock(code, block): |
| """Check whether the character is part of the UCS Block """ |
| ret = libxml2mod.xmlUCSIsBlock(code, block) |
| return ret |
| |
| def uCSIsBlockElements(code): |
| """Check whether the character is part of BlockElements UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsBlockElements(code) |
| return ret |
| |
| def uCSIsBopomofo(code): |
| """Check whether the character is part of Bopomofo UCS Block """ |
| ret = libxml2mod.xmlUCSIsBopomofo(code) |
| return ret |
| |
| def uCSIsBopomofoExtended(code): |
| """Check whether the character is part of BopomofoExtended UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsBopomofoExtended(code) |
| return ret |
| |
| def uCSIsBoxDrawing(code): |
| """Check whether the character is part of BoxDrawing UCS Block """ |
| ret = libxml2mod.xmlUCSIsBoxDrawing(code) |
| return ret |
| |
| def uCSIsBraillePatterns(code): |
| """Check whether the character is part of BraillePatterns UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsBraillePatterns(code) |
| return ret |
| |
| def uCSIsBuhid(code): |
| """Check whether the character is part of Buhid UCS Block """ |
| ret = libxml2mod.xmlUCSIsBuhid(code) |
| return ret |
| |
| def uCSIsByzantineMusicalSymbols(code): |
| """Check whether the character is part of |
| ByzantineMusicalSymbols UCS Block """ |
| ret = libxml2mod.xmlUCSIsByzantineMusicalSymbols(code) |
| return ret |
| |
| def uCSIsCJKCompatibility(code): |
| """Check whether the character is part of CJKCompatibility UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsCJKCompatibility(code) |
| return ret |
| |
| def uCSIsCJKCompatibilityForms(code): |
| """Check whether the character is part of |
| CJKCompatibilityForms UCS Block """ |
| ret = libxml2mod.xmlUCSIsCJKCompatibilityForms(code) |
| return ret |
| |
| def uCSIsCJKCompatibilityIdeographs(code): |
| """Check whether the character is part of |
| CJKCompatibilityIdeographs UCS Block """ |
| ret = libxml2mod.xmlUCSIsCJKCompatibilityIdeographs(code) |
| return ret |
| |
| def uCSIsCJKCompatibilityIdeographsSupplement(code): |
| """Check whether the character is part of |
| CJKCompatibilityIdeographsSupplement UCS Block """ |
| ret = libxml2mod.xmlUCSIsCJKCompatibilityIdeographsSupplement(code) |
| return ret |
| |
| def uCSIsCJKRadicalsSupplement(code): |
| """Check whether the character is part of |
| CJKRadicalsSupplement UCS Block """ |
| ret = libxml2mod.xmlUCSIsCJKRadicalsSupplement(code) |
| return ret |
| |
| def uCSIsCJKSymbolsandPunctuation(code): |
| """Check whether the character is part of |
| CJKSymbolsandPunctuation UCS Block """ |
| ret = libxml2mod.xmlUCSIsCJKSymbolsandPunctuation(code) |
| return ret |
| |
| def uCSIsCJKUnifiedIdeographs(code): |
| """Check whether the character is part of CJKUnifiedIdeographs |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsCJKUnifiedIdeographs(code) |
| return ret |
| |
| def uCSIsCJKUnifiedIdeographsExtensionA(code): |
| """Check whether the character is part of |
| CJKUnifiedIdeographsExtensionA UCS Block """ |
| ret = libxml2mod.xmlUCSIsCJKUnifiedIdeographsExtensionA(code) |
| return ret |
| |
| def uCSIsCJKUnifiedIdeographsExtensionB(code): |
| """Check whether the character is part of |
| CJKUnifiedIdeographsExtensionB UCS Block """ |
| ret = libxml2mod.xmlUCSIsCJKUnifiedIdeographsExtensionB(code) |
| return ret |
| |
| def uCSIsCat(code, cat): |
| """Check whether the character is part of the UCS Category """ |
| ret = libxml2mod.xmlUCSIsCat(code, cat) |
| return ret |
| |
| def uCSIsCatC(code): |
| """Check whether the character is part of C UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatC(code) |
| return ret |
| |
| def uCSIsCatCc(code): |
| """Check whether the character is part of Cc UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatCc(code) |
| return ret |
| |
| def uCSIsCatCf(code): |
| """Check whether the character is part of Cf UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatCf(code) |
| return ret |
| |
| def uCSIsCatCo(code): |
| """Check whether the character is part of Co UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatCo(code) |
| return ret |
| |
| def uCSIsCatCs(code): |
| """Check whether the character is part of Cs UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatCs(code) |
| return ret |
| |
| def uCSIsCatL(code): |
| """Check whether the character is part of L UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatL(code) |
| return ret |
| |
| def uCSIsCatLl(code): |
| """Check whether the character is part of Ll UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatLl(code) |
| return ret |
| |
| def uCSIsCatLm(code): |
| """Check whether the character is part of Lm UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatLm(code) |
| return ret |
| |
| def uCSIsCatLo(code): |
| """Check whether the character is part of Lo UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatLo(code) |
| return ret |
| |
| def uCSIsCatLt(code): |
| """Check whether the character is part of Lt UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatLt(code) |
| return ret |
| |
| def uCSIsCatLu(code): |
| """Check whether the character is part of Lu UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatLu(code) |
| return ret |
| |
| def uCSIsCatM(code): |
| """Check whether the character is part of M UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatM(code) |
| return ret |
| |
| def uCSIsCatMc(code): |
| """Check whether the character is part of Mc UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatMc(code) |
| return ret |
| |
| def uCSIsCatMe(code): |
| """Check whether the character is part of Me UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatMe(code) |
| return ret |
| |
| def uCSIsCatMn(code): |
| """Check whether the character is part of Mn UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatMn(code) |
| return ret |
| |
| def uCSIsCatN(code): |
| """Check whether the character is part of N UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatN(code) |
| return ret |
| |
| def uCSIsCatNd(code): |
| """Check whether the character is part of Nd UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatNd(code) |
| return ret |
| |
| def uCSIsCatNl(code): |
| """Check whether the character is part of Nl UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatNl(code) |
| return ret |
| |
| def uCSIsCatNo(code): |
| """Check whether the character is part of No UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatNo(code) |
| return ret |
| |
| def uCSIsCatP(code): |
| """Check whether the character is part of P UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatP(code) |
| return ret |
| |
| def uCSIsCatPc(code): |
| """Check whether the character is part of Pc UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatPc(code) |
| return ret |
| |
| def uCSIsCatPd(code): |
| """Check whether the character is part of Pd UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatPd(code) |
| return ret |
| |
| def uCSIsCatPe(code): |
| """Check whether the character is part of Pe UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatPe(code) |
| return ret |
| |
| def uCSIsCatPf(code): |
| """Check whether the character is part of Pf UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatPf(code) |
| return ret |
| |
| def uCSIsCatPi(code): |
| """Check whether the character is part of Pi UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatPi(code) |
| return ret |
| |
| def uCSIsCatPo(code): |
| """Check whether the character is part of Po UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatPo(code) |
| return ret |
| |
| def uCSIsCatPs(code): |
| """Check whether the character is part of Ps UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatPs(code) |
| return ret |
| |
| def uCSIsCatS(code): |
| """Check whether the character is part of S UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatS(code) |
| return ret |
| |
| def uCSIsCatSc(code): |
| """Check whether the character is part of Sc UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatSc(code) |
| return ret |
| |
| def uCSIsCatSk(code): |
| """Check whether the character is part of Sk UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatSk(code) |
| return ret |
| |
| def uCSIsCatSm(code): |
| """Check whether the character is part of Sm UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatSm(code) |
| return ret |
| |
| def uCSIsCatSo(code): |
| """Check whether the character is part of So UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatSo(code) |
| return ret |
| |
| def uCSIsCatZ(code): |
| """Check whether the character is part of Z UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatZ(code) |
| return ret |
| |
| def uCSIsCatZl(code): |
| """Check whether the character is part of Zl UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatZl(code) |
| return ret |
| |
| def uCSIsCatZp(code): |
| """Check whether the character is part of Zp UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatZp(code) |
| return ret |
| |
| def uCSIsCatZs(code): |
| """Check whether the character is part of Zs UCS Category """ |
| ret = libxml2mod.xmlUCSIsCatZs(code) |
| return ret |
| |
| def uCSIsCherokee(code): |
| """Check whether the character is part of Cherokee UCS Block """ |
| ret = libxml2mod.xmlUCSIsCherokee(code) |
| return ret |
| |
| def uCSIsCombiningDiacriticalMarks(code): |
| """Check whether the character is part of |
| CombiningDiacriticalMarks UCS Block """ |
| ret = libxml2mod.xmlUCSIsCombiningDiacriticalMarks(code) |
| return ret |
| |
| def uCSIsCombiningDiacriticalMarksforSymbols(code): |
| """Check whether the character is part of |
| CombiningDiacriticalMarksforSymbols UCS Block """ |
| ret = libxml2mod.xmlUCSIsCombiningDiacriticalMarksforSymbols(code) |
| return ret |
| |
| def uCSIsCombiningHalfMarks(code): |
| """Check whether the character is part of CombiningHalfMarks |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsCombiningHalfMarks(code) |
| return ret |
| |
| def uCSIsCombiningMarksforSymbols(code): |
| """Check whether the character is part of |
| CombiningMarksforSymbols UCS Block """ |
| ret = libxml2mod.xmlUCSIsCombiningMarksforSymbols(code) |
| return ret |
| |
| def uCSIsControlPictures(code): |
| """Check whether the character is part of ControlPictures UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsControlPictures(code) |
| return ret |
| |
| def uCSIsCurrencySymbols(code): |
| """Check whether the character is part of CurrencySymbols UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsCurrencySymbols(code) |
| return ret |
| |
| def uCSIsCypriotSyllabary(code): |
| """Check whether the character is part of CypriotSyllabary UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsCypriotSyllabary(code) |
| return ret |
| |
| def uCSIsCyrillic(code): |
| """Check whether the character is part of Cyrillic UCS Block """ |
| ret = libxml2mod.xmlUCSIsCyrillic(code) |
| return ret |
| |
| def uCSIsCyrillicSupplement(code): |
| """Check whether the character is part of CyrillicSupplement |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsCyrillicSupplement(code) |
| return ret |
| |
| def uCSIsDeseret(code): |
| """Check whether the character is part of Deseret UCS Block """ |
| ret = libxml2mod.xmlUCSIsDeseret(code) |
| return ret |
| |
| def uCSIsDevanagari(code): |
| """Check whether the character is part of Devanagari UCS Block """ |
| ret = libxml2mod.xmlUCSIsDevanagari(code) |
| return ret |
| |
| def uCSIsDingbats(code): |
| """Check whether the character is part of Dingbats UCS Block """ |
| ret = libxml2mod.xmlUCSIsDingbats(code) |
| return ret |
| |
| def uCSIsEnclosedAlphanumerics(code): |
| """Check whether the character is part of |
| EnclosedAlphanumerics UCS Block """ |
| ret = libxml2mod.xmlUCSIsEnclosedAlphanumerics(code) |
| return ret |
| |
| def uCSIsEnclosedCJKLettersandMonths(code): |
| """Check whether the character is part of |
| EnclosedCJKLettersandMonths UCS Block """ |
| ret = libxml2mod.xmlUCSIsEnclosedCJKLettersandMonths(code) |
| return ret |
| |
| def uCSIsEthiopic(code): |
| """Check whether the character is part of Ethiopic UCS Block """ |
| ret = libxml2mod.xmlUCSIsEthiopic(code) |
| return ret |
| |
| def uCSIsGeneralPunctuation(code): |
| """Check whether the character is part of GeneralPunctuation |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsGeneralPunctuation(code) |
| return ret |
| |
| def uCSIsGeometricShapes(code): |
| """Check whether the character is part of GeometricShapes UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsGeometricShapes(code) |
| return ret |
| |
| def uCSIsGeorgian(code): |
| """Check whether the character is part of Georgian UCS Block """ |
| ret = libxml2mod.xmlUCSIsGeorgian(code) |
| return ret |
| |
| def uCSIsGothic(code): |
| """Check whether the character is part of Gothic UCS Block """ |
| ret = libxml2mod.xmlUCSIsGothic(code) |
| return ret |
| |
| def uCSIsGreek(code): |
| """Check whether the character is part of Greek UCS Block """ |
| ret = libxml2mod.xmlUCSIsGreek(code) |
| return ret |
| |
| def uCSIsGreekExtended(code): |
| """Check whether the character is part of GreekExtended UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsGreekExtended(code) |
| return ret |
| |
| def uCSIsGreekandCoptic(code): |
| """Check whether the character is part of GreekandCoptic UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsGreekandCoptic(code) |
| return ret |
| |
| def uCSIsGujarati(code): |
| """Check whether the character is part of Gujarati UCS Block """ |
| ret = libxml2mod.xmlUCSIsGujarati(code) |
| return ret |
| |
| def uCSIsGurmukhi(code): |
| """Check whether the character is part of Gurmukhi UCS Block """ |
| ret = libxml2mod.xmlUCSIsGurmukhi(code) |
| return ret |
| |
| def uCSIsHalfwidthandFullwidthForms(code): |
| """Check whether the character is part of |
| HalfwidthandFullwidthForms UCS Block """ |
| ret = libxml2mod.xmlUCSIsHalfwidthandFullwidthForms(code) |
| return ret |
| |
| def uCSIsHangulCompatibilityJamo(code): |
| """Check whether the character is part of |
| HangulCompatibilityJamo UCS Block """ |
| ret = libxml2mod.xmlUCSIsHangulCompatibilityJamo(code) |
| return ret |
| |
| def uCSIsHangulJamo(code): |
| """Check whether the character is part of HangulJamo UCS Block """ |
| ret = libxml2mod.xmlUCSIsHangulJamo(code) |
| return ret |
| |
| def uCSIsHangulSyllables(code): |
| """Check whether the character is part of HangulSyllables UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsHangulSyllables(code) |
| return ret |
| |
| def uCSIsHanunoo(code): |
| """Check whether the character is part of Hanunoo UCS Block """ |
| ret = libxml2mod.xmlUCSIsHanunoo(code) |
| return ret |
| |
| def uCSIsHebrew(code): |
| """Check whether the character is part of Hebrew UCS Block """ |
| ret = libxml2mod.xmlUCSIsHebrew(code) |
| return ret |
| |
| def uCSIsHighPrivateUseSurrogates(code): |
| """Check whether the character is part of |
| HighPrivateUseSurrogates UCS Block """ |
| ret = libxml2mod.xmlUCSIsHighPrivateUseSurrogates(code) |
| return ret |
| |
| def uCSIsHighSurrogates(code): |
| """Check whether the character is part of HighSurrogates UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsHighSurrogates(code) |
| return ret |
| |
| def uCSIsHiragana(code): |
| """Check whether the character is part of Hiragana UCS Block """ |
| ret = libxml2mod.xmlUCSIsHiragana(code) |
| return ret |
| |
| def uCSIsIPAExtensions(code): |
| """Check whether the character is part of IPAExtensions UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsIPAExtensions(code) |
| return ret |
| |
| def uCSIsIdeographicDescriptionCharacters(code): |
| """Check whether the character is part of |
| IdeographicDescriptionCharacters UCS Block """ |
| ret = libxml2mod.xmlUCSIsIdeographicDescriptionCharacters(code) |
| return ret |
| |
| def uCSIsKanbun(code): |
| """Check whether the character is part of Kanbun UCS Block """ |
| ret = libxml2mod.xmlUCSIsKanbun(code) |
| return ret |
| |
| def uCSIsKangxiRadicals(code): |
| """Check whether the character is part of KangxiRadicals UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsKangxiRadicals(code) |
| return ret |
| |
| def uCSIsKannada(code): |
| """Check whether the character is part of Kannada UCS Block """ |
| ret = libxml2mod.xmlUCSIsKannada(code) |
| return ret |
| |
| def uCSIsKatakana(code): |
| """Check whether the character is part of Katakana UCS Block """ |
| ret = libxml2mod.xmlUCSIsKatakana(code) |
| return ret |
| |
| def uCSIsKatakanaPhoneticExtensions(code): |
| """Check whether the character is part of |
| KatakanaPhoneticExtensions UCS Block """ |
| ret = libxml2mod.xmlUCSIsKatakanaPhoneticExtensions(code) |
| return ret |
| |
| def uCSIsKhmer(code): |
| """Check whether the character is part of Khmer UCS Block """ |
| ret = libxml2mod.xmlUCSIsKhmer(code) |
| return ret |
| |
| def uCSIsKhmerSymbols(code): |
| """Check whether the character is part of KhmerSymbols UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsKhmerSymbols(code) |
| return ret |
| |
| def uCSIsLao(code): |
| """Check whether the character is part of Lao UCS Block """ |
| ret = libxml2mod.xmlUCSIsLao(code) |
| return ret |
| |
| def uCSIsLatin1Supplement(code): |
| """Check whether the character is part of Latin-1Supplement |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsLatin1Supplement(code) |
| return ret |
| |
| def uCSIsLatinExtendedA(code): |
| """Check whether the character is part of LatinExtended-A UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsLatinExtendedA(code) |
| return ret |
| |
| def uCSIsLatinExtendedAdditional(code): |
| """Check whether the character is part of |
| LatinExtendedAdditional UCS Block """ |
| ret = libxml2mod.xmlUCSIsLatinExtendedAdditional(code) |
| return ret |
| |
| def uCSIsLatinExtendedB(code): |
| """Check whether the character is part of LatinExtended-B UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsLatinExtendedB(code) |
| return ret |
| |
| def uCSIsLetterlikeSymbols(code): |
| """Check whether the character is part of LetterlikeSymbols |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsLetterlikeSymbols(code) |
| return ret |
| |
| def uCSIsLimbu(code): |
| """Check whether the character is part of Limbu UCS Block """ |
| ret = libxml2mod.xmlUCSIsLimbu(code) |
| return ret |
| |
| def uCSIsLinearBIdeograms(code): |
| """Check whether the character is part of LinearBIdeograms UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsLinearBIdeograms(code) |
| return ret |
| |
| def uCSIsLinearBSyllabary(code): |
| """Check whether the character is part of LinearBSyllabary UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsLinearBSyllabary(code) |
| return ret |
| |
| def uCSIsLowSurrogates(code): |
| """Check whether the character is part of LowSurrogates UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsLowSurrogates(code) |
| return ret |
| |
| def uCSIsMalayalam(code): |
| """Check whether the character is part of Malayalam UCS Block """ |
| ret = libxml2mod.xmlUCSIsMalayalam(code) |
| return ret |
| |
| def uCSIsMathematicalAlphanumericSymbols(code): |
| """Check whether the character is part of |
| MathematicalAlphanumericSymbols UCS Block """ |
| ret = libxml2mod.xmlUCSIsMathematicalAlphanumericSymbols(code) |
| return ret |
| |
| def uCSIsMathematicalOperators(code): |
| """Check whether the character is part of |
| MathematicalOperators UCS Block """ |
| ret = libxml2mod.xmlUCSIsMathematicalOperators(code) |
| return ret |
| |
| def uCSIsMiscellaneousMathematicalSymbolsA(code): |
| """Check whether the character is part of |
| MiscellaneousMathematicalSymbols-A UCS Block """ |
| ret = libxml2mod.xmlUCSIsMiscellaneousMathematicalSymbolsA(code) |
| return ret |
| |
| def uCSIsMiscellaneousMathematicalSymbolsB(code): |
| """Check whether the character is part of |
| MiscellaneousMathematicalSymbols-B UCS Block """ |
| ret = libxml2mod.xmlUCSIsMiscellaneousMathematicalSymbolsB(code) |
| return ret |
| |
| def uCSIsMiscellaneousSymbols(code): |
| """Check whether the character is part of MiscellaneousSymbols |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsMiscellaneousSymbols(code) |
| return ret |
| |
| def uCSIsMiscellaneousSymbolsandArrows(code): |
| """Check whether the character is part of |
| MiscellaneousSymbolsandArrows UCS Block """ |
| ret = libxml2mod.xmlUCSIsMiscellaneousSymbolsandArrows(code) |
| return ret |
| |
| def uCSIsMiscellaneousTechnical(code): |
| """Check whether the character is part of |
| MiscellaneousTechnical UCS Block """ |
| ret = libxml2mod.xmlUCSIsMiscellaneousTechnical(code) |
| return ret |
| |
| def uCSIsMongolian(code): |
| """Check whether the character is part of Mongolian UCS Block """ |
| ret = libxml2mod.xmlUCSIsMongolian(code) |
| return ret |
| |
| def uCSIsMusicalSymbols(code): |
| """Check whether the character is part of MusicalSymbols UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsMusicalSymbols(code) |
| return ret |
| |
| def uCSIsMyanmar(code): |
| """Check whether the character is part of Myanmar UCS Block """ |
| ret = libxml2mod.xmlUCSIsMyanmar(code) |
| return ret |
| |
| def uCSIsNumberForms(code): |
| """Check whether the character is part of NumberForms UCS Block """ |
| ret = libxml2mod.xmlUCSIsNumberForms(code) |
| return ret |
| |
| def uCSIsOgham(code): |
| """Check whether the character is part of Ogham UCS Block """ |
| ret = libxml2mod.xmlUCSIsOgham(code) |
| return ret |
| |
| def uCSIsOldItalic(code): |
| """Check whether the character is part of OldItalic UCS Block """ |
| ret = libxml2mod.xmlUCSIsOldItalic(code) |
| return ret |
| |
| def uCSIsOpticalCharacterRecognition(code): |
| """Check whether the character is part of |
| OpticalCharacterRecognition UCS Block """ |
| ret = libxml2mod.xmlUCSIsOpticalCharacterRecognition(code) |
| return ret |
| |
| def uCSIsOriya(code): |
| """Check whether the character is part of Oriya UCS Block """ |
| ret = libxml2mod.xmlUCSIsOriya(code) |
| return ret |
| |
| def uCSIsOsmanya(code): |
| """Check whether the character is part of Osmanya UCS Block """ |
| ret = libxml2mod.xmlUCSIsOsmanya(code) |
| return ret |
| |
| def uCSIsPhoneticExtensions(code): |
| """Check whether the character is part of PhoneticExtensions |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsPhoneticExtensions(code) |
| return ret |
| |
| def uCSIsPrivateUse(code): |
| """Check whether the character is part of PrivateUse UCS Block """ |
| ret = libxml2mod.xmlUCSIsPrivateUse(code) |
| return ret |
| |
| def uCSIsPrivateUseArea(code): |
| """Check whether the character is part of PrivateUseArea UCS |
| Block """ |
| ret = libxml2mod.xmlUCSIsPrivateUseArea(code) |
| return ret |
| |
| def uCSIsRunic(code): |
| """Check whether the character is part of Runic UCS Block """ |
| ret = libxml2mod.xmlUCSIsRunic(code) |
| return ret |
| |
| def uCSIsShavian(code): |
| """Check whether the character is part of Shavian UCS Block """ |
| ret = libxml2mod.xmlUCSIsShavian(code) |
| return ret |
| |
| def uCSIsSinhala(code): |
| """Check whether the character is part of Sinhala UCS Block """ |
| ret = libxml2mod.xmlUCSIsSinhala(code) |
| return ret |
| |
| def uCSIsSmallFormVariants(code): |
| """Check whether the character is part of SmallFormVariants |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsSmallFormVariants(code) |
| return ret |
| |
| def uCSIsSpacingModifierLetters(code): |
| """Check whether the character is part of |
| SpacingModifierLetters UCS Block """ |
| ret = libxml2mod.xmlUCSIsSpacingModifierLetters(code) |
| return ret |
| |
| def uCSIsSpecials(code): |
| """Check whether the character is part of Specials UCS Block """ |
| ret = libxml2mod.xmlUCSIsSpecials(code) |
| return ret |
| |
| def uCSIsSuperscriptsandSubscripts(code): |
| """Check whether the character is part of |
| SuperscriptsandSubscripts UCS Block """ |
| ret = libxml2mod.xmlUCSIsSuperscriptsandSubscripts(code) |
| return ret |
| |
| def uCSIsSupplementalArrowsA(code): |
| """Check whether the character is part of SupplementalArrows-A |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsSupplementalArrowsA(code) |
| return ret |
| |
| def uCSIsSupplementalArrowsB(code): |
| """Check whether the character is part of SupplementalArrows-B |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsSupplementalArrowsB(code) |
| return ret |
| |
| def uCSIsSupplementalMathematicalOperators(code): |
| """Check whether the character is part of |
| SupplementalMathematicalOperators UCS Block """ |
| ret = libxml2mod.xmlUCSIsSupplementalMathematicalOperators(code) |
| return ret |
| |
| def uCSIsSupplementaryPrivateUseAreaA(code): |
| """Check whether the character is part of |
| SupplementaryPrivateUseArea-A UCS Block """ |
| ret = libxml2mod.xmlUCSIsSupplementaryPrivateUseAreaA(code) |
| return ret |
| |
| def uCSIsSupplementaryPrivateUseAreaB(code): |
| """Check whether the character is part of |
| SupplementaryPrivateUseArea-B UCS Block """ |
| ret = libxml2mod.xmlUCSIsSupplementaryPrivateUseAreaB(code) |
| return ret |
| |
| def uCSIsSyriac(code): |
| """Check whether the character is part of Syriac UCS Block """ |
| ret = libxml2mod.xmlUCSIsSyriac(code) |
| return ret |
| |
| def uCSIsTagalog(code): |
| """Check whether the character is part of Tagalog UCS Block """ |
| ret = libxml2mod.xmlUCSIsTagalog(code) |
| return ret |
| |
| def uCSIsTagbanwa(code): |
| """Check whether the character is part of Tagbanwa UCS Block """ |
| ret = libxml2mod.xmlUCSIsTagbanwa(code) |
| return ret |
| |
| def uCSIsTags(code): |
| """Check whether the character is part of Tags UCS Block """ |
| ret = libxml2mod.xmlUCSIsTags(code) |
| return ret |
| |
| def uCSIsTaiLe(code): |
| """Check whether the character is part of TaiLe UCS Block """ |
| ret = libxml2mod.xmlUCSIsTaiLe(code) |
| return ret |
| |
| def uCSIsTaiXuanJingSymbols(code): |
| """Check whether the character is part of TaiXuanJingSymbols |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsTaiXuanJingSymbols(code) |
| return ret |
| |
| def uCSIsTamil(code): |
| """Check whether the character is part of Tamil UCS Block """ |
| ret = libxml2mod.xmlUCSIsTamil(code) |
| return ret |
| |
| def uCSIsTelugu(code): |
| """Check whether the character is part of Telugu UCS Block """ |
| ret = libxml2mod.xmlUCSIsTelugu(code) |
| return ret |
| |
| def uCSIsThaana(code): |
| """Check whether the character is part of Thaana UCS Block """ |
| ret = libxml2mod.xmlUCSIsThaana(code) |
| return ret |
| |
| def uCSIsThai(code): |
| """Check whether the character is part of Thai UCS Block """ |
| ret = libxml2mod.xmlUCSIsThai(code) |
| return ret |
| |
| def uCSIsTibetan(code): |
| """Check whether the character is part of Tibetan UCS Block """ |
| ret = libxml2mod.xmlUCSIsTibetan(code) |
| return ret |
| |
| def uCSIsUgaritic(code): |
| """Check whether the character is part of Ugaritic UCS Block """ |
| ret = libxml2mod.xmlUCSIsUgaritic(code) |
| return ret |
| |
| def uCSIsUnifiedCanadianAboriginalSyllabics(code): |
| """Check whether the character is part of |
| UnifiedCanadianAboriginalSyllabics UCS Block """ |
| ret = libxml2mod.xmlUCSIsUnifiedCanadianAboriginalSyllabics(code) |
| return ret |
| |
| def uCSIsVariationSelectors(code): |
| """Check whether the character is part of VariationSelectors |
| UCS Block """ |
| ret = libxml2mod.xmlUCSIsVariationSelectors(code) |
| return ret |
| |
| def uCSIsVariationSelectorsSupplement(code): |
| """Check whether the character is part of |
| VariationSelectorsSupplement UCS Block """ |
| ret = libxml2mod.xmlUCSIsVariationSelectorsSupplement(code) |
| return ret |
| |
| def uCSIsYiRadicals(code): |
| """Check whether the character is part of YiRadicals UCS Block """ |
| ret = libxml2mod.xmlUCSIsYiRadicals(code) |
| return ret |
| |
| def uCSIsYiSyllables(code): |
| """Check whether the character is part of YiSyllables UCS Block """ |
| ret = libxml2mod.xmlUCSIsYiSyllables(code) |
| return ret |
| |
| def uCSIsYijingHexagramSymbols(code): |
| """Check whether the character is part of |
| YijingHexagramSymbols UCS Block """ |
| ret = libxml2mod.xmlUCSIsYijingHexagramSymbols(code) |
| return ret |
| |
| # |
| # Functions from module xmlversion |
| # |
| |
| def checkVersion(version): |
| """check the compiled lib version against the include one. |
| This can warn or immediately kill the application """ |
| libxml2mod.xmlCheckVersion(version) |
| |
| # |
| # Functions from module xpathInternals |
| # |
| |
| def valuePop(ctxt): |
| """Pops the top XPath object from the value stack """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.valuePop(ctxt__o) |
| return ret |
| |
| class xmlNode(xmlCore): |
| def __init__(self, _obj=None): |
| if checkWrapper(_obj) != 0: raise TypeError('xmlNode got a wrong wrapper object type') |
| self._o = _obj |
| xmlCore.__init__(self, _obj=_obj) |
| |
| def __repr__(self): |
| return "<xmlNode (%s) object at 0x%x>" % (self.name, int(pos_id (self))) |
| |
| # accessors for xmlNode |
| def ns(self): |
| """Get the namespace of a node """ |
| ret = libxml2mod.xmlNodeGetNs(self._o) |
| if ret is None:return None |
| __tmp = xmlNs(_obj=ret) |
| return __tmp |
| |
| def nsDefs(self): |
| """Get the namespace of a node """ |
| ret = libxml2mod.xmlNodeGetNsDefs(self._o) |
| if ret is None:return None |
| __tmp = xmlNs(_obj=ret) |
| return __tmp |
| |
| # |
| # xmlNode functions from module debugXML |
| # |
| |
| def debugDumpNode(self, output, depth): |
| """Dumps debug information for the element node, it is |
| recursive """ |
| libxml2mod.xmlDebugDumpNode(output, self._o, depth) |
| |
| def debugDumpNodeList(self, output, depth): |
| """Dumps debug information for the list of element node, it is |
| recursive """ |
| libxml2mod.xmlDebugDumpNodeList(output, self._o, depth) |
| |
| def debugDumpOneNode(self, output, depth): |
| """Dumps debug information for the element node, it is not |
| recursive """ |
| libxml2mod.xmlDebugDumpOneNode(output, self._o, depth) |
| |
| def lsCountNode(self): |
| """Count the children of @node. """ |
| ret = libxml2mod.xmlLsCountNode(self._o) |
| return ret |
| |
| def lsOneNode(self, output): |
| """Dump to @output the type and name of @node. """ |
| libxml2mod.xmlLsOneNode(output, self._o) |
| |
| def shellPrintNode(self): |
| """Print node to the output FILE """ |
| libxml2mod.xmlShellPrintNode(self._o) |
| |
| # |
| # xmlNode functions from module tree |
| # |
| |
| def addChild(self, cur): |
| """Add a new node to @parent, at the end of the child (or |
| property) list merging adjacent TEXT nodes (in which case |
| @cur is freed) If the new node is ATTRIBUTE, it is added |
| into properties instead of children. If there is an |
| attribute with equal name, it is first destroyed. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlAddChild(self._o, cur__o) |
| if ret is None:raise treeError('xmlAddChild() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def addChildList(self, cur): |
| """Add a list of node at the end of the child list of the |
| parent merging adjacent TEXT nodes (@cur may be freed) """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlAddChildList(self._o, cur__o) |
| if ret is None:raise treeError('xmlAddChildList() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def addContent(self, content): |
| """Append the extra substring to the node content. NOTE: In |
| contrast to xmlNodeSetContent(), @content is supposed to be |
| raw text, so unescaped XML special chars are allowed, |
| entity references are not supported. """ |
| libxml2mod.xmlNodeAddContent(self._o, content) |
| |
| def addContentLen(self, content, len): |
| """Append the extra substring to the node content. NOTE: In |
| contrast to xmlNodeSetContentLen(), @content is supposed to |
| be raw text, so unescaped XML special chars are allowed, |
| entity references are not supported. """ |
| libxml2mod.xmlNodeAddContentLen(self._o, content, len) |
| |
| def addNextSibling(self, elem): |
| """Add a new node @elem as the next sibling of @cur If the new |
| node was already inserted in a document it is first |
| unlinked from its existing context. As a result of text |
| merging @elem may be freed. If the new node is ATTRIBUTE, |
| it is added into properties instead of children. If there |
| is an attribute with equal name, it is first destroyed. """ |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlAddNextSibling(self._o, elem__o) |
| if ret is None:raise treeError('xmlAddNextSibling() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def addPrevSibling(self, elem): |
| """Add a new node @elem as the previous sibling of @cur |
| merging adjacent TEXT nodes (@elem may be freed) If the new |
| node was already inserted in a document it is first |
| unlinked from its existing context. If the new node is |
| ATTRIBUTE, it is added into properties instead of children. |
| If there is an attribute with equal name, it is first |
| destroyed. """ |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlAddPrevSibling(self._o, elem__o) |
| if ret is None:raise treeError('xmlAddPrevSibling() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def addSibling(self, elem): |
| """Add a new element @elem to the list of siblings of @cur |
| merging adjacent TEXT nodes (@elem may be freed) If the new |
| element was already inserted in a document it is first |
| unlinked from its existing context. """ |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlAddSibling(self._o, elem__o) |
| if ret is None:raise treeError('xmlAddSibling() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def copyNode(self, extended): |
| """Do a copy of the node. """ |
| ret = libxml2mod.xmlCopyNode(self._o, extended) |
| if ret is None:raise treeError('xmlCopyNode() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def copyNodeList(self): |
| """Do a recursive copy of the node list. Use |
| xmlDocCopyNodeList() if possible to ensure string interning. """ |
| ret = libxml2mod.xmlCopyNodeList(self._o) |
| if ret is None:raise treeError('xmlCopyNodeList() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def copyProp(self, cur): |
| """Do a copy of the attribute. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlCopyProp(self._o, cur__o) |
| if ret is None:raise treeError('xmlCopyProp() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def copyPropList(self, cur): |
| """Do a copy of an attribute list. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlCopyPropList(self._o, cur__o) |
| if ret is None:raise treeError('xmlCopyPropList() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def docCopyNode(self, doc, extended): |
| """Do a copy of the node to a given document. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlDocCopyNode(self._o, doc__o, extended) |
| if ret is None:raise treeError('xmlDocCopyNode() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def docCopyNodeList(self, doc): |
| """Do a recursive copy of the node list. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlDocCopyNodeList(doc__o, self._o) |
| if ret is None:raise treeError('xmlDocCopyNodeList() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def docSetRootElement(self, doc): |
| """Set the root element of the document (doc->children is a |
| list containing possibly comments, PIs, etc ...). """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlDocSetRootElement(doc__o, self._o) |
| if ret is None:return None |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def firstElementChild(self): |
| """Finds the first child node of that element which is a |
| Element node Note the handling of entities references is |
| different than in the W3C DOM element traversal spec since |
| we don't have back reference from entities content to |
| entities references. """ |
| ret = libxml2mod.xmlFirstElementChild(self._o) |
| if ret is None:return None |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def freeNode(self): |
| """Free a node, this is a recursive behaviour, all the |
| children are freed too. This doesn't unlink the child from |
| the list, use xmlUnlinkNode() first. """ |
| libxml2mod.xmlFreeNode(self._o) |
| |
| def freeNodeList(self): |
| """Free a node and all its siblings, this is a recursive |
| behaviour, all the children are freed too. """ |
| libxml2mod.xmlFreeNodeList(self._o) |
| |
| def getBase(self, doc): |
| """Searches for the BASE URL. The code should work on both XML |
| and HTML document even if base mechanisms are completely |
| different. It returns the base as defined in RFC 2396 |
| sections 5.1.1. Base URI within Document Content and 5.1.2. |
| Base URI from the Encapsulating Entity However it does not |
| return the document base (5.1.3), use doc->URL in this case """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlNodeGetBase(doc__o, self._o) |
| return ret |
| |
| def getContent(self): |
| """Read the value of a node, this can be either the text |
| carried directly by this node if it's a TEXT node or the |
| aggregate string of the values carried by this node child's |
| (TEXT and ENTITY_REF). Entity references are substituted. """ |
| ret = libxml2mod.xmlNodeGetContent(self._o) |
| return ret |
| |
| def getLang(self): |
| """Searches the language of a node, i.e. the values of the |
| xml:lang attribute or the one carried by the nearest |
| ancestor. """ |
| ret = libxml2mod.xmlNodeGetLang(self._o) |
| return ret |
| |
| def getSpacePreserve(self): |
| """Searches the space preserving behaviour of a node, i.e. the |
| values of the xml:space attribute or the one carried by the |
| nearest ancestor. """ |
| ret = libxml2mod.xmlNodeGetSpacePreserve(self._o) |
| return ret |
| |
| def hasNsProp(self, name, nameSpace): |
| """Search for an attribute associated to a node This attribute |
| has to be anchored in the namespace specified. This does |
| the entity substitution. This function looks in DTD |
| attribute declaration for #FIXED or default declaration |
| values unless DTD use has been turned off. Note that a |
| namespace of None indicates to use the default namespace. """ |
| ret = libxml2mod.xmlHasNsProp(self._o, name, nameSpace) |
| if ret is None:return None |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def hasProp(self, name): |
| """Search an attribute associated to a node This function also |
| looks in DTD attribute declaration for #FIXED or default |
| declaration values unless DTD use has been turned off. """ |
| ret = libxml2mod.xmlHasProp(self._o, name) |
| if ret is None:return None |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def isBlankNode(self): |
| """Checks whether this node is an empty or whitespace only |
| (and possibly ignorable) text-node. """ |
| ret = libxml2mod.xmlIsBlankNode(self._o) |
| return ret |
| |
| def isText(self): |
| """Is this node a Text node ? """ |
| ret = libxml2mod.xmlNodeIsText(self._o) |
| return ret |
| |
| def lastChild(self): |
| """Search the last child of a node. """ |
| ret = libxml2mod.xmlGetLastChild(self._o) |
| if ret is None:raise treeError('xmlGetLastChild() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def lastElementChild(self): |
| """Finds the last child node of that element which is a |
| Element node Note the handling of entities references is |
| different than in the W3C DOM element traversal spec since |
| we don't have back reference from entities content to |
| entities references. """ |
| ret = libxml2mod.xmlLastElementChild(self._o) |
| if ret is None:return None |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def lineNo(self): |
| """Get line number of @node. Try to override the limitation of |
| lines being store in 16 bits ints if XML_PARSE_BIG_LINES |
| parser option was used """ |
| ret = libxml2mod.xmlGetLineNo(self._o) |
| return ret |
| |
| def listGetRawString(self, doc, inLine): |
| """Builds the string equivalent to the text contained in the |
| Node list made of TEXTs and ENTITY_REFs, contrary to |
| xmlNodeListGetString() this function doesn't do any |
| character encoding handling. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlNodeListGetRawString(doc__o, self._o, inLine) |
| return ret |
| |
| def listGetString(self, doc, inLine): |
| """Build the string equivalent to the text contained in the |
| Node list made of TEXTs and ENTITY_REFs """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlNodeListGetString(doc__o, self._o, inLine) |
| return ret |
| |
| def newChild(self, ns, name, content): |
| """Creation of a new child element, added at the end of |
| @parent children list. @ns and @content parameters are |
| optional (None). If @ns is None, the newly created element |
| inherits the namespace of @parent. If @content is non None, |
| a child list containing the TEXTs and ENTITY_REFs node will |
| be created. NOTE: @content is supposed to be a piece of XML |
| CDATA, so it allows entity references. XML special chars |
| must be escaped first by using |
| xmlEncodeEntitiesReentrant(), or xmlNewTextChild() should |
| be used. """ |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| ret = libxml2mod.xmlNewChild(self._o, ns__o, name, content) |
| if ret is None:raise treeError('xmlNewChild() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newNs(self, href, prefix): |
| """Creation of a new Namespace. This function will refuse to |
| create a namespace with a similar prefix than an existing |
| one present on this node. Note that for a default |
| namespace, @prefix should be None. We use href==None in |
| the case of an element creation where the namespace was not |
| defined. """ |
| ret = libxml2mod.xmlNewNs(self._o, href, prefix) |
| if ret is None:raise treeError('xmlNewNs() failed') |
| __tmp = xmlNs(_obj=ret) |
| return __tmp |
| |
| def newNsProp(self, ns, name, value): |
| """Create a new property tagged with a namespace and carried |
| by a node. """ |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| ret = libxml2mod.xmlNewNsProp(self._o, ns__o, name, value) |
| if ret is None:raise treeError('xmlNewNsProp() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def newNsPropEatName(self, ns, name, value): |
| """Create a new property tagged with a namespace and carried |
| by a node. """ |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| ret = libxml2mod.xmlNewNsPropEatName(self._o, ns__o, name, value) |
| if ret is None:raise treeError('xmlNewNsPropEatName() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def newProp(self, name, value): |
| """Create a new property carried by a node. """ |
| ret = libxml2mod.xmlNewProp(self._o, name, value) |
| if ret is None:raise treeError('xmlNewProp() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def newTextChild(self, ns, name, content): |
| """Creation of a new child element, added at the end of |
| @parent children list. @ns and @content parameters are |
| optional (None). If @ns is None, the newly created element |
| inherits the namespace of @parent. If @content is non None, |
| a child TEXT node will be created containing the string |
| @content. NOTE: Use xmlNewChild() if @content will contain |
| entities that need to be preserved. Use this function, |
| xmlNewTextChild(), if you need to ensure that reserved XML |
| chars that might appear in @content, such as the ampersand, |
| greater-than or less-than signs, are automatically replaced |
| by their XML escaped entity representations. """ |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| ret = libxml2mod.xmlNewTextChild(self._o, ns__o, name, content) |
| if ret is None:raise treeError('xmlNewTextChild() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def nextElementSibling(self): |
| """Finds the first closest next sibling of the node which is |
| an element node. Note the handling of entities references |
| is different than in the W3C DOM element traversal spec |
| since we don't have back reference from entities content to |
| entities references. """ |
| ret = libxml2mod.xmlNextElementSibling(self._o) |
| if ret is None:return None |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def noNsProp(self, name): |
| """Search and get the value of an attribute associated to a |
| node This does the entity substitution. This function looks |
| in DTD attribute declaration for #FIXED or default |
| declaration values unless DTD use has been turned off. This |
| function is similar to xmlGetProp except it will accept |
| only an attribute in no namespace. """ |
| ret = libxml2mod.xmlGetNoNsProp(self._o, name) |
| return ret |
| |
| def nodePath(self): |
| """Build a structure based Path for the given node """ |
| ret = libxml2mod.xmlGetNodePath(self._o) |
| return ret |
| |
| def nsProp(self, name, nameSpace): |
| """Search and get the value of an attribute associated to a |
| node This attribute has to be anchored in the namespace |
| specified. This does the entity substitution. This function |
| looks in DTD attribute declaration for #FIXED or default |
| declaration values unless DTD use has been turned off. """ |
| ret = libxml2mod.xmlGetNsProp(self._o, name, nameSpace) |
| return ret |
| |
| def previousElementSibling(self): |
| """Finds the first closest previous sibling of the node which |
| is an element node. Note the handling of entities |
| references is different than in the W3C DOM element |
| traversal spec since we don't have back reference from |
| entities content to entities references. """ |
| ret = libxml2mod.xmlPreviousElementSibling(self._o) |
| if ret is None:return None |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def prop(self, name): |
| """Search and get the value of an attribute associated to a |
| node This does the entity substitution. This function looks |
| in DTD attribute declaration for #FIXED or default |
| declaration values unless DTD use has been turned off. |
| NOTE: this function acts independently of namespaces |
| associated to the attribute. Use xmlGetNsProp() or |
| xmlGetNoNsProp() for namespace aware processing. """ |
| ret = libxml2mod.xmlGetProp(self._o, name) |
| return ret |
| |
| def reconciliateNs(self, doc): |
| """This function checks that all the namespaces declared |
| within the given tree are properly declared. This is needed |
| for example after Copy or Cut and then paste operations. |
| The subtree may still hold pointers to namespace |
| declarations outside the subtree or invalid/masked. As much |
| as possible the function try to reuse the existing |
| namespaces found in the new environment. If not possible |
| the new namespaces are redeclared on @tree at the top of |
| the given subtree. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlReconciliateNs(doc__o, self._o) |
| return ret |
| |
| def replaceNode(self, cur): |
| """Unlink the old node from its current context, prune the new |
| one at the same place. If @cur was already inserted in a |
| document it is first unlinked from its existing context. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlReplaceNode(self._o, cur__o) |
| if ret is None:raise treeError('xmlReplaceNode() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def searchNs(self, doc, nameSpace): |
| """Search a Ns registered under a given name space for a |
| document. recurse on the parents until it finds the defined |
| namespace or return None otherwise. @nameSpace can be None, |
| this is a search for the default namespace. We don't allow |
| to cross entities boundaries. If you don't declare the |
| namespace within those you will be in troubles !!! A |
| warning is generated to cover this case. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlSearchNs(doc__o, self._o, nameSpace) |
| if ret is None:raise treeError('xmlSearchNs() failed') |
| __tmp = xmlNs(_obj=ret) |
| return __tmp |
| |
| def searchNsByHref(self, doc, href): |
| """Search a Ns aliasing a given URI. Recurse on the parents |
| until it finds the defined namespace or return None |
| otherwise. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlSearchNsByHref(doc__o, self._o, href) |
| if ret is None:raise treeError('xmlSearchNsByHref() failed') |
| __tmp = xmlNs(_obj=ret) |
| return __tmp |
| |
| def setBase(self, uri): |
| """Set (or reset) the base URI of a node, i.e. the value of |
| the xml:base attribute. """ |
| libxml2mod.xmlNodeSetBase(self._o, uri) |
| |
| def setContent(self, content): |
| """Replace the content of a node. NOTE: @content is supposed |
| to be a piece of XML CDATA, so it allows entity references, |
| but XML special chars need to be escaped first by using |
| xmlEncodeEntitiesReentrant() resp. xmlEncodeSpecialChars(). """ |
| libxml2mod.xmlNodeSetContent(self._o, content) |
| |
| def setContentLen(self, content, len): |
| """Replace the content of a node. NOTE: @content is supposed |
| to be a piece of XML CDATA, so it allows entity references, |
| but XML special chars need to be escaped first by using |
| xmlEncodeEntitiesReentrant() resp. xmlEncodeSpecialChars(). """ |
| libxml2mod.xmlNodeSetContentLen(self._o, content, len) |
| |
| def setLang(self, lang): |
| """Set the language of a node, i.e. the values of the xml:lang |
| attribute. """ |
| libxml2mod.xmlNodeSetLang(self._o, lang) |
| |
| def setListDoc(self, doc): |
| """update all nodes in the list to point to the right document """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| libxml2mod.xmlSetListDoc(self._o, doc__o) |
| |
| def setName(self, name): |
| """Set (or reset) the name of a node. """ |
| libxml2mod.xmlNodeSetName(self._o, name) |
| |
| def setNs(self, ns): |
| """Associate a namespace to a node, a posteriori. """ |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| libxml2mod.xmlSetNs(self._o, ns__o) |
| |
| def setNsProp(self, ns, name, value): |
| """Set (or reset) an attribute carried by a node. The ns |
| structure must be in scope, this is not checked """ |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| ret = libxml2mod.xmlSetNsProp(self._o, ns__o, name, value) |
| if ret is None:raise treeError('xmlSetNsProp() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def setProp(self, name, value): |
| """Set (or reset) an attribute carried by a node. If @name has |
| a prefix, then the corresponding namespace-binding will be |
| used, if in scope; it is an error it there's no such |
| ns-binding for the prefix in scope. """ |
| ret = libxml2mod.xmlSetProp(self._o, name, value) |
| if ret is None:raise treeError('xmlSetProp() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def setSpacePreserve(self, val): |
| """Set (or reset) the space preserving behaviour of a node, |
| i.e. the value of the xml:space attribute. """ |
| libxml2mod.xmlNodeSetSpacePreserve(self._o, val) |
| |
| def setTreeDoc(self, doc): |
| """update all nodes under the tree to point to the right |
| document """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| libxml2mod.xmlSetTreeDoc(self._o, doc__o) |
| |
| def textConcat(self, content, len): |
| """Concat the given string at the end of the existing node |
| content """ |
| ret = libxml2mod.xmlTextConcat(self._o, content, len) |
| return ret |
| |
| def textMerge(self, second): |
| """Merge two text nodes into one """ |
| if second is None: second__o = None |
| else: second__o = second._o |
| ret = libxml2mod.xmlTextMerge(self._o, second__o) |
| if ret is None:raise treeError('xmlTextMerge() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def unlinkNode(self): |
| """Unlink a node from it's current context, the node is not |
| freed If one need to free the node, use xmlFreeNode() |
| routine after the unlink to discard it. Note that namespace |
| nodes can't be unlinked as they do not have pointer to |
| their parent. """ |
| libxml2mod.xmlUnlinkNode(self._o) |
| |
| def unsetNsProp(self, ns, name): |
| """Remove an attribute carried by a node. """ |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| ret = libxml2mod.xmlUnsetNsProp(self._o, ns__o, name) |
| return ret |
| |
| def unsetProp(self, name): |
| """Remove an attribute carried by a node. This handles only |
| attributes in no namespace. """ |
| ret = libxml2mod.xmlUnsetProp(self._o, name) |
| return ret |
| |
| # |
| # xmlNode functions from module valid |
| # |
| |
| def isID(self, doc, attr): |
| """Determine whether an attribute is of type ID. In case we |
| have DTD(s) then this is done if DTD loading has been |
| requested. In the case of HTML documents parsed with the |
| HTML parser, then ID detection is done systematically. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if attr is None: attr__o = None |
| else: attr__o = attr._o |
| ret = libxml2mod.xmlIsID(doc__o, self._o, attr__o) |
| return ret |
| |
| def isRef(self, doc, attr): |
| """Determine whether an attribute is of type Ref. In case we |
| have DTD(s) then this is simple, otherwise we use an |
| heuristic: name Ref (upper or lowercase). """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if attr is None: attr__o = None |
| else: attr__o = attr._o |
| ret = libxml2mod.xmlIsRef(doc__o, self._o, attr__o) |
| return ret |
| |
| def validNormalizeAttributeValue(self, doc, name, value): |
| """Does the validation related extra step of the normalization |
| of attribute values: If the declared value is not CDATA, |
| then the XML processor must further process the normalized |
| attribute value by discarding any leading and trailing |
| space (#x20) characters, and by replacing sequences of |
| space (#x20) characters by single space (#x20) character. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlValidNormalizeAttributeValue(doc__o, self._o, name, value) |
| return ret |
| |
| # |
| # xmlNode functions from module xinclude |
| # |
| |
| def xincludeProcessTree(self): |
| """Implement the XInclude substitution for the given subtree """ |
| ret = libxml2mod.xmlXIncludeProcessTree(self._o) |
| return ret |
| |
| def xincludeProcessTreeFlags(self, flags): |
| """Implement the XInclude substitution for the given subtree """ |
| ret = libxml2mod.xmlXIncludeProcessTreeFlags(self._o, flags) |
| return ret |
| |
| # |
| # xmlNode functions from module xmlschemas |
| # |
| |
| def schemaValidateOneElement(self, ctxt): |
| """Validate a branch of a tree, starting with the given @elem. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlSchemaValidateOneElement(ctxt__o, self._o) |
| return ret |
| |
| # |
| # xmlNode functions from module xpath |
| # |
| |
| def xpathCastNodeToNumber(self): |
| """Converts a node to its number value """ |
| ret = libxml2mod.xmlXPathCastNodeToNumber(self._o) |
| return ret |
| |
| def xpathCastNodeToString(self): |
| """Converts a node to its string value. """ |
| ret = libxml2mod.xmlXPathCastNodeToString(self._o) |
| return ret |
| |
| def xpathCmpNodes(self, node2): |
| """Compare two nodes w.r.t document order """ |
| if node2 is None: node2__o = None |
| else: node2__o = node2._o |
| ret = libxml2mod.xmlXPathCmpNodes(self._o, node2__o) |
| return ret |
| |
| def xpathNodeEval(self, str, ctx): |
| """Evaluate the XPath Location Path in the given context. The |
| node 'node' is set as the context node. The context node is |
| not restored. """ |
| if ctx is None: ctx__o = None |
| else: ctx__o = ctx._o |
| ret = libxml2mod.xmlXPathNodeEval(self._o, str, ctx__o) |
| if ret is None:raise xpathError('xmlXPathNodeEval() failed') |
| return xpathObjectRet(ret) |
| |
| # |
| # xmlNode functions from module xpathInternals |
| # |
| |
| def xpathNewNodeSet(self): |
| """Create a new xmlXPathObjectPtr of type NodeSet and |
| initialize it with the single Node @val """ |
| ret = libxml2mod.xmlXPathNewNodeSet(self._o) |
| if ret is None:raise xpathError('xmlXPathNewNodeSet() failed') |
| return xpathObjectRet(ret) |
| |
| def xpathNewValueTree(self): |
| """Create a new xmlXPathObjectPtr of type Value Tree (XSLT) |
| and initialize it with the tree root @val """ |
| ret = libxml2mod.xmlXPathNewValueTree(self._o) |
| if ret is None:raise xpathError('xmlXPathNewValueTree() failed') |
| return xpathObjectRet(ret) |
| |
| def xpathNextAncestor(self, ctxt): |
| """Traversal function for the "ancestor" direction the |
| ancestor axis contains the ancestors of the context node; |
| the ancestors of the context node consist of the parent of |
| context node and the parent's parent and so on; the nodes |
| are ordered in reverse document order; thus the parent is |
| the first node on the axis, and the parent's parent is the |
| second node on the axis """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextAncestor(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextAncestor() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextAncestorOrSelf(self, ctxt): |
| """Traversal function for the "ancestor-or-self" direction he |
| ancestor-or-self axis contains the context node and |
| ancestors of the context node in reverse document order; |
| thus the context node is the first node on the axis, and |
| the context node's parent the second; parent here is |
| defined the same as with the parent axis. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextAncestorOrSelf(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextAncestorOrSelf() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextAttribute(self, ctxt): |
| """Traversal function for the "attribute" direction TODO: |
| support DTD inherited default attributes """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextAttribute(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextAttribute() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextChild(self, ctxt): |
| """Traversal function for the "child" direction The child axis |
| contains the children of the context node in document order. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextChild(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextChild() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextDescendant(self, ctxt): |
| """Traversal function for the "descendant" direction the |
| descendant axis contains the descendants of the context |
| node in document order; a descendant is a child or a child |
| of a child and so on. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextDescendant(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextDescendant() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextDescendantOrSelf(self, ctxt): |
| """Traversal function for the "descendant-or-self" direction |
| the descendant-or-self axis contains the context node and |
| the descendants of the context node in document order; thus |
| the context node is the first node on the axis, and the |
| first child of the context node is the second node on the |
| axis """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextDescendantOrSelf(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextDescendantOrSelf() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextFollowing(self, ctxt): |
| """Traversal function for the "following" direction The |
| following axis contains all nodes in the same document as |
| the context node that are after the context node in |
| document order, excluding any descendants and excluding |
| attribute nodes and namespace nodes; the nodes are ordered |
| in document order """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextFollowing(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextFollowing() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextFollowingSibling(self, ctxt): |
| """Traversal function for the "following-sibling" direction |
| The following-sibling axis contains the following siblings |
| of the context node in document order. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextFollowingSibling(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextFollowingSibling() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextNamespace(self, ctxt): |
| """Traversal function for the "namespace" direction the |
| namespace axis contains the namespace nodes of the context |
| node; the order of nodes on this axis is |
| implementation-defined; the axis will be empty unless the |
| context node is an element We keep the XML namespace node |
| at the end of the list. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextNamespace(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextNamespace() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextParent(self, ctxt): |
| """Traversal function for the "parent" direction The parent |
| axis contains the parent of the context node, if there is |
| one. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextParent(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextParent() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextPreceding(self, ctxt): |
| """Traversal function for the "preceding" direction the |
| preceding axis contains all nodes in the same document as |
| the context node that are before the context node in |
| document order, excluding any ancestors and excluding |
| attribute nodes and namespace nodes; the nodes are ordered |
| in reverse document order """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextPreceding(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextPreceding() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextPrecedingSibling(self, ctxt): |
| """Traversal function for the "preceding-sibling" direction |
| The preceding-sibling axis contains the preceding siblings |
| of the context node in reverse document order; the first |
| preceding sibling is first on the axis; the sibling |
| preceding that node is the second on the axis and so on. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextPrecedingSibling(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextPrecedingSibling() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextSelf(self, ctxt): |
| """Traversal function for the "self" direction The self axis |
| contains just the context node itself """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlXPathNextSelf(ctxt__o, self._o) |
| if ret is None:raise xpathError('xmlXPathNextSelf() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| # |
| # xmlNode functions from module xpointer |
| # |
| |
| def xpointerNewCollapsedRange(self): |
| """Create a new xmlXPathObjectPtr of type range using a single |
| nodes """ |
| ret = libxml2mod.xmlXPtrNewCollapsedRange(self._o) |
| if ret is None:raise treeError('xmlXPtrNewCollapsedRange() failed') |
| return xpathObjectRet(ret) |
| |
| def xpointerNewContext(self, doc, origin): |
| """Create a new XPointer context """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if origin is None: origin__o = None |
| else: origin__o = origin._o |
| ret = libxml2mod.xmlXPtrNewContext(doc__o, self._o, origin__o) |
| if ret is None:raise treeError('xmlXPtrNewContext() failed') |
| __tmp = xpathContext(_obj=ret) |
| return __tmp |
| |
| def xpointerNewLocationSetNodes(self, end): |
| """Create a new xmlXPathObjectPtr of type LocationSet and |
| initialize it with the single range made of the two nodes |
| @start and @end """ |
| if end is None: end__o = None |
| else: end__o = end._o |
| ret = libxml2mod.xmlXPtrNewLocationSetNodes(self._o, end__o) |
| if ret is None:raise treeError('xmlXPtrNewLocationSetNodes() failed') |
| return xpathObjectRet(ret) |
| |
| def xpointerNewRange(self, startindex, end, endindex): |
| """Create a new xmlXPathObjectPtr of type range """ |
| if end is None: end__o = None |
| else: end__o = end._o |
| ret = libxml2mod.xmlXPtrNewRange(self._o, startindex, end__o, endindex) |
| if ret is None:raise treeError('xmlXPtrNewRange() failed') |
| return xpathObjectRet(ret) |
| |
| def xpointerNewRangeNodes(self, end): |
| """Create a new xmlXPathObjectPtr of type range using 2 nodes """ |
| if end is None: end__o = None |
| else: end__o = end._o |
| ret = libxml2mod.xmlXPtrNewRangeNodes(self._o, end__o) |
| if ret is None:raise treeError('xmlXPtrNewRangeNodes() failed') |
| return xpathObjectRet(ret) |
| |
| class xmlDoc(xmlNode): |
| def __init__(self, _obj=None): |
| if checkWrapper(_obj) != 0: raise TypeError('xmlDoc got a wrong wrapper object type') |
| self._o = _obj |
| xmlNode.__init__(self, _obj=_obj) |
| |
| def __repr__(self): |
| return "<xmlDoc (%s) object at 0x%x>" % (self.name, int(pos_id (self))) |
| |
| # |
| # xmlDoc functions from module HTMLparser |
| # |
| |
| def htmlAutoCloseTag(self, name, elem): |
| """The HTML DTD allows a tag to implicitly close other tags. |
| The list is kept in htmlStartClose array. This function |
| checks if the element or one of it's children would |
| autoclose the given tag. """ |
| ret = libxml2mod.htmlAutoCloseTag(self._o, name, elem) |
| return ret |
| |
| def htmlIsAutoClosed(self, elem): |
| """The HTML DTD allows a tag to implicitly close other tags. |
| The list is kept in htmlStartClose array. This function |
| checks if a tag is autoclosed by one of it's child """ |
| ret = libxml2mod.htmlIsAutoClosed(self._o, elem) |
| return ret |
| |
| # |
| # xmlDoc functions from module HTMLtree |
| # |
| |
| def htmlDocContentDumpFormatOutput(self, buf, encoding, format): |
| """Dump an HTML document. """ |
| if buf is None: buf__o = None |
| else: buf__o = buf._o |
| libxml2mod.htmlDocContentDumpFormatOutput(buf__o, self._o, encoding, format) |
| |
| def htmlDocContentDumpOutput(self, buf, encoding): |
| """Dump an HTML document. Formating return/spaces are added. """ |
| if buf is None: buf__o = None |
| else: buf__o = buf._o |
| libxml2mod.htmlDocContentDumpOutput(buf__o, self._o, encoding) |
| |
| def htmlDocDump(self, f): |
| """Dump an HTML document to an open FILE. """ |
| ret = libxml2mod.htmlDocDump(f, self._o) |
| return ret |
| |
| def htmlGetMetaEncoding(self): |
| """Encoding definition lookup in the Meta tags """ |
| ret = libxml2mod.htmlGetMetaEncoding(self._o) |
| return ret |
| |
| def htmlNodeDumpFile(self, out, cur): |
| """Dump an HTML node, recursive behaviour,children are printed |
| too, and formatting returns are added. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| libxml2mod.htmlNodeDumpFile(out, self._o, cur__o) |
| |
| def htmlNodeDumpFileFormat(self, out, cur, encoding, format): |
| """Dump an HTML node, recursive behaviour,children are printed |
| too. TODO: if encoding == None try to save in the doc |
| encoding """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.htmlNodeDumpFileFormat(out, self._o, cur__o, encoding, format) |
| return ret |
| |
| def htmlNodeDumpFormatOutput(self, buf, cur, encoding, format): |
| """Dump an HTML node, recursive behaviour,children are printed |
| too. """ |
| if buf is None: buf__o = None |
| else: buf__o = buf._o |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| libxml2mod.htmlNodeDumpFormatOutput(buf__o, self._o, cur__o, encoding, format) |
| |
| def htmlNodeDumpOutput(self, buf, cur, encoding): |
| """Dump an HTML node, recursive behaviour,children are printed |
| too, and formatting returns/spaces are added. """ |
| if buf is None: buf__o = None |
| else: buf__o = buf._o |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| libxml2mod.htmlNodeDumpOutput(buf__o, self._o, cur__o, encoding) |
| |
| def htmlSaveFile(self, filename): |
| """Dump an HTML document to a file. If @filename is "-" the |
| stdout file is used. """ |
| ret = libxml2mod.htmlSaveFile(filename, self._o) |
| return ret |
| |
| def htmlSaveFileEnc(self, filename, encoding): |
| """Dump an HTML document to a file using a given encoding and |
| formatting returns/spaces are added. """ |
| ret = libxml2mod.htmlSaveFileEnc(filename, self._o, encoding) |
| return ret |
| |
| def htmlSaveFileFormat(self, filename, encoding, format): |
| """Dump an HTML document to a file using a given encoding. """ |
| ret = libxml2mod.htmlSaveFileFormat(filename, self._o, encoding, format) |
| return ret |
| |
| def htmlSetMetaEncoding(self, encoding): |
| """Sets the current encoding in the Meta tags NOTE: this will |
| not change the document content encoding, just the META |
| flag associated. """ |
| ret = libxml2mod.htmlSetMetaEncoding(self._o, encoding) |
| return ret |
| |
| # |
| # xmlDoc functions from module debugXML |
| # |
| |
| def debugCheckDocument(self, output): |
| """Check the document for potential content problems, and |
| output the errors to @output """ |
| ret = libxml2mod.xmlDebugCheckDocument(output, self._o) |
| return ret |
| |
| def debugDumpDocument(self, output): |
| """Dumps debug information for the document, it's recursive """ |
| libxml2mod.xmlDebugDumpDocument(output, self._o) |
| |
| def debugDumpDocumentHead(self, output): |
| """Dumps debug information cncerning the document, not |
| recursive """ |
| libxml2mod.xmlDebugDumpDocumentHead(output, self._o) |
| |
| def debugDumpEntities(self, output): |
| """Dumps debug information for all the entities in use by the |
| document """ |
| libxml2mod.xmlDebugDumpEntities(output, self._o) |
| |
| # |
| # xmlDoc functions from module entities |
| # |
| |
| def addDocEntity(self, name, type, ExternalID, SystemID, content): |
| """Register a new entity for this document. """ |
| ret = libxml2mod.xmlAddDocEntity(self._o, name, type, ExternalID, SystemID, content) |
| if ret is None:raise treeError('xmlAddDocEntity() failed') |
| __tmp = xmlEntity(_obj=ret) |
| return __tmp |
| |
| def addDtdEntity(self, name, type, ExternalID, SystemID, content): |
| """Register a new entity for this document DTD external subset. """ |
| ret = libxml2mod.xmlAddDtdEntity(self._o, name, type, ExternalID, SystemID, content) |
| if ret is None:raise treeError('xmlAddDtdEntity() failed') |
| __tmp = xmlEntity(_obj=ret) |
| return __tmp |
| |
| def docEntity(self, name): |
| """Do an entity lookup in the document entity hash table and """ |
| ret = libxml2mod.xmlGetDocEntity(self._o, name) |
| if ret is None:raise treeError('xmlGetDocEntity() failed') |
| __tmp = xmlEntity(_obj=ret) |
| return __tmp |
| |
| def dtdEntity(self, name): |
| """Do an entity lookup in the DTD entity hash table and """ |
| ret = libxml2mod.xmlGetDtdEntity(self._o, name) |
| if ret is None:raise treeError('xmlGetDtdEntity() failed') |
| __tmp = xmlEntity(_obj=ret) |
| return __tmp |
| |
| def encodeEntities(self, input): |
| """TODO: remove xmlEncodeEntities, once we are not afraid of |
| breaking binary compatibility People must migrate their |
| code to xmlEncodeEntitiesReentrant ! This routine will |
| issue a warning when encountered. """ |
| ret = libxml2mod.xmlEncodeEntities(self._o, input) |
| return ret |
| |
| def encodeEntitiesReentrant(self, input): |
| """Do a global encoding of a string, replacing the predefined |
| entities and non ASCII values with their entities and |
| CharRef counterparts. Contrary to xmlEncodeEntities, this |
| routine is reentrant, and result must be deallocated. """ |
| ret = libxml2mod.xmlEncodeEntitiesReentrant(self._o, input) |
| return ret |
| |
| def encodeSpecialChars(self, input): |
| """Do a global encoding of a string, replacing the predefined |
| entities this routine is reentrant, and result must be |
| deallocated. """ |
| ret = libxml2mod.xmlEncodeSpecialChars(self._o, input) |
| return ret |
| |
| def newEntity(self, name, type, ExternalID, SystemID, content): |
| """Create a new entity, this differs from xmlAddDocEntity() |
| that if the document is None or has no internal subset |
| defined, then an unlinked entity structure will be |
| returned, it is then the responsability of the caller to |
| link it to the document later or free it when not needed |
| anymore. """ |
| ret = libxml2mod.xmlNewEntity(self._o, name, type, ExternalID, SystemID, content) |
| if ret is None:raise treeError('xmlNewEntity() failed') |
| __tmp = xmlEntity(_obj=ret) |
| return __tmp |
| |
| def parameterEntity(self, name): |
| """Do an entity lookup in the internal and external subsets and """ |
| ret = libxml2mod.xmlGetParameterEntity(self._o, name) |
| if ret is None:raise treeError('xmlGetParameterEntity() failed') |
| __tmp = xmlEntity(_obj=ret) |
| return __tmp |
| |
| # |
| # xmlDoc functions from module relaxng |
| # |
| |
| def relaxNGNewDocParserCtxt(self): |
| """Create an XML RelaxNGs parser context for that document. |
| Note: since the process of compiling a RelaxNG schemas |
| modifies the document, the @doc parameter is duplicated |
| internally. """ |
| ret = libxml2mod.xmlRelaxNGNewDocParserCtxt(self._o) |
| if ret is None:raise parserError('xmlRelaxNGNewDocParserCtxt() failed') |
| __tmp = relaxNgParserCtxt(_obj=ret) |
| return __tmp |
| |
| def relaxNGValidateDoc(self, ctxt): |
| """Validate a document tree in memory. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlRelaxNGValidateDoc(ctxt__o, self._o) |
| return ret |
| |
| def relaxNGValidateFullElement(self, ctxt, elem): |
| """Validate a full subtree when |
| xmlRelaxNGValidatePushElement() returned 0 and the content |
| of the node has been expanded. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlRelaxNGValidateFullElement(ctxt__o, self._o, elem__o) |
| return ret |
| |
| def relaxNGValidatePopElement(self, ctxt, elem): |
| """Pop the element end from the RelaxNG validation stack. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlRelaxNGValidatePopElement(ctxt__o, self._o, elem__o) |
| return ret |
| |
| def relaxNGValidatePushElement(self, ctxt, elem): |
| """Push a new element start on the RelaxNG validation stack. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlRelaxNGValidatePushElement(ctxt__o, self._o, elem__o) |
| return ret |
| |
| # |
| # xmlDoc functions from module tree |
| # |
| |
| def copyDoc(self, recursive): |
| """Do a copy of the document info. If recursive, the content |
| tree will be copied too as well as DTD, namespaces and |
| entities. """ |
| ret = libxml2mod.xmlCopyDoc(self._o, recursive) |
| if ret is None:raise treeError('xmlCopyDoc() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def copyNode(self, node, extended): |
| """Do a copy of the node to a given document. """ |
| if node is None: node__o = None |
| else: node__o = node._o |
| ret = libxml2mod.xmlDocCopyNode(node__o, self._o, extended) |
| if ret is None:raise treeError('xmlDocCopyNode() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def copyNodeList(self, node): |
| """Do a recursive copy of the node list. """ |
| if node is None: node__o = None |
| else: node__o = node._o |
| ret = libxml2mod.xmlDocCopyNodeList(self._o, node__o) |
| if ret is None:raise treeError('xmlDocCopyNodeList() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def createIntSubset(self, name, ExternalID, SystemID): |
| """Create the internal subset of a document """ |
| ret = libxml2mod.xmlCreateIntSubset(self._o, name, ExternalID, SystemID) |
| if ret is None:raise treeError('xmlCreateIntSubset() failed') |
| __tmp = xmlDtd(_obj=ret) |
| return __tmp |
| |
| def docCompressMode(self): |
| """get the compression ratio for a document, ZLIB based """ |
| ret = libxml2mod.xmlGetDocCompressMode(self._o) |
| return ret |
| |
| def dump(self, f): |
| """Dump an XML document to an open FILE. """ |
| ret = libxml2mod.xmlDocDump(f, self._o) |
| return ret |
| |
| def elemDump(self, f, cur): |
| """Dump an XML/HTML node, recursive behaviour, children are |
| printed too. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| libxml2mod.xmlElemDump(f, self._o, cur__o) |
| |
| def formatDump(self, f, format): |
| """Dump an XML document to an open FILE. """ |
| ret = libxml2mod.xmlDocFormatDump(f, self._o, format) |
| return ret |
| |
| def freeDoc(self): |
| """Free up all the structures used by a document, tree |
| included. """ |
| libxml2mod.xmlFreeDoc(self._o) |
| |
| def getRootElement(self): |
| """Get the root element of the document (doc->children is a |
| list containing possibly comments, PIs, etc ...). """ |
| ret = libxml2mod.xmlDocGetRootElement(self._o) |
| if ret is None:raise treeError('xmlDocGetRootElement() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def intSubset(self): |
| """Get the internal subset of a document """ |
| ret = libxml2mod.xmlGetIntSubset(self._o) |
| if ret is None:raise treeError('xmlGetIntSubset() failed') |
| __tmp = xmlDtd(_obj=ret) |
| return __tmp |
| |
| def newCDataBlock(self, content, len): |
| """Creation of a new node containing a CDATA block. """ |
| ret = libxml2mod.xmlNewCDataBlock(self._o, content, len) |
| if ret is None:raise treeError('xmlNewCDataBlock() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newCharRef(self, name): |
| """Creation of a new character reference node. """ |
| ret = libxml2mod.xmlNewCharRef(self._o, name) |
| if ret is None:raise treeError('xmlNewCharRef() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDocComment(self, content): |
| """Creation of a new node containing a comment within a |
| document. """ |
| ret = libxml2mod.xmlNewDocComment(self._o, content) |
| if ret is None:raise treeError('xmlNewDocComment() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDocFragment(self): |
| """Creation of a new Fragment node. """ |
| ret = libxml2mod.xmlNewDocFragment(self._o) |
| if ret is None:raise treeError('xmlNewDocFragment() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDocNode(self, ns, name, content): |
| """Creation of a new node element within a document. @ns and |
| @content are optional (None). NOTE: @content is supposed to |
| be a piece of XML CDATA, so it allow entities references, |
| but XML special chars need to be escaped first by using |
| xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you |
| don't need entities support. """ |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| ret = libxml2mod.xmlNewDocNode(self._o, ns__o, name, content) |
| if ret is None:raise treeError('xmlNewDocNode() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDocNodeEatName(self, ns, name, content): |
| """Creation of a new node element within a document. @ns and |
| @content are optional (None). NOTE: @content is supposed to |
| be a piece of XML CDATA, so it allow entities references, |
| but XML special chars need to be escaped first by using |
| xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you |
| don't need entities support. """ |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| ret = libxml2mod.xmlNewDocNodeEatName(self._o, ns__o, name, content) |
| if ret is None:raise treeError('xmlNewDocNodeEatName() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDocPI(self, name, content): |
| """Creation of a processing instruction element. """ |
| ret = libxml2mod.xmlNewDocPI(self._o, name, content) |
| if ret is None:raise treeError('xmlNewDocPI() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDocProp(self, name, value): |
| """Create a new property carried by a document. """ |
| ret = libxml2mod.xmlNewDocProp(self._o, name, value) |
| if ret is None:raise treeError('xmlNewDocProp() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def newDocRawNode(self, ns, name, content): |
| """Creation of a new node element within a document. @ns and |
| @content are optional (None). """ |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| ret = libxml2mod.xmlNewDocRawNode(self._o, ns__o, name, content) |
| if ret is None:raise treeError('xmlNewDocRawNode() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDocText(self, content): |
| """Creation of a new text node within a document. """ |
| ret = libxml2mod.xmlNewDocText(self._o, content) |
| if ret is None:raise treeError('xmlNewDocText() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDocTextLen(self, content, len): |
| """Creation of a new text node with an extra content length |
| parameter. The text node pertain to a given document. """ |
| ret = libxml2mod.xmlNewDocTextLen(self._o, content, len) |
| if ret is None:raise treeError('xmlNewDocTextLen() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDtd(self, name, ExternalID, SystemID): |
| """Creation of a new DTD for the external subset. To create an |
| internal subset, use xmlCreateIntSubset(). """ |
| ret = libxml2mod.xmlNewDtd(self._o, name, ExternalID, SystemID) |
| if ret is None:raise treeError('xmlNewDtd() failed') |
| __tmp = xmlDtd(_obj=ret) |
| return __tmp |
| |
| def newGlobalNs(self, href, prefix): |
| """Creation of a Namespace, the old way using PI and without |
| scoping DEPRECATED !!! """ |
| ret = libxml2mod.xmlNewGlobalNs(self._o, href, prefix) |
| if ret is None:raise treeError('xmlNewGlobalNs() failed') |
| __tmp = xmlNs(_obj=ret) |
| return __tmp |
| |
| def newReference(self, name): |
| """Creation of a new reference node. """ |
| ret = libxml2mod.xmlNewReference(self._o, name) |
| if ret is None:raise treeError('xmlNewReference() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def nodeDumpOutput(self, buf, cur, level, format, encoding): |
| """Dump an XML node, recursive behaviour, children are printed |
| too. Note that @format = 1 provide node indenting only if |
| xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was |
| called """ |
| if buf is None: buf__o = None |
| else: buf__o = buf._o |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| libxml2mod.xmlNodeDumpOutput(buf__o, self._o, cur__o, level, format, encoding) |
| |
| def nodeGetBase(self, cur): |
| """Searches for the BASE URL. The code should work on both XML |
| and HTML document even if base mechanisms are completely |
| different. It returns the base as defined in RFC 2396 |
| sections 5.1.1. Base URI within Document Content and 5.1.2. |
| Base URI from the Encapsulating Entity However it does not |
| return the document base (5.1.3), use doc->URL in this case """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlNodeGetBase(self._o, cur__o) |
| return ret |
| |
| def nodeListGetRawString(self, list, inLine): |
| """Builds the string equivalent to the text contained in the |
| Node list made of TEXTs and ENTITY_REFs, contrary to |
| xmlNodeListGetString() this function doesn't do any |
| character encoding handling. """ |
| if list is None: list__o = None |
| else: list__o = list._o |
| ret = libxml2mod.xmlNodeListGetRawString(self._o, list__o, inLine) |
| return ret |
| |
| def nodeListGetString(self, list, inLine): |
| """Build the string equivalent to the text contained in the |
| Node list made of TEXTs and ENTITY_REFs """ |
| if list is None: list__o = None |
| else: list__o = list._o |
| ret = libxml2mod.xmlNodeListGetString(self._o, list__o, inLine) |
| return ret |
| |
| def reconciliateNs(self, tree): |
| """This function checks that all the namespaces declared |
| within the given tree are properly declared. This is needed |
| for example after Copy or Cut and then paste operations. |
| The subtree may still hold pointers to namespace |
| declarations outside the subtree or invalid/masked. As much |
| as possible the function try to reuse the existing |
| namespaces found in the new environment. If not possible |
| the new namespaces are redeclared on @tree at the top of |
| the given subtree. """ |
| if tree is None: tree__o = None |
| else: tree__o = tree._o |
| ret = libxml2mod.xmlReconciliateNs(self._o, tree__o) |
| return ret |
| |
| def saveFile(self, filename): |
| """Dump an XML document to a file. Will use compression if |
| compiled in and enabled. If @filename is "-" the stdout |
| file is used. """ |
| ret = libxml2mod.xmlSaveFile(filename, self._o) |
| return ret |
| |
| def saveFileEnc(self, filename, encoding): |
| """Dump an XML document, converting it to the given encoding """ |
| ret = libxml2mod.xmlSaveFileEnc(filename, self._o, encoding) |
| return ret |
| |
| def saveFileTo(self, buf, encoding): |
| """Dump an XML document to an I/O buffer. Warning ! This call |
| xmlOutputBufferClose() on buf which is not available after |
| this call. """ |
| if buf is None: buf__o = None |
| else: buf__o = buf._o |
| ret = libxml2mod.xmlSaveFileTo(buf__o, self._o, encoding) |
| return ret |
| |
| def saveFormatFile(self, filename, format): |
| """Dump an XML document to a file. Will use compression if |
| compiled in and enabled. If @filename is "-" the stdout |
| file is used. If @format is set then the document will be |
| indented on output. Note that @format = 1 provide node |
| indenting only if xmlIndentTreeOutput = 1 or |
| xmlKeepBlanksDefault(0) was called """ |
| ret = libxml2mod.xmlSaveFormatFile(filename, self._o, format) |
| return ret |
| |
| def saveFormatFileEnc(self, filename, encoding, format): |
| """Dump an XML document to a file or an URL. """ |
| ret = libxml2mod.xmlSaveFormatFileEnc(filename, self._o, encoding, format) |
| return ret |
| |
| def saveFormatFileTo(self, buf, encoding, format): |
| """Dump an XML document to an I/O buffer. Warning ! This call |
| xmlOutputBufferClose() on buf which is not available after |
| this call. """ |
| if buf is None: buf__o = None |
| else: buf__o = buf._o |
| ret = libxml2mod.xmlSaveFormatFileTo(buf__o, self._o, encoding, format) |
| return ret |
| |
| def searchNs(self, node, nameSpace): |
| """Search a Ns registered under a given name space for a |
| document. recurse on the parents until it finds the defined |
| namespace or return None otherwise. @nameSpace can be None, |
| this is a search for the default namespace. We don't allow |
| to cross entities boundaries. If you don't declare the |
| namespace within those you will be in troubles !!! A |
| warning is generated to cover this case. """ |
| if node is None: node__o = None |
| else: node__o = node._o |
| ret = libxml2mod.xmlSearchNs(self._o, node__o, nameSpace) |
| if ret is None:raise treeError('xmlSearchNs() failed') |
| __tmp = xmlNs(_obj=ret) |
| return __tmp |
| |
| def searchNsByHref(self, node, href): |
| """Search a Ns aliasing a given URI. Recurse on the parents |
| until it finds the defined namespace or return None |
| otherwise. """ |
| if node is None: node__o = None |
| else: node__o = node._o |
| ret = libxml2mod.xmlSearchNsByHref(self._o, node__o, href) |
| if ret is None:raise treeError('xmlSearchNsByHref() failed') |
| __tmp = xmlNs(_obj=ret) |
| return __tmp |
| |
| def setDocCompressMode(self, mode): |
| """set the compression ratio for a document, ZLIB based |
| Correct values: 0 (uncompressed) to 9 (max compression) """ |
| libxml2mod.xmlSetDocCompressMode(self._o, mode) |
| |
| def setListDoc(self, list): |
| """update all nodes in the list to point to the right document """ |
| if list is None: list__o = None |
| else: list__o = list._o |
| libxml2mod.xmlSetListDoc(list__o, self._o) |
| |
| def setRootElement(self, root): |
| """Set the root element of the document (doc->children is a |
| list containing possibly comments, PIs, etc ...). """ |
| if root is None: root__o = None |
| else: root__o = root._o |
| ret = libxml2mod.xmlDocSetRootElement(self._o, root__o) |
| if ret is None:return None |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def setTreeDoc(self, tree): |
| """update all nodes under the tree to point to the right |
| document """ |
| if tree is None: tree__o = None |
| else: tree__o = tree._o |
| libxml2mod.xmlSetTreeDoc(tree__o, self._o) |
| |
| def stringGetNodeList(self, value): |
| """Parse the value string and build the node list associated. |
| Should produce a flat tree with only TEXTs and ENTITY_REFs. """ |
| ret = libxml2mod.xmlStringGetNodeList(self._o, value) |
| if ret is None:raise treeError('xmlStringGetNodeList() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def stringLenGetNodeList(self, value, len): |
| """Parse the value string and build the node list associated. |
| Should produce a flat tree with only TEXTs and ENTITY_REFs. """ |
| ret = libxml2mod.xmlStringLenGetNodeList(self._o, value, len) |
| if ret is None:raise treeError('xmlStringLenGetNodeList() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| # |
| # xmlDoc functions from module valid |
| # |
| |
| def ID(self, ID): |
| """Search the attribute declaring the given ID """ |
| ret = libxml2mod.xmlGetID(self._o, ID) |
| if ret is None:raise treeError('xmlGetID() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def isID(self, elem, attr): |
| """Determine whether an attribute is of type ID. In case we |
| have DTD(s) then this is done if DTD loading has been |
| requested. In the case of HTML documents parsed with the |
| HTML parser, then ID detection is done systematically. """ |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| if attr is None: attr__o = None |
| else: attr__o = attr._o |
| ret = libxml2mod.xmlIsID(self._o, elem__o, attr__o) |
| return ret |
| |
| def isMixedElement(self, name): |
| """Search in the DtDs whether an element accept Mixed content |
| (or ANY) basically if it is supposed to accept text childs """ |
| ret = libxml2mod.xmlIsMixedElement(self._o, name) |
| return ret |
| |
| def isRef(self, elem, attr): |
| """Determine whether an attribute is of type Ref. In case we |
| have DTD(s) then this is simple, otherwise we use an |
| heuristic: name Ref (upper or lowercase). """ |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| if attr is None: attr__o = None |
| else: attr__o = attr._o |
| ret = libxml2mod.xmlIsRef(self._o, elem__o, attr__o) |
| return ret |
| |
| def removeID(self, attr): |
| """Remove the given attribute from the ID table maintained |
| internally. """ |
| if attr is None: attr__o = None |
| else: attr__o = attr._o |
| ret = libxml2mod.xmlRemoveID(self._o, attr__o) |
| return ret |
| |
| def removeRef(self, attr): |
| """Remove the given attribute from the Ref table maintained |
| internally. """ |
| if attr is None: attr__o = None |
| else: attr__o = attr._o |
| ret = libxml2mod.xmlRemoveRef(self._o, attr__o) |
| return ret |
| |
| def validCtxtNormalizeAttributeValue(self, ctxt, elem, name, value): |
| """Does the validation related extra step of the normalization |
| of attribute values: If the declared value is not CDATA, |
| then the XML processor must further process the normalized |
| attribute value by discarding any leading and trailing |
| space (#x20) characters, and by replacing sequences of |
| space (#x20) characters by single space (#x20) character. |
| Also check VC: Standalone Document Declaration in P32, and |
| update ctxt->valid accordingly """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlValidCtxtNormalizeAttributeValue(ctxt__o, self._o, elem__o, name, value) |
| return ret |
| |
| def validNormalizeAttributeValue(self, elem, name, value): |
| """Does the validation related extra step of the normalization |
| of attribute values: If the declared value is not CDATA, |
| then the XML processor must further process the normalized |
| attribute value by discarding any leading and trailing |
| space (#x20) characters, and by replacing sequences of |
| space (#x20) characters by single space (#x20) character. """ |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlValidNormalizeAttributeValue(self._o, elem__o, name, value) |
| return ret |
| |
| def validateDocument(self, ctxt): |
| """Try to validate the document instance basically it does |
| the all the checks described by the XML Rec i.e. validates |
| the internal and external subset (if present) and validate |
| the document tree. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlValidateDocument(ctxt__o, self._o) |
| return ret |
| |
| def validateDocumentFinal(self, ctxt): |
| """Does the final step for the document validation once all |
| the incremental validation steps have been completed |
| basically it does the following checks described by the XML |
| Rec Check all the IDREF/IDREFS attributes definition for |
| validity """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlValidateDocumentFinal(ctxt__o, self._o) |
| return ret |
| |
| def validateDtd(self, ctxt, dtd): |
| """Try to validate the document against the dtd instance |
| Basically it does check all the definitions in the DtD. |
| Note the the internal subset (if present) is de-coupled |
| (i.e. not used), which could give problems if ID or IDREF |
| is present. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if dtd is None: dtd__o = None |
| else: dtd__o = dtd._o |
| ret = libxml2mod.xmlValidateDtd(ctxt__o, self._o, dtd__o) |
| return ret |
| |
| def validateDtdFinal(self, ctxt): |
| """Does the final step for the dtds validation once all the |
| subsets have been parsed basically it does the following |
| checks described by the XML Rec - check that ENTITY and |
| ENTITIES type attributes default or possible values matches |
| one of the defined entities. - check that NOTATION type |
| attributes default or possible values matches one of the |
| defined notations. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlValidateDtdFinal(ctxt__o, self._o) |
| return ret |
| |
| def validateElement(self, ctxt, elem): |
| """Try to validate the subtree under an element """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlValidateElement(ctxt__o, self._o, elem__o) |
| return ret |
| |
| def validateNotationUse(self, ctxt, notationName): |
| """Validate that the given name match a notation declaration. |
| - [ VC: Notation Declared ] """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlValidateNotationUse(ctxt__o, self._o, notationName) |
| return ret |
| |
| def validateOneAttribute(self, ctxt, elem, attr, value): |
| """Try to validate a single attribute for an element basically |
| it does the following checks as described by the XML-1.0 |
| recommendation: - [ VC: Attribute Value Type ] - [ VC: |
| Fixed Attribute Default ] - [ VC: Entity Name ] - [ VC: |
| Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC: Entity |
| Name ] - [ VC: Notation Attributes ] The ID/IDREF |
| uniqueness and matching are done separately """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| if attr is None: attr__o = None |
| else: attr__o = attr._o |
| ret = libxml2mod.xmlValidateOneAttribute(ctxt__o, self._o, elem__o, attr__o, value) |
| return ret |
| |
| def validateOneElement(self, ctxt, elem): |
| """Try to validate a single element and it's attributes, |
| basically it does the following checks as described by the |
| XML-1.0 recommendation: - [ VC: Element Valid ] - [ VC: |
| Required Attribute ] Then call xmlValidateOneAttribute() |
| for each attribute present. The ID/IDREF checkings are |
| done separately """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlValidateOneElement(ctxt__o, self._o, elem__o) |
| return ret |
| |
| def validateOneNamespace(self, ctxt, elem, prefix, ns, value): |
| """Try to validate a single namespace declaration for an |
| element basically it does the following checks as described |
| by the XML-1.0 recommendation: - [ VC: Attribute Value Type |
| ] - [ VC: Fixed Attribute Default ] - [ VC: Entity Name ] - |
| [ VC: Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC: |
| Entity Name ] - [ VC: Notation Attributes ] The ID/IDREF |
| uniqueness and matching are done separately """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| ret = libxml2mod.xmlValidateOneNamespace(ctxt__o, self._o, elem__o, prefix, ns__o, value) |
| return ret |
| |
| def validatePopElement(self, ctxt, elem, qname): |
| """Pop the element end from the validation stack. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlValidatePopElement(ctxt__o, self._o, elem__o, qname) |
| return ret |
| |
| def validatePushElement(self, ctxt, elem, qname): |
| """Push a new element start on the validation stack. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlValidatePushElement(ctxt__o, self._o, elem__o, qname) |
| return ret |
| |
| def validateRoot(self, ctxt): |
| """Try to validate a the root element basically it does the |
| following check as described by the XML-1.0 recommendation: |
| - [ VC: Root Element Type ] it doesn't try to recurse or |
| apply other check to the element """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlValidateRoot(ctxt__o, self._o) |
| return ret |
| |
| # |
| # xmlDoc functions from module xinclude |
| # |
| |
| def xincludeProcess(self): |
| """Implement the XInclude substitution on the XML document @doc """ |
| ret = libxml2mod.xmlXIncludeProcess(self._o) |
| return ret |
| |
| def xincludeProcessFlags(self, flags): |
| """Implement the XInclude substitution on the XML document @doc """ |
| ret = libxml2mod.xmlXIncludeProcessFlags(self._o, flags) |
| return ret |
| |
| # |
| # xmlDoc functions from module xmlreader |
| # |
| |
| def NewWalker(self, reader): |
| """Setup an xmltextReader to parse a preparsed XML document. |
| This reuses the existing @reader xmlTextReader. """ |
| if reader is None: reader__o = None |
| else: reader__o = reader._o |
| ret = libxml2mod.xmlReaderNewWalker(reader__o, self._o) |
| return ret |
| |
| def readerWalker(self): |
| """Create an xmltextReader for a preparsed document. """ |
| ret = libxml2mod.xmlReaderWalker(self._o) |
| if ret is None:raise treeError('xmlReaderWalker() failed') |
| __tmp = xmlTextReader(_obj=ret) |
| return __tmp |
| |
| # |
| # xmlDoc functions from module xmlschemas |
| # |
| |
| def schemaNewDocParserCtxt(self): |
| """Create an XML Schemas parse context for that document. NB. |
| The document may be modified during the parsing process. """ |
| ret = libxml2mod.xmlSchemaNewDocParserCtxt(self._o) |
| if ret is None:raise parserError('xmlSchemaNewDocParserCtxt() failed') |
| __tmp = SchemaParserCtxt(_obj=ret) |
| return __tmp |
| |
| def schemaValidateDoc(self, ctxt): |
| """Validate a document tree in memory. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlSchemaValidateDoc(ctxt__o, self._o) |
| return ret |
| |
| # |
| # xmlDoc functions from module xpath |
| # |
| |
| def xpathNewContext(self): |
| """Create a new xmlXPathContext """ |
| ret = libxml2mod.xmlXPathNewContext(self._o) |
| if ret is None:raise xpathError('xmlXPathNewContext() failed') |
| __tmp = xpathContext(_obj=ret) |
| return __tmp |
| |
| def xpathOrderDocElems(self): |
| """Call this routine to speed up XPath computation on static |
| documents. This stamps all the element nodes with the |
| document order Like for line information, the order is kept |
| in the element->content field, the value stored is actually |
| - the node number (starting at -1) to be able to |
| differentiate from line numbers. """ |
| ret = libxml2mod.xmlXPathOrderDocElems(self._o) |
| return ret |
| |
| # |
| # xmlDoc functions from module xpointer |
| # |
| |
| def xpointerNewContext(self, here, origin): |
| """Create a new XPointer context """ |
| if here is None: here__o = None |
| else: here__o = here._o |
| if origin is None: origin__o = None |
| else: origin__o = origin._o |
| ret = libxml2mod.xmlXPtrNewContext(self._o, here__o, origin__o) |
| if ret is None:raise treeError('xmlXPtrNewContext() failed') |
| __tmp = xpathContext(_obj=ret) |
| return __tmp |
| |
| class parserCtxt(parserCtxtCore): |
| def __init__(self, _obj=None): |
| self._o = _obj |
| parserCtxtCore.__init__(self, _obj=_obj) |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlFreeParserCtxt(self._o) |
| self._o = None |
| |
| # accessors for parserCtxt |
| def doc(self): |
| """Get the document tree from a parser context. """ |
| ret = libxml2mod.xmlParserGetDoc(self._o) |
| if ret is None:raise parserError('xmlParserGetDoc() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def isValid(self): |
| """Get the validity information from a parser context. """ |
| ret = libxml2mod.xmlParserGetIsValid(self._o) |
| return ret |
| |
| def lineNumbers(self, linenumbers): |
| """Switch on the generation of line number for elements nodes. """ |
| libxml2mod.xmlParserSetLineNumbers(self._o, linenumbers) |
| |
| def loadSubset(self, loadsubset): |
| """Switch the parser to load the DTD without validating. """ |
| libxml2mod.xmlParserSetLoadSubset(self._o, loadsubset) |
| |
| def pedantic(self, pedantic): |
| """Switch the parser to be pedantic. """ |
| libxml2mod.xmlParserSetPedantic(self._o, pedantic) |
| |
| def replaceEntities(self, replaceEntities): |
| """Switch the parser to replace entities. """ |
| libxml2mod.xmlParserSetReplaceEntities(self._o, replaceEntities) |
| |
| def validate(self, validate): |
| """Switch the parser to validation mode. """ |
| libxml2mod.xmlParserSetValidate(self._o, validate) |
| |
| def wellFormed(self): |
| """Get the well formed information from a parser context. """ |
| ret = libxml2mod.xmlParserGetWellFormed(self._o) |
| return ret |
| |
| # |
| # parserCtxt functions from module HTMLparser |
| # |
| |
| def htmlCtxtReadDoc(self, cur, URL, encoding, options): |
| """parse an XML in-memory document and build a tree. This |
| reuses the existing @ctxt parser context """ |
| ret = libxml2mod.htmlCtxtReadDoc(self._o, cur, URL, encoding, options) |
| if ret is None:raise treeError('htmlCtxtReadDoc() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def htmlCtxtReadFd(self, fd, URL, encoding, options): |
| """parse an XML from a file descriptor and build a tree. This |
| reuses the existing @ctxt parser context """ |
| ret = libxml2mod.htmlCtxtReadFd(self._o, fd, URL, encoding, options) |
| if ret is None:raise treeError('htmlCtxtReadFd() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def htmlCtxtReadFile(self, filename, encoding, options): |
| """parse an XML file from the filesystem or the network. This |
| reuses the existing @ctxt parser context """ |
| ret = libxml2mod.htmlCtxtReadFile(self._o, filename, encoding, options) |
| if ret is None:raise treeError('htmlCtxtReadFile() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def htmlCtxtReadMemory(self, buffer, size, URL, encoding, options): |
| """parse an XML in-memory document and build a tree. This |
| reuses the existing @ctxt parser context """ |
| ret = libxml2mod.htmlCtxtReadMemory(self._o, buffer, size, URL, encoding, options) |
| if ret is None:raise treeError('htmlCtxtReadMemory() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def htmlCtxtReset(self): |
| """Reset a parser context """ |
| libxml2mod.htmlCtxtReset(self._o) |
| |
| def htmlCtxtUseOptions(self, options): |
| """Applies the options to the parser context """ |
| ret = libxml2mod.htmlCtxtUseOptions(self._o, options) |
| return ret |
| |
| def htmlFreeParserCtxt(self): |
| """Free all the memory used by a parser context. However the |
| parsed document in ctxt->myDoc is not freed. """ |
| libxml2mod.htmlFreeParserCtxt(self._o) |
| |
| def htmlParseCharRef(self): |
| """parse Reference declarations [66] CharRef ::= '&#' [0-9]+ |
| ';' | '&#x' [0-9a-fA-F]+ ';' """ |
| ret = libxml2mod.htmlParseCharRef(self._o) |
| return ret |
| |
| def htmlParseChunk(self, chunk, size, terminate): |
| """Parse a Chunk of memory """ |
| ret = libxml2mod.htmlParseChunk(self._o, chunk, size, terminate) |
| return ret |
| |
| def htmlParseDocument(self): |
| """parse an HTML document (and build a tree if using the |
| standard SAX interface). """ |
| ret = libxml2mod.htmlParseDocument(self._o) |
| return ret |
| |
| def htmlParseElement(self): |
| """parse an HTML element, this is highly recursive this is |
| kept for compatibility with previous code versions [39] |
| element ::= EmptyElemTag | STag content ETag [41] |
| Attribute ::= Name Eq AttValue """ |
| libxml2mod.htmlParseElement(self._o) |
| |
| # |
| # parserCtxt functions from module parser |
| # |
| |
| def byteConsumed(self): |
| """This function provides the current index of the parser |
| relative to the start of the current entity. This function |
| is computed in bytes from the beginning starting at zero |
| and finishing at the size in byte of the file if parsing a |
| file. The function is of constant cost if the input is |
| UTF-8 but can be costly if run on non-UTF-8 input. """ |
| ret = libxml2mod.xmlByteConsumed(self._o) |
| return ret |
| |
| def clearParserCtxt(self): |
| """Clear (release owned resources) and reinitialize a parser |
| context """ |
| libxml2mod.xmlClearParserCtxt(self._o) |
| |
| def ctxtReadDoc(self, cur, URL, encoding, options): |
| """parse an XML in-memory document and build a tree. This |
| reuses the existing @ctxt parser context """ |
| ret = libxml2mod.xmlCtxtReadDoc(self._o, cur, URL, encoding, options) |
| if ret is None:raise treeError('xmlCtxtReadDoc() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def ctxtReadFd(self, fd, URL, encoding, options): |
| """parse an XML from a file descriptor and build a tree. This |
| reuses the existing @ctxt parser context NOTE that the file |
| descriptor will not be closed when the reader is closed or |
| reset. """ |
| ret = libxml2mod.xmlCtxtReadFd(self._o, fd, URL, encoding, options) |
| if ret is None:raise treeError('xmlCtxtReadFd() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def ctxtReadFile(self, filename, encoding, options): |
| """parse an XML file from the filesystem or the network. This |
| reuses the existing @ctxt parser context """ |
| ret = libxml2mod.xmlCtxtReadFile(self._o, filename, encoding, options) |
| if ret is None:raise treeError('xmlCtxtReadFile() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def ctxtReadMemory(self, buffer, size, URL, encoding, options): |
| """parse an XML in-memory document and build a tree. This |
| reuses the existing @ctxt parser context """ |
| ret = libxml2mod.xmlCtxtReadMemory(self._o, buffer, size, URL, encoding, options) |
| if ret is None:raise treeError('xmlCtxtReadMemory() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def ctxtReset(self): |
| """Reset a parser context """ |
| libxml2mod.xmlCtxtReset(self._o) |
| |
| def ctxtResetPush(self, chunk, size, filename, encoding): |
| """Reset a push parser context """ |
| ret = libxml2mod.xmlCtxtResetPush(self._o, chunk, size, filename, encoding) |
| return ret |
| |
| def ctxtUseOptions(self, options): |
| """Applies the options to the parser context """ |
| ret = libxml2mod.xmlCtxtUseOptions(self._o, options) |
| return ret |
| |
| def initParserCtxt(self): |
| """Initialize a parser context """ |
| ret = libxml2mod.xmlInitParserCtxt(self._o) |
| return ret |
| |
| def parseChunk(self, chunk, size, terminate): |
| """Parse a Chunk of memory """ |
| ret = libxml2mod.xmlParseChunk(self._o, chunk, size, terminate) |
| return ret |
| |
| def parseDocument(self): |
| """parse an XML document (and build a tree if using the |
| standard SAX interface). [1] document ::= prolog element |
| Misc* [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)? """ |
| ret = libxml2mod.xmlParseDocument(self._o) |
| return ret |
| |
| def parseExtParsedEnt(self): |
| """parse a general parsed entity An external general parsed |
| entity is well-formed if it matches the production labeled |
| extParsedEnt. [78] extParsedEnt ::= TextDecl? content """ |
| ret = libxml2mod.xmlParseExtParsedEnt(self._o) |
| return ret |
| |
| def setupParserForBuffer(self, buffer, filename): |
| """Setup the parser context to parse a new buffer; Clears any |
| prior contents from the parser context. The buffer |
| parameter must not be None, but the filename parameter can |
| be """ |
| libxml2mod.xmlSetupParserForBuffer(self._o, buffer, filename) |
| |
| def stopParser(self): |
| """Blocks further parser processing """ |
| libxml2mod.xmlStopParser(self._o) |
| |
| # |
| # parserCtxt functions from module parserInternals |
| # |
| |
| def decodeEntities(self, len, what, end, end2, end3): |
| """This function is deprecated, we now always process entities |
| content through xmlStringDecodeEntities TODO: remove it in |
| next major release. [67] Reference ::= EntityRef | CharRef |
| [69] PEReference ::= '%' Name ';' """ |
| ret = libxml2mod.xmlDecodeEntities(self._o, len, what, end, end2, end3) |
| return ret |
| |
| def handleEntity(self, entity): |
| """Default handling of defined entities, when should we define |
| a new input stream ? When do we just handle that as a set |
| of chars ? OBSOLETE: to be removed at some point. """ |
| if entity is None: entity__o = None |
| else: entity__o = entity._o |
| libxml2mod.xmlHandleEntity(self._o, entity__o) |
| |
| def namespaceParseNCName(self): |
| """parse an XML namespace name. TODO: this seems not in use |
| anymore, the namespace handling is done on top of the SAX |
| interfaces, i.e. not on raw input. [NS 3] NCName ::= |
| (Letter | '_') (NCNameChar)* [NS 4] NCNameChar ::= Letter |
| | Digit | '.' | '-' | '_' | CombiningChar | Extender """ |
| ret = libxml2mod.xmlNamespaceParseNCName(self._o) |
| return ret |
| |
| def namespaceParseNSDef(self): |
| """parse a namespace prefix declaration TODO: this seems not |
| in use anymore, the namespace handling is done on top of |
| the SAX interfaces, i.e. not on raw input. [NS 1] NSDef |
| ::= PrefixDef Eq SystemLiteral [NS 2] PrefixDef ::= |
| 'xmlns' (':' NCName)? """ |
| ret = libxml2mod.xmlNamespaceParseNSDef(self._o) |
| return ret |
| |
| def nextChar(self): |
| """Skip to the next char input char. """ |
| libxml2mod.xmlNextChar(self._o) |
| |
| def parseAttValue(self): |
| """parse a value for an attribute Note: the parser won't do |
| substitution of entities here, this will be handled later |
| in xmlStringGetNodeList [10] AttValue ::= '"' ([^<&"] | |
| Reference)* '"' | "'" ([^<&'] | Reference)* "'" 3.3.3 |
| Attribute-Value Normalization: Before the value of an |
| attribute is passed to the application or checked for |
| validity, the XML processor must normalize it as follows: - |
| a character reference is processed by appending the |
| referenced character to the attribute value - an entity |
| reference is processed by recursively processing the |
| replacement text of the entity - a whitespace character |
| (#x20, #xD, #xA, #x9) is processed by appending #x20 to the |
| normalized value, except that only a single #x20 is |
| appended for a "#xD#xA" sequence that is part of an |
| external parsed entity or the literal entity value of an |
| internal parsed entity - other characters are processed by |
| appending them to the normalized value If the declared |
| value is not CDATA, then the XML processor must further |
| process the normalized attribute value by discarding any |
| leading and trailing space (#x20) characters, and by |
| replacing sequences of space (#x20) characters by a single |
| space (#x20) character. All attributes for which no |
| declaration has been read should be treated by a |
| non-validating parser as if declared CDATA. """ |
| ret = libxml2mod.xmlParseAttValue(self._o) |
| return ret |
| |
| def parseAttributeListDecl(self): |
| """: parse the Attribute list def for an element [52] |
| AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>' [53] |
| AttDef ::= S Name S AttType S DefaultDecl """ |
| libxml2mod.xmlParseAttributeListDecl(self._o) |
| |
| def parseCDSect(self): |
| """Parse escaped pure raw content. [18] CDSect ::= CDStart |
| CData CDEnd [19] CDStart ::= '<![CDATA[' [20] Data ::= |
| (Char* - (Char* ']]>' Char*)) [21] CDEnd ::= ']]>' """ |
| libxml2mod.xmlParseCDSect(self._o) |
| |
| def parseCharData(self, cdata): |
| """parse a CharData section. if we are within a CDATA section |
| ']]>' marks an end of section. The right angle bracket (>) |
| may be represented using the string ">", and must, for |
| compatibility, be escaped using ">" or a character |
| reference when it appears in the string "]]>" in content, |
| when that string is not marking the end of a CDATA section. |
| [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) """ |
| libxml2mod.xmlParseCharData(self._o, cdata) |
| |
| def parseCharRef(self): |
| """parse Reference declarations [66] CharRef ::= '&#' [0-9]+ |
| ';' | '&#x' [0-9a-fA-F]+ ';' [ WFC: Legal Character ] |
| Characters referred to using character references must |
| match the production for Char. """ |
| ret = libxml2mod.xmlParseCharRef(self._o) |
| return ret |
| |
| def parseComment(self): |
| """Skip an XML (SGML) comment <!-- .... --> The spec says that |
| "For compatibility, the string "--" (double-hyphen) must |
| not occur within comments. " [15] Comment ::= '<!--' |
| ((Char - '-') | ('-' (Char - '-')))* '-->' """ |
| libxml2mod.xmlParseComment(self._o) |
| |
| def parseContent(self): |
| """Parse a content: [43] content ::= (element | CharData | |
| Reference | CDSect | PI | Comment)* """ |
| libxml2mod.xmlParseContent(self._o) |
| |
| def parseDocTypeDecl(self): |
| """parse a DOCTYPE declaration [28] doctypedecl ::= |
| '<!DOCTYPE' S Name (S ExternalID)? S? ('[' (markupdecl | |
| PEReference | S)* ']' S?)? '>' [ VC: Root Element Type ] |
| The Name in the document type declaration must match the |
| element type of the root element. """ |
| libxml2mod.xmlParseDocTypeDecl(self._o) |
| |
| def parseElement(self): |
| """parse an XML element, this is highly recursive [39] |
| element ::= EmptyElemTag | STag content ETag [ WFC: |
| Element Type Match ] The Name in an element's end-tag must |
| match the element type in the start-tag. """ |
| libxml2mod.xmlParseElement(self._o) |
| |
| def parseElementDecl(self): |
| """parse an Element declaration. [45] elementdecl ::= |
| '<!ELEMENT' S Name S contentspec S? '>' [ VC: Unique |
| Element Type Declaration ] No element type may be declared |
| more than once """ |
| ret = libxml2mod.xmlParseElementDecl(self._o) |
| return ret |
| |
| def parseEncName(self): |
| """parse the XML encoding name [81] EncName ::= [A-Za-z] |
| ([A-Za-z0-9._] | '-')* """ |
| ret = libxml2mod.xmlParseEncName(self._o) |
| return ret |
| |
| def parseEncodingDecl(self): |
| """parse the XML encoding declaration [80] EncodingDecl ::= S |
| 'encoding' Eq ('"' EncName '"' | "'" EncName "'") this |
| setups the conversion filters. """ |
| ret = libxml2mod.xmlParseEncodingDecl(self._o) |
| return ret |
| |
| def parseEndTag(self): |
| """parse an end of tag [42] ETag ::= '</' Name S? '>' With |
| namespace [NS 9] ETag ::= '</' QName S? '>' """ |
| libxml2mod.xmlParseEndTag(self._o) |
| |
| def parseEntityDecl(self): |
| """parse <!ENTITY declarations [70] EntityDecl ::= GEDecl | |
| PEDecl [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? |
| '>' [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>' |
| [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?) |
| [74] PEDef ::= EntityValue | ExternalID [76] NDataDecl ::= |
| S 'NDATA' S Name [ VC: Notation Declared ] The Name must |
| match the declared name of a notation. """ |
| libxml2mod.xmlParseEntityDecl(self._o) |
| |
| def parseEntityRef(self): |
| """parse ENTITY references declarations [68] EntityRef ::= |
| '&' Name ';' [ WFC: Entity Declared ] In a document |
| without any DTD, a document with only an internal DTD |
| subset which contains no parameter entity references, or a |
| document with "standalone='yes'", the Name given in the |
| entity reference must match that in an entity declaration, |
| except that well-formed documents need not declare any of |
| the following entities: amp, lt, gt, apos, quot. The |
| declaration of a parameter entity must precede any |
| reference to it. Similarly, the declaration of a general |
| entity must precede any reference to it which appears in a |
| default value in an attribute-list declaration. Note that |
| if entities are declared in the external subset or in |
| external parameter entities, a non-validating processor is |
| not obligated to read and process their declarations; for |
| such documents, the rule that an entity must be declared is |
| a well-formedness constraint only if standalone='yes'. [ |
| WFC: Parsed Entity ] An entity reference must not contain |
| the name of an unparsed entity """ |
| ret = libxml2mod.xmlParseEntityRef(self._o) |
| if ret is None:raise parserError('xmlParseEntityRef() failed') |
| __tmp = xmlEntity(_obj=ret) |
| return __tmp |
| |
| def parseExternalSubset(self, ExternalID, SystemID): |
| """parse Markup declarations from an external subset [30] |
| extSubset ::= textDecl? extSubsetDecl [31] extSubsetDecl |
| ::= (markupdecl | conditionalSect | PEReference | S) * """ |
| libxml2mod.xmlParseExternalSubset(self._o, ExternalID, SystemID) |
| |
| def parseMarkupDecl(self): |
| """parse Markup declarations [29] markupdecl ::= elementdecl |
| | AttlistDecl | EntityDecl | NotationDecl | PI | Comment [ |
| VC: Proper Declaration/PE Nesting ] Parameter-entity |
| replacement text must be properly nested with markup |
| declarations. That is to say, if either the first character |
| or the last character of a markup declaration (markupdecl |
| above) is contained in the replacement text for a |
| parameter-entity reference, both must be contained in the |
| same replacement text. [ WFC: PEs in Internal Subset ] In |
| the internal DTD subset, parameter-entity references can |
| occur only where markup declarations can occur, not within |
| markup declarations. (This does not apply to references |
| that occur in external parameter entities or to the |
| external subset.) """ |
| libxml2mod.xmlParseMarkupDecl(self._o) |
| |
| def parseMisc(self): |
| """parse an XML Misc* optional field. [27] Misc ::= Comment | |
| PI | S """ |
| libxml2mod.xmlParseMisc(self._o) |
| |
| def parseName(self): |
| """parse an XML name. [4] NameChar ::= Letter | Digit | '.' | |
| '-' | '_' | ':' | CombiningChar | Extender [5] Name ::= |
| (Letter | '_' | ':') (NameChar)* [6] Names ::= Name (#x20 |
| Name)* """ |
| ret = libxml2mod.xmlParseName(self._o) |
| return ret |
| |
| def parseNamespace(self): |
| """xmlParseNamespace: parse specific PI '<?namespace ...' |
| constructs. This is what the older xml-name Working Draft |
| specified, a bunch of other stuff may still rely on it, so |
| support is still here as if it was declared on the root of |
| the Tree:-( TODO: remove from library To be removed at |
| next drop of binary compatibility """ |
| libxml2mod.xmlParseNamespace(self._o) |
| |
| def parseNmtoken(self): |
| """parse an XML Nmtoken. [7] Nmtoken ::= (NameChar)+ [8] |
| Nmtokens ::= Nmtoken (#x20 Nmtoken)* """ |
| ret = libxml2mod.xmlParseNmtoken(self._o) |
| return ret |
| |
| def parseNotationDecl(self): |
| """parse a notation declaration [82] NotationDecl ::= |
| '<!NOTATION' S Name S (ExternalID | PublicID) S? '>' |
| Hence there is actually 3 choices: 'PUBLIC' S PubidLiteral |
| 'PUBLIC' S PubidLiteral S SystemLiteral and 'SYSTEM' S |
| SystemLiteral See the NOTE on xmlParseExternalID(). """ |
| libxml2mod.xmlParseNotationDecl(self._o) |
| |
| def parsePEReference(self): |
| """parse PEReference declarations The entity content is |
| handled directly by pushing it's content as a new input |
| stream. [69] PEReference ::= '%' Name ';' [ WFC: No |
| Recursion ] A parsed entity must not contain a recursive |
| reference to itself, either directly or indirectly. [ WFC: |
| Entity Declared ] In a document without any DTD, a document |
| with only an internal DTD subset which contains no |
| parameter entity references, or a document with |
| "standalone='yes'", ... ... The declaration of a parameter |
| entity must precede any reference to it... [ VC: Entity |
| Declared ] In a document with an external subset or |
| external parameter entities with "standalone='no'", ... |
| ... The declaration of a parameter entity must precede any |
| reference to it... [ WFC: In DTD ] Parameter-entity |
| references may only appear in the DTD. NOTE: misleading but |
| this is handled. """ |
| libxml2mod.xmlParsePEReference(self._o) |
| |
| def parsePI(self): |
| """parse an XML Processing Instruction. [16] PI ::= '<?' |
| PITarget (S (Char* - (Char* '?>' Char*)))? '?>' The |
| processing is transfered to SAX once parsed. """ |
| libxml2mod.xmlParsePI(self._o) |
| |
| def parsePITarget(self): |
| """parse the name of a PI [17] PITarget ::= Name - (('X' | |
| 'x') ('M' | 'm') ('L' | 'l')) """ |
| ret = libxml2mod.xmlParsePITarget(self._o) |
| return ret |
| |
| def parsePubidLiteral(self): |
| """parse an XML public literal [12] PubidLiteral ::= '"' |
| PubidChar* '"' | "'" (PubidChar - "'")* "'" """ |
| ret = libxml2mod.xmlParsePubidLiteral(self._o) |
| return ret |
| |
| def parseQuotedString(self): |
| """Parse and return a string between quotes or doublequotes |
| TODO: Deprecated, to be removed at next drop of binary |
| compatibility """ |
| ret = libxml2mod.xmlParseQuotedString(self._o) |
| return ret |
| |
| def parseReference(self): |
| """parse and handle entity references in content, depending on |
| the SAX interface, this may end-up in a call to character() |
| if this is a CharRef, a predefined entity, if there is no |
| reference() callback. or if the parser was asked to switch |
| to that mode. [67] Reference ::= EntityRef | CharRef """ |
| libxml2mod.xmlParseReference(self._o) |
| |
| def parseSDDecl(self): |
| """parse the XML standalone declaration [32] SDDecl ::= S |
| 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | |
| 'no')'"')) [ VC: Standalone Document Declaration ] TODO |
| The standalone document declaration must have the value |
| "no" if any external markup declarations contain |
| declarations of: - attributes with default values, if |
| elements to which these attributes apply appear in the |
| document without specifications of values for these |
| attributes, or - entities (other than amp, lt, gt, apos, |
| quot), if references to those entities appear in the |
| document, or - attributes with values subject to |
| normalization, where the attribute appears in the document |
| with a value which will change as a result of |
| normalization, or - element types with element content, if |
| white space occurs directly within any instance of those |
| types. """ |
| ret = libxml2mod.xmlParseSDDecl(self._o) |
| return ret |
| |
| def parseStartTag(self): |
| """parse a start of tag either for rule element or |
| EmptyElement. In both case we don't parse the tag closing |
| chars. [40] STag ::= '<' Name (S Attribute)* S? '>' [ |
| WFC: Unique Att Spec ] No attribute name may appear more |
| than once in the same start-tag or empty-element tag. [44] |
| EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' [ WFC: |
| Unique Att Spec ] No attribute name may appear more than |
| once in the same start-tag or empty-element tag. With |
| namespace: [NS 8] STag ::= '<' QName (S Attribute)* S? '>' |
| [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>' """ |
| ret = libxml2mod.xmlParseStartTag(self._o) |
| return ret |
| |
| def parseSystemLiteral(self): |
| """parse an XML Literal [11] SystemLiteral ::= ('"' [^"]* |
| '"') | ("'" [^']* "'") """ |
| ret = libxml2mod.xmlParseSystemLiteral(self._o) |
| return ret |
| |
| def parseTextDecl(self): |
| """parse an XML declaration header for external entities [77] |
| TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>' """ |
| libxml2mod.xmlParseTextDecl(self._o) |
| |
| def parseVersionInfo(self): |
| """parse the XML version. [24] VersionInfo ::= S 'version' Eq |
| (' VersionNum ' | " VersionNum ") [25] Eq ::= S? '=' S? """ |
| ret = libxml2mod.xmlParseVersionInfo(self._o) |
| return ret |
| |
| def parseVersionNum(self): |
| """parse the XML version value. [26] VersionNum ::= '1.' |
| [0-9]+ In practice allow [0-9].[0-9]+ at that level """ |
| ret = libxml2mod.xmlParseVersionNum(self._o) |
| return ret |
| |
| def parseXMLDecl(self): |
| """parse an XML declaration header [23] XMLDecl ::= '<?xml' |
| VersionInfo EncodingDecl? SDDecl? S? '?>' """ |
| libxml2mod.xmlParseXMLDecl(self._o) |
| |
| def parserHandlePEReference(self): |
| """[69] PEReference ::= '%' Name ';' [ WFC: No Recursion ] A |
| parsed entity must not contain a recursive reference to |
| itself, either directly or indirectly. [ WFC: Entity |
| Declared ] In a document without any DTD, a document with |
| only an internal DTD subset which contains no parameter |
| entity references, or a document with "standalone='yes'", |
| ... ... The declaration of a parameter entity must precede |
| any reference to it... [ VC: Entity Declared ] In a |
| document with an external subset or external parameter |
| entities with "standalone='no'", ... ... The declaration |
| of a parameter entity must precede any reference to it... |
| [ WFC: In DTD ] Parameter-entity references may only appear |
| in the DTD. NOTE: misleading but this is handled. A |
| PEReference may have been detected in the current input |
| stream the handling is done accordingly to |
| http://www.w3.org/TR/REC-xml#entproc i.e. - Included in |
| literal in entity values - Included as Parameter Entity |
| reference within DTDs """ |
| libxml2mod.xmlParserHandlePEReference(self._o) |
| |
| def parserHandleReference(self): |
| """TODO: Remove, now deprecated ... the test is done directly |
| in the content parsing routines. [67] Reference ::= |
| EntityRef | CharRef [68] EntityRef ::= '&' Name ';' [ |
| WFC: Entity Declared ] the Name given in the entity |
| reference must match that in an entity declaration, except |
| that well-formed documents need not declare any of the |
| following entities: amp, lt, gt, apos, quot. [ WFC: Parsed |
| Entity ] An entity reference must not contain the name of |
| an unparsed entity [66] CharRef ::= '&#' [0-9]+ ';' | |
| '&#x' [0-9a-fA-F]+ ';' A PEReference may have been |
| detected in the current input stream the handling is done |
| accordingly to http://www.w3.org/TR/REC-xml#entproc """ |
| libxml2mod.xmlParserHandleReference(self._o) |
| |
| def popInput(self): |
| """xmlPopInput: the current input pointed by ctxt->input came |
| to an end pop it and return the next char. """ |
| ret = libxml2mod.xmlPopInput(self._o) |
| return ret |
| |
| def scanName(self): |
| """Trickery: parse an XML name but without consuming the input |
| flow Needed for rollback cases. Used only when parsing |
| entities references. TODO: seems deprecated now, only used |
| in the default part of xmlParserHandleReference [4] |
| NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | |
| CombiningChar | Extender [5] Name ::= (Letter | '_' | ':') |
| (NameChar)* [6] Names ::= Name (S Name)* """ |
| ret = libxml2mod.xmlScanName(self._o) |
| return ret |
| |
| def skipBlankChars(self): |
| """skip all blanks character found at that point in the input |
| streams. It pops up finished entities in the process if |
| allowable at that point. """ |
| ret = libxml2mod.xmlSkipBlankChars(self._o) |
| return ret |
| |
| def stringDecodeEntities(self, str, what, end, end2, end3): |
| """Takes a entity string content and process to do the |
| adequate substitutions. [67] Reference ::= EntityRef | |
| CharRef [69] PEReference ::= '%' Name ';' """ |
| ret = libxml2mod.xmlStringDecodeEntities(self._o, str, what, end, end2, end3) |
| return ret |
| |
| def stringLenDecodeEntities(self, str, len, what, end, end2, end3): |
| """Takes a entity string content and process to do the |
| adequate substitutions. [67] Reference ::= EntityRef | |
| CharRef [69] PEReference ::= '%' Name ';' """ |
| ret = libxml2mod.xmlStringLenDecodeEntities(self._o, str, len, what, end, end2, end3) |
| return ret |
| |
| class xmlAttr(xmlNode): |
| def __init__(self, _obj=None): |
| if checkWrapper(_obj) != 0: raise TypeError('xmlAttr got a wrong wrapper object type') |
| self._o = _obj |
| xmlNode.__init__(self, _obj=_obj) |
| |
| def __repr__(self): |
| return "<xmlAttr (%s) object at 0x%x>" % (self.name, int(pos_id (self))) |
| |
| # |
| # xmlAttr functions from module debugXML |
| # |
| |
| def debugDumpAttr(self, output, depth): |
| """Dumps debug information for the attribute """ |
| libxml2mod.xmlDebugDumpAttr(output, self._o, depth) |
| |
| def debugDumpAttrList(self, output, depth): |
| """Dumps debug information for the attribute list """ |
| libxml2mod.xmlDebugDumpAttrList(output, self._o, depth) |
| |
| # |
| # xmlAttr functions from module tree |
| # |
| |
| def copyProp(self, target): |
| """Do a copy of the attribute. """ |
| if target is None: target__o = None |
| else: target__o = target._o |
| ret = libxml2mod.xmlCopyProp(target__o, self._o) |
| if ret is None:raise treeError('xmlCopyProp() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def copyPropList(self, target): |
| """Do a copy of an attribute list. """ |
| if target is None: target__o = None |
| else: target__o = target._o |
| ret = libxml2mod.xmlCopyPropList(target__o, self._o) |
| if ret is None:raise treeError('xmlCopyPropList() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def freeProp(self): |
| """Free one attribute, all the content is freed too """ |
| libxml2mod.xmlFreeProp(self._o) |
| |
| def freePropList(self): |
| """Free a property and all its siblings, all the children are |
| freed too. """ |
| libxml2mod.xmlFreePropList(self._o) |
| |
| def removeProp(self): |
| """Unlink and free one attribute, all the content is freed too |
| Note this doesn't work for namespace definition attributes """ |
| ret = libxml2mod.xmlRemoveProp(self._o) |
| return ret |
| |
| # |
| # xmlAttr functions from module valid |
| # |
| |
| def removeID(self, doc): |
| """Remove the given attribute from the ID table maintained |
| internally. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlRemoveID(doc__o, self._o) |
| return ret |
| |
| def removeRef(self, doc): |
| """Remove the given attribute from the Ref table maintained |
| internally. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlRemoveRef(doc__o, self._o) |
| return ret |
| |
| class xmlAttribute(xmlNode): |
| def __init__(self, _obj=None): |
| if checkWrapper(_obj) != 0: raise TypeError('xmlAttribute got a wrong wrapper object type') |
| self._o = _obj |
| xmlNode.__init__(self, _obj=_obj) |
| |
| def __repr__(self): |
| return "<xmlAttribute (%s) object at 0x%x>" % (self.name, int(pos_id (self))) |
| |
| class catalog: |
| def __init__(self, _obj=None): |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlFreeCatalog(self._o) |
| self._o = None |
| |
| # |
| # catalog functions from module catalog |
| # |
| |
| def add(self, type, orig, replace): |
| """Add an entry in the catalog, it may overwrite existing but |
| different entries. """ |
| ret = libxml2mod.xmlACatalogAdd(self._o, type, orig, replace) |
| return ret |
| |
| def catalogIsEmpty(self): |
| """Check is a catalog is empty """ |
| ret = libxml2mod.xmlCatalogIsEmpty(self._o) |
| return ret |
| |
| def convertSGMLCatalog(self): |
| """Convert all the SGML catalog entries as XML ones """ |
| ret = libxml2mod.xmlConvertSGMLCatalog(self._o) |
| return ret |
| |
| def dump(self, out): |
| """Dump the given catalog to the given file. """ |
| libxml2mod.xmlACatalogDump(self._o, out) |
| |
| def remove(self, value): |
| """Remove an entry from the catalog """ |
| ret = libxml2mod.xmlACatalogRemove(self._o, value) |
| return ret |
| |
| def resolve(self, pubID, sysID): |
| """Do a complete resolution lookup of an External Identifier """ |
| ret = libxml2mod.xmlACatalogResolve(self._o, pubID, sysID) |
| return ret |
| |
| def resolvePublic(self, pubID): |
| """Try to lookup the catalog local reference associated to a |
| public ID in that catalog """ |
| ret = libxml2mod.xmlACatalogResolvePublic(self._o, pubID) |
| return ret |
| |
| def resolveSystem(self, sysID): |
| """Try to lookup the catalog resource for a system ID """ |
| ret = libxml2mod.xmlACatalogResolveSystem(self._o, sysID) |
| return ret |
| |
| def resolveURI(self, URI): |
| """Do a complete resolution lookup of an URI """ |
| ret = libxml2mod.xmlACatalogResolveURI(self._o, URI) |
| return ret |
| |
| class xmlDtd(xmlNode): |
| def __init__(self, _obj=None): |
| if checkWrapper(_obj) != 0: raise TypeError('xmlDtd got a wrong wrapper object type') |
| self._o = _obj |
| xmlNode.__init__(self, _obj=_obj) |
| |
| def __repr__(self): |
| return "<xmlDtd (%s) object at 0x%x>" % (self.name, int(pos_id (self))) |
| |
| # |
| # xmlDtd functions from module debugXML |
| # |
| |
| def debugDumpDTD(self, output): |
| """Dumps debug information for the DTD """ |
| libxml2mod.xmlDebugDumpDTD(output, self._o) |
| |
| # |
| # xmlDtd functions from module tree |
| # |
| |
| def copyDtd(self): |
| """Do a copy of the dtd. """ |
| ret = libxml2mod.xmlCopyDtd(self._o) |
| if ret is None:raise treeError('xmlCopyDtd() failed') |
| __tmp = xmlDtd(_obj=ret) |
| return __tmp |
| |
| def freeDtd(self): |
| """Free a DTD structure. """ |
| libxml2mod.xmlFreeDtd(self._o) |
| |
| # |
| # xmlDtd functions from module valid |
| # |
| |
| def dtdAttrDesc(self, elem, name): |
| """Search the DTD for the description of this attribute on |
| this element. """ |
| ret = libxml2mod.xmlGetDtdAttrDesc(self._o, elem, name) |
| if ret is None:raise treeError('xmlGetDtdAttrDesc() failed') |
| __tmp = xmlAttribute(_obj=ret) |
| return __tmp |
| |
| def dtdElementDesc(self, name): |
| """Search the DTD for the description of this element """ |
| ret = libxml2mod.xmlGetDtdElementDesc(self._o, name) |
| if ret is None:raise treeError('xmlGetDtdElementDesc() failed') |
| __tmp = xmlElement(_obj=ret) |
| return __tmp |
| |
| def dtdQAttrDesc(self, elem, name, prefix): |
| """Search the DTD for the description of this qualified |
| attribute on this element. """ |
| ret = libxml2mod.xmlGetDtdQAttrDesc(self._o, elem, name, prefix) |
| if ret is None:raise treeError('xmlGetDtdQAttrDesc() failed') |
| __tmp = xmlAttribute(_obj=ret) |
| return __tmp |
| |
| def dtdQElementDesc(self, name, prefix): |
| """Search the DTD for the description of this element """ |
| ret = libxml2mod.xmlGetDtdQElementDesc(self._o, name, prefix) |
| if ret is None:raise treeError('xmlGetDtdQElementDesc() failed') |
| __tmp = xmlElement(_obj=ret) |
| return __tmp |
| |
| class xmlElement(xmlNode): |
| def __init__(self, _obj=None): |
| if checkWrapper(_obj) != 0: raise TypeError('xmlElement got a wrong wrapper object type') |
| self._o = _obj |
| xmlNode.__init__(self, _obj=_obj) |
| |
| def __repr__(self): |
| return "<xmlElement (%s) object at 0x%x>" % (self.name, int(pos_id (self))) |
| |
| class xmlEntity(xmlNode): |
| def __init__(self, _obj=None): |
| if checkWrapper(_obj) != 0: raise TypeError('xmlEntity got a wrong wrapper object type') |
| self._o = _obj |
| xmlNode.__init__(self, _obj=_obj) |
| |
| def __repr__(self): |
| return "<xmlEntity (%s) object at 0x%x>" % (self.name, int(pos_id (self))) |
| |
| # |
| # xmlEntity functions from module parserInternals |
| # |
| |
| def handleEntity(self, ctxt): |
| """Default handling of defined entities, when should we define |
| a new input stream ? When do we just handle that as a set |
| of chars ? OBSOLETE: to be removed at some point. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| libxml2mod.xmlHandleEntity(ctxt__o, self._o) |
| |
| class Error: |
| def __init__(self, _obj=None): |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| # accessors for Error |
| def code(self): |
| """The error code, e.g. an xmlParserError """ |
| ret = libxml2mod.xmlErrorGetCode(self._o) |
| return ret |
| |
| def domain(self): |
| """What part of the library raised this error """ |
| ret = libxml2mod.xmlErrorGetDomain(self._o) |
| return ret |
| |
| def file(self): |
| """the filename """ |
| ret = libxml2mod.xmlErrorGetFile(self._o) |
| return ret |
| |
| def level(self): |
| """how consequent is the error """ |
| ret = libxml2mod.xmlErrorGetLevel(self._o) |
| return ret |
| |
| def line(self): |
| """the line number if available """ |
| ret = libxml2mod.xmlErrorGetLine(self._o) |
| return ret |
| |
| def message(self): |
| """human-readable informative error message """ |
| ret = libxml2mod.xmlErrorGetMessage(self._o) |
| return ret |
| |
| # |
| # Error functions from module xmlerror |
| # |
| |
| def copyError(self, to): |
| """Save the original error to the new place. """ |
| if to is None: to__o = None |
| else: to__o = to._o |
| ret = libxml2mod.xmlCopyError(self._o, to__o) |
| return ret |
| |
| def resetError(self): |
| """Cleanup the error. """ |
| libxml2mod.xmlResetError(self._o) |
| |
| class xmlNs(xmlNode): |
| def __init__(self, _obj=None): |
| if checkWrapper(_obj) != 0: raise TypeError('xmlNs got a wrong wrapper object type') |
| self._o = _obj |
| xmlNode.__init__(self, _obj=_obj) |
| |
| def __repr__(self): |
| return "<xmlNs (%s) object at 0x%x>" % (self.name, int(pos_id (self))) |
| |
| # |
| # xmlNs functions from module tree |
| # |
| |
| def copyNamespace(self): |
| """Do a copy of the namespace. """ |
| ret = libxml2mod.xmlCopyNamespace(self._o) |
| if ret is None:raise treeError('xmlCopyNamespace() failed') |
| __tmp = xmlNs(_obj=ret) |
| return __tmp |
| |
| def copyNamespaceList(self): |
| """Do a copy of an namespace list. """ |
| ret = libxml2mod.xmlCopyNamespaceList(self._o) |
| if ret is None:raise treeError('xmlCopyNamespaceList() failed') |
| __tmp = xmlNs(_obj=ret) |
| return __tmp |
| |
| def freeNs(self): |
| """Free up the structures associated to a namespace """ |
| libxml2mod.xmlFreeNs(self._o) |
| |
| def freeNsList(self): |
| """Free up all the structures associated to the chained |
| namespaces. """ |
| libxml2mod.xmlFreeNsList(self._o) |
| |
| def newChild(self, parent, name, content): |
| """Creation of a new child element, added at the end of |
| @parent children list. @ns and @content parameters are |
| optional (None). If @ns is None, the newly created element |
| inherits the namespace of @parent. If @content is non None, |
| a child list containing the TEXTs and ENTITY_REFs node will |
| be created. NOTE: @content is supposed to be a piece of XML |
| CDATA, so it allows entity references. XML special chars |
| must be escaped first by using |
| xmlEncodeEntitiesReentrant(), or xmlNewTextChild() should |
| be used. """ |
| if parent is None: parent__o = None |
| else: parent__o = parent._o |
| ret = libxml2mod.xmlNewChild(parent__o, self._o, name, content) |
| if ret is None:raise treeError('xmlNewChild() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDocNode(self, doc, name, content): |
| """Creation of a new node element within a document. @ns and |
| @content are optional (None). NOTE: @content is supposed to |
| be a piece of XML CDATA, so it allow entities references, |
| but XML special chars need to be escaped first by using |
| xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you |
| don't need entities support. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlNewDocNode(doc__o, self._o, name, content) |
| if ret is None:raise treeError('xmlNewDocNode() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDocNodeEatName(self, doc, name, content): |
| """Creation of a new node element within a document. @ns and |
| @content are optional (None). NOTE: @content is supposed to |
| be a piece of XML CDATA, so it allow entities references, |
| but XML special chars need to be escaped first by using |
| xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you |
| don't need entities support. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlNewDocNodeEatName(doc__o, self._o, name, content) |
| if ret is None:raise treeError('xmlNewDocNodeEatName() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newDocRawNode(self, doc, name, content): |
| """Creation of a new node element within a document. @ns and |
| @content are optional (None). """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlNewDocRawNode(doc__o, self._o, name, content) |
| if ret is None:raise treeError('xmlNewDocRawNode() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newNodeEatName(self, name): |
| """Creation of a new node element. @ns is optional (None). """ |
| ret = libxml2mod.xmlNewNodeEatName(self._o, name) |
| if ret is None:raise treeError('xmlNewNodeEatName() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def newNsProp(self, node, name, value): |
| """Create a new property tagged with a namespace and carried |
| by a node. """ |
| if node is None: node__o = None |
| else: node__o = node._o |
| ret = libxml2mod.xmlNewNsProp(node__o, self._o, name, value) |
| if ret is None:raise treeError('xmlNewNsProp() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def newNsPropEatName(self, node, name, value): |
| """Create a new property tagged with a namespace and carried |
| by a node. """ |
| if node is None: node__o = None |
| else: node__o = node._o |
| ret = libxml2mod.xmlNewNsPropEatName(node__o, self._o, name, value) |
| if ret is None:raise treeError('xmlNewNsPropEatName() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def newTextChild(self, parent, name, content): |
| """Creation of a new child element, added at the end of |
| @parent children list. @ns and @content parameters are |
| optional (None). If @ns is None, the newly created element |
| inherits the namespace of @parent. If @content is non None, |
| a child TEXT node will be created containing the string |
| @content. NOTE: Use xmlNewChild() if @content will contain |
| entities that need to be preserved. Use this function, |
| xmlNewTextChild(), if you need to ensure that reserved XML |
| chars that might appear in @content, such as the ampersand, |
| greater-than or less-than signs, are automatically replaced |
| by their XML escaped entity representations. """ |
| if parent is None: parent__o = None |
| else: parent__o = parent._o |
| ret = libxml2mod.xmlNewTextChild(parent__o, self._o, name, content) |
| if ret is None:raise treeError('xmlNewTextChild() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def setNs(self, node): |
| """Associate a namespace to a node, a posteriori. """ |
| if node is None: node__o = None |
| else: node__o = node._o |
| libxml2mod.xmlSetNs(node__o, self._o) |
| |
| def setNsProp(self, node, name, value): |
| """Set (or reset) an attribute carried by a node. The ns |
| structure must be in scope, this is not checked """ |
| if node is None: node__o = None |
| else: node__o = node._o |
| ret = libxml2mod.xmlSetNsProp(node__o, self._o, name, value) |
| if ret is None:raise treeError('xmlSetNsProp() failed') |
| __tmp = xmlAttr(_obj=ret) |
| return __tmp |
| |
| def unsetNsProp(self, node, name): |
| """Remove an attribute carried by a node. """ |
| if node is None: node__o = None |
| else: node__o = node._o |
| ret = libxml2mod.xmlUnsetNsProp(node__o, self._o, name) |
| return ret |
| |
| # |
| # xmlNs functions from module xpathInternals |
| # |
| |
| def xpathNodeSetFreeNs(self): |
| """Namespace nodes in libxml don't match the XPath semantic. |
| In a node set the namespace nodes are duplicated and the |
| next pointer is set to the parent node in the XPath |
| semantic. Check if such a node needs to be freed """ |
| libxml2mod.xmlXPathNodeSetFreeNs(self._o) |
| |
| class outputBuffer(ioWriteWrapper): |
| def __init__(self, _obj=None): |
| self._o = _obj |
| ioWriteWrapper.__init__(self, _obj=_obj) |
| |
| # |
| # outputBuffer functions from module HTMLtree |
| # |
| |
| def htmlDocContentDumpFormatOutput(self, cur, encoding, format): |
| """Dump an HTML document. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| libxml2mod.htmlDocContentDumpFormatOutput(self._o, cur__o, encoding, format) |
| |
| def htmlDocContentDumpOutput(self, cur, encoding): |
| """Dump an HTML document. Formating return/spaces are added. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| libxml2mod.htmlDocContentDumpOutput(self._o, cur__o, encoding) |
| |
| def htmlNodeDumpFormatOutput(self, doc, cur, encoding, format): |
| """Dump an HTML node, recursive behaviour,children are printed |
| too. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| libxml2mod.htmlNodeDumpFormatOutput(self._o, doc__o, cur__o, encoding, format) |
| |
| def htmlNodeDumpOutput(self, doc, cur, encoding): |
| """Dump an HTML node, recursive behaviour,children are printed |
| too, and formatting returns/spaces are added. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| libxml2mod.htmlNodeDumpOutput(self._o, doc__o, cur__o, encoding) |
| |
| # |
| # outputBuffer functions from module tree |
| # |
| |
| def nodeDumpOutput(self, doc, cur, level, format, encoding): |
| """Dump an XML node, recursive behaviour, children are printed |
| too. Note that @format = 1 provide node indenting only if |
| xmlIndentTreeOutput = 1 or xmlKeepBlanksDefault(0) was |
| called """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| libxml2mod.xmlNodeDumpOutput(self._o, doc__o, cur__o, level, format, encoding) |
| |
| def saveFileTo(self, cur, encoding): |
| """Dump an XML document to an I/O buffer. Warning ! This call |
| xmlOutputBufferClose() on buf which is not available after |
| this call. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlSaveFileTo(self._o, cur__o, encoding) |
| return ret |
| |
| def saveFormatFileTo(self, cur, encoding, format): |
| """Dump an XML document to an I/O buffer. Warning ! This call |
| xmlOutputBufferClose() on buf which is not available after |
| this call. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlSaveFormatFileTo(self._o, cur__o, encoding, format) |
| return ret |
| |
| # |
| # outputBuffer functions from module xmlIO |
| # |
| |
| def getContent(self): |
| """Gives a pointer to the data currently held in the output |
| buffer """ |
| ret = libxml2mod.xmlOutputBufferGetContent(self._o) |
| return ret |
| |
| def write(self, len, buf): |
| """Write the content of the array in the output I/O buffer |
| This routine handle the I18N transcoding from internal |
| UTF-8 The buffer is lossless, i.e. will store in case of |
| partial or delayed writes. """ |
| ret = libxml2mod.xmlOutputBufferWrite(self._o, len, buf) |
| return ret |
| |
| def writeString(self, str): |
| """Write the content of the string in the output I/O buffer |
| This routine handle the I18N transcoding from internal |
| UTF-8 The buffer is lossless, i.e. will store in case of |
| partial or delayed writes. """ |
| ret = libxml2mod.xmlOutputBufferWriteString(self._o, str) |
| return ret |
| |
| class inputBuffer(ioReadWrapper): |
| def __init__(self, _obj=None): |
| self._o = _obj |
| ioReadWrapper.__init__(self, _obj=_obj) |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlFreeParserInputBuffer(self._o) |
| self._o = None |
| |
| # |
| # inputBuffer functions from module xmlIO |
| # |
| |
| def grow(self, len): |
| """Grow up the content of the input buffer, the old data are |
| preserved This routine handle the I18N transcoding to |
| internal UTF-8 This routine is used when operating the |
| parser in normal (pull) mode TODO: one should be able to |
| remove one extra copy by copying directly onto in->buffer |
| or in->raw """ |
| ret = libxml2mod.xmlParserInputBufferGrow(self._o, len) |
| return ret |
| |
| def push(self, len, buf): |
| """Push the content of the arry in the input buffer This |
| routine handle the I18N transcoding to internal UTF-8 This |
| is used when operating the parser in progressive (push) |
| mode. """ |
| ret = libxml2mod.xmlParserInputBufferPush(self._o, len, buf) |
| return ret |
| |
| def read(self, len): |
| """Refresh the content of the input buffer, the old data are |
| considered consumed This routine handle the I18N |
| transcoding to internal UTF-8 """ |
| ret = libxml2mod.xmlParserInputBufferRead(self._o, len) |
| return ret |
| |
| # |
| # inputBuffer functions from module xmlreader |
| # |
| |
| def Setup(self, reader, URL, encoding, options): |
| """Setup an XML reader with new options """ |
| if reader is None: reader__o = None |
| else: reader__o = reader._o |
| ret = libxml2mod.xmlTextReaderSetup(reader__o, self._o, URL, encoding, options) |
| return ret |
| |
| def newTextReader(self, URI): |
| """Create an xmlTextReader structure fed with @input """ |
| ret = libxml2mod.xmlNewTextReader(self._o, URI) |
| if ret is None:raise treeError('xmlNewTextReader() failed') |
| __tmp = xmlTextReader(_obj=ret) |
| __tmp.input = self |
| return __tmp |
| |
| class xmlReg: |
| def __init__(self, _obj=None): |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlRegFreeRegexp(self._o) |
| self._o = None |
| |
| # |
| # xmlReg functions from module xmlregexp |
| # |
| |
| def regexpExec(self, content): |
| """Check if the regular expression generates the value """ |
| ret = libxml2mod.xmlRegexpExec(self._o, content) |
| return ret |
| |
| def regexpIsDeterminist(self): |
| """Check if the regular expression is determinist """ |
| ret = libxml2mod.xmlRegexpIsDeterminist(self._o) |
| return ret |
| |
| def regexpPrint(self, output): |
| """Print the content of the compiled regular expression """ |
| libxml2mod.xmlRegexpPrint(output, self._o) |
| |
| class relaxNgParserCtxt: |
| def __init__(self, _obj=None): |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlRelaxNGFreeParserCtxt(self._o) |
| self._o = None |
| |
| # |
| # relaxNgParserCtxt functions from module relaxng |
| # |
| |
| def relaxNGParse(self): |
| """parse a schema definition resource and build an internal |
| XML Shema struture which can be used to validate instances. """ |
| ret = libxml2mod.xmlRelaxNGParse(self._o) |
| if ret is None:raise parserError('xmlRelaxNGParse() failed') |
| __tmp = relaxNgSchema(_obj=ret) |
| return __tmp |
| |
| def relaxParserSetFlag(self, flags): |
| """Semi private function used to pass informations to a parser |
| context which are a combination of xmlRelaxNGParserFlag . """ |
| ret = libxml2mod.xmlRelaxParserSetFlag(self._o, flags) |
| return ret |
| |
| class relaxNgSchema: |
| def __init__(self, _obj=None): |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlRelaxNGFree(self._o) |
| self._o = None |
| |
| # |
| # relaxNgSchema functions from module relaxng |
| # |
| |
| def relaxNGDump(self, output): |
| """Dump a RelaxNG structure back """ |
| libxml2mod.xmlRelaxNGDump(output, self._o) |
| |
| def relaxNGDumpTree(self, output): |
| """Dump the transformed RelaxNG tree. """ |
| libxml2mod.xmlRelaxNGDumpTree(output, self._o) |
| |
| def relaxNGNewValidCtxt(self): |
| """Create an XML RelaxNGs validation context based on the |
| given schema """ |
| ret = libxml2mod.xmlRelaxNGNewValidCtxt(self._o) |
| if ret is None:raise treeError('xmlRelaxNGNewValidCtxt() failed') |
| __tmp = relaxNgValidCtxt(_obj=ret) |
| __tmp.schema = self |
| return __tmp |
| |
| # |
| # relaxNgSchema functions from module xmlreader |
| # |
| |
| def RelaxNGSetSchema(self, reader): |
| """Use RelaxNG to validate the document as it is processed. |
| Activation is only possible before the first Read(). if |
| @schema is None, then RelaxNG validation is desactivated. @ |
| The @schema should not be freed until the reader is |
| deallocated or its use has been deactivated. """ |
| if reader is None: reader__o = None |
| else: reader__o = reader._o |
| ret = libxml2mod.xmlTextReaderRelaxNGSetSchema(reader__o, self._o) |
| return ret |
| |
| class relaxNgValidCtxt(relaxNgValidCtxtCore): |
| def __init__(self, _obj=None): |
| self.schema = None |
| self._o = _obj |
| relaxNgValidCtxtCore.__init__(self, _obj=_obj) |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlRelaxNGFreeValidCtxt(self._o) |
| self._o = None |
| |
| # |
| # relaxNgValidCtxt functions from module relaxng |
| # |
| |
| def relaxNGValidateDoc(self, doc): |
| """Validate a document tree in memory. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlRelaxNGValidateDoc(self._o, doc__o) |
| return ret |
| |
| def relaxNGValidateFullElement(self, doc, elem): |
| """Validate a full subtree when |
| xmlRelaxNGValidatePushElement() returned 0 and the content |
| of the node has been expanded. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlRelaxNGValidateFullElement(self._o, doc__o, elem__o) |
| return ret |
| |
| def relaxNGValidatePopElement(self, doc, elem): |
| """Pop the element end from the RelaxNG validation stack. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlRelaxNGValidatePopElement(self._o, doc__o, elem__o) |
| return ret |
| |
| def relaxNGValidatePushCData(self, data, len): |
| """check the CData parsed for validation in the current stack """ |
| ret = libxml2mod.xmlRelaxNGValidatePushCData(self._o, data, len) |
| return ret |
| |
| def relaxNGValidatePushElement(self, doc, elem): |
| """Push a new element start on the RelaxNG validation stack. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlRelaxNGValidatePushElement(self._o, doc__o, elem__o) |
| return ret |
| |
| # |
| # relaxNgValidCtxt functions from module xmlreader |
| # |
| |
| def RelaxNGValidateCtxt(self, reader, options): |
| """Use RelaxNG schema context to validate the document as it |
| is processed. Activation is only possible before the first |
| Read(). If @ctxt is None, then RelaxNG schema validation is |
| deactivated. """ |
| if reader is None: reader__o = None |
| else: reader__o = reader._o |
| ret = libxml2mod.xmlTextReaderRelaxNGValidateCtxt(reader__o, self._o, options) |
| return ret |
| |
| class SchemaParserCtxt: |
| def __init__(self, _obj=None): |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlSchemaFreeParserCtxt(self._o) |
| self._o = None |
| |
| # |
| # SchemaParserCtxt functions from module xmlschemas |
| # |
| |
| def schemaParse(self): |
| """parse a schema definition resource and build an internal |
| XML Shema struture which can be used to validate instances. """ |
| ret = libxml2mod.xmlSchemaParse(self._o) |
| if ret is None:raise parserError('xmlSchemaParse() failed') |
| __tmp = Schema(_obj=ret) |
| return __tmp |
| |
| class Schema: |
| def __init__(self, _obj=None): |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlSchemaFree(self._o) |
| self._o = None |
| |
| # |
| # Schema functions from module xmlreader |
| # |
| |
| def SetSchema(self, reader): |
| """Use XSD Schema to validate the document as it is processed. |
| Activation is only possible before the first Read(). if |
| @schema is None, then Schema validation is desactivated. @ |
| The @schema should not be freed until the reader is |
| deallocated or its use has been deactivated. """ |
| if reader is None: reader__o = None |
| else: reader__o = reader._o |
| ret = libxml2mod.xmlTextReaderSetSchema(reader__o, self._o) |
| return ret |
| |
| # |
| # Schema functions from module xmlschemas |
| # |
| |
| def schemaDump(self, output): |
| """Dump a Schema structure. """ |
| libxml2mod.xmlSchemaDump(output, self._o) |
| |
| def schemaNewValidCtxt(self): |
| """Create an XML Schemas validation context based on the given |
| schema. """ |
| ret = libxml2mod.xmlSchemaNewValidCtxt(self._o) |
| if ret is None:raise treeError('xmlSchemaNewValidCtxt() failed') |
| __tmp = SchemaValidCtxt(_obj=ret) |
| __tmp.schema = self |
| return __tmp |
| |
| class SchemaValidCtxt(SchemaValidCtxtCore): |
| def __init__(self, _obj=None): |
| self.schema = None |
| self._o = _obj |
| SchemaValidCtxtCore.__init__(self, _obj=_obj) |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlSchemaFreeValidCtxt(self._o) |
| self._o = None |
| |
| # |
| # SchemaValidCtxt functions from module xmlreader |
| # |
| |
| def SchemaValidateCtxt(self, reader, options): |
| """Use W3C XSD schema context to validate the document as it |
| is processed. Activation is only possible before the first |
| Read(). If @ctxt is None, then XML Schema validation is |
| deactivated. """ |
| if reader is None: reader__o = None |
| else: reader__o = reader._o |
| ret = libxml2mod.xmlTextReaderSchemaValidateCtxt(reader__o, self._o, options) |
| return ret |
| |
| # |
| # SchemaValidCtxt functions from module xmlschemas |
| # |
| |
| def schemaIsValid(self): |
| """Check if any error was detected during validation. """ |
| ret = libxml2mod.xmlSchemaIsValid(self._o) |
| return ret |
| |
| def schemaSetValidOptions(self, options): |
| """Sets the options to be used during the validation. """ |
| ret = libxml2mod.xmlSchemaSetValidOptions(self._o, options) |
| return ret |
| |
| def schemaValidCtxtGetOptions(self): |
| """Get the validation context options. """ |
| ret = libxml2mod.xmlSchemaValidCtxtGetOptions(self._o) |
| return ret |
| |
| def schemaValidCtxtGetParserCtxt(self): |
| """allow access to the parser context of the schema validation |
| context """ |
| ret = libxml2mod.xmlSchemaValidCtxtGetParserCtxt(self._o) |
| if ret is None:raise parserError('xmlSchemaValidCtxtGetParserCtxt() failed') |
| __tmp = parserCtxt(_obj=ret) |
| return __tmp |
| |
| def schemaValidateDoc(self, doc): |
| """Validate a document tree in memory. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlSchemaValidateDoc(self._o, doc__o) |
| return ret |
| |
| def schemaValidateFile(self, filename, options): |
| """Do a schemas validation of the given resource, it will use |
| the SAX streamable validation internally. """ |
| ret = libxml2mod.xmlSchemaValidateFile(self._o, filename, options) |
| return ret |
| |
| def schemaValidateOneElement(self, elem): |
| """Validate a branch of a tree, starting with the given @elem. """ |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlSchemaValidateOneElement(self._o, elem__o) |
| return ret |
| |
| def schemaValidateSetFilename(self, filename): |
| """Workaround to provide file error reporting information when |
| this is not provided by current APIs """ |
| libxml2mod.xmlSchemaValidateSetFilename(self._o, filename) |
| |
| class xmlTextReaderLocator: |
| def __init__(self, _obj=None): |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| # |
| # xmlTextReaderLocator functions from module xmlreader |
| # |
| |
| def BaseURI(self): |
| """Obtain the base URI for the given locator. """ |
| ret = libxml2mod.xmlTextReaderLocatorBaseURI(self._o) |
| return ret |
| |
| def LineNumber(self): |
| """Obtain the line number for the given locator. """ |
| ret = libxml2mod.xmlTextReaderLocatorLineNumber(self._o) |
| return ret |
| |
| class xmlTextReader(xmlTextReaderCore): |
| def __init__(self, _obj=None): |
| self.input = None |
| self._o = _obj |
| xmlTextReaderCore.__init__(self, _obj=_obj) |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlFreeTextReader(self._o) |
| self._o = None |
| |
| # |
| # xmlTextReader functions from module xmlreader |
| # |
| |
| def AttributeCount(self): |
| """Provides the number of attributes of the current node """ |
| ret = libxml2mod.xmlTextReaderAttributeCount(self._o) |
| return ret |
| |
| def BaseUri(self): |
| """The base URI of the node. """ |
| ret = libxml2mod.xmlTextReaderConstBaseUri(self._o) |
| return ret |
| |
| def ByteConsumed(self): |
| """This function provides the current index of the parser used |
| by the reader, relative to the start of the current entity. |
| This function actually just wraps a call to |
| xmlBytesConsumed() for the parser context associated with |
| the reader. See xmlBytesConsumed() for more information. """ |
| ret = libxml2mod.xmlTextReaderByteConsumed(self._o) |
| return ret |
| |
| def Close(self): |
| """This method releases any resources allocated by the current |
| instance changes the state to Closed and close any |
| underlying input. """ |
| ret = libxml2mod.xmlTextReaderClose(self._o) |
| return ret |
| |
| def CurrentDoc(self): |
| """Hacking interface allowing to get the xmlDocPtr |
| correponding to the current document being accessed by the |
| xmlTextReader. NOTE: as a result of this call, the reader |
| will not destroy the associated XML document and calling |
| xmlFreeDoc() on the result is needed once the reader |
| parsing has finished. """ |
| ret = libxml2mod.xmlTextReaderCurrentDoc(self._o) |
| if ret is None:raise treeError('xmlTextReaderCurrentDoc() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def CurrentNode(self): |
| """Hacking interface allowing to get the xmlNodePtr |
| correponding to the current node being accessed by the |
| xmlTextReader. This is dangerous because the underlying |
| node may be destroyed on the next Reads. """ |
| ret = libxml2mod.xmlTextReaderCurrentNode(self._o) |
| if ret is None:raise treeError('xmlTextReaderCurrentNode() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def Depth(self): |
| """The depth of the node in the tree. """ |
| ret = libxml2mod.xmlTextReaderDepth(self._o) |
| return ret |
| |
| def Encoding(self): |
| """Determine the encoding of the document being read. """ |
| ret = libxml2mod.xmlTextReaderConstEncoding(self._o) |
| return ret |
| |
| def Expand(self): |
| """Reads the contents of the current node and the full |
| subtree. It then makes the subtree available until the next |
| xmlTextReaderRead() call """ |
| ret = libxml2mod.xmlTextReaderExpand(self._o) |
| if ret is None:raise treeError('xmlTextReaderExpand() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def GetAttribute(self, name): |
| """Provides the value of the attribute with the specified |
| qualified name. """ |
| ret = libxml2mod.xmlTextReaderGetAttribute(self._o, name) |
| return ret |
| |
| def GetAttributeNo(self, no): |
| """Provides the value of the attribute with the specified |
| index relative to the containing element. """ |
| ret = libxml2mod.xmlTextReaderGetAttributeNo(self._o, no) |
| return ret |
| |
| def GetAttributeNs(self, localName, namespaceURI): |
| """Provides the value of the specified attribute """ |
| ret = libxml2mod.xmlTextReaderGetAttributeNs(self._o, localName, namespaceURI) |
| return ret |
| |
| def GetParserColumnNumber(self): |
| """Provide the column number of the current parsing point. """ |
| ret = libxml2mod.xmlTextReaderGetParserColumnNumber(self._o) |
| return ret |
| |
| def GetParserLineNumber(self): |
| """Provide the line number of the current parsing point. """ |
| ret = libxml2mod.xmlTextReaderGetParserLineNumber(self._o) |
| return ret |
| |
| def GetParserProp(self, prop): |
| """Read the parser internal property. """ |
| ret = libxml2mod.xmlTextReaderGetParserProp(self._o, prop) |
| return ret |
| |
| def GetRemainder(self): |
| """Method to get the remainder of the buffered XML. this |
| method stops the parser, set its state to End Of File and |
| return the input stream with what is left that the parser |
| did not use. The implementation is not good, the parser |
| certainly procgressed past what's left in reader->input, |
| and there is an allocation problem. Best would be to |
| rewrite it differently. """ |
| ret = libxml2mod.xmlTextReaderGetRemainder(self._o) |
| if ret is None:raise treeError('xmlTextReaderGetRemainder() failed') |
| __tmp = inputBuffer(_obj=ret) |
| return __tmp |
| |
| def HasAttributes(self): |
| """Whether the node has attributes. """ |
| ret = libxml2mod.xmlTextReaderHasAttributes(self._o) |
| return ret |
| |
| def HasValue(self): |
| """Whether the node can have a text value. """ |
| ret = libxml2mod.xmlTextReaderHasValue(self._o) |
| return ret |
| |
| def IsDefault(self): |
| """Whether an Attribute node was generated from the default |
| value defined in the DTD or schema. """ |
| ret = libxml2mod.xmlTextReaderIsDefault(self._o) |
| return ret |
| |
| def IsEmptyElement(self): |
| """Check if the current node is empty """ |
| ret = libxml2mod.xmlTextReaderIsEmptyElement(self._o) |
| return ret |
| |
| def IsNamespaceDecl(self): |
| """Determine whether the current node is a namespace |
| declaration rather than a regular attribute. """ |
| ret = libxml2mod.xmlTextReaderIsNamespaceDecl(self._o) |
| return ret |
| |
| def IsValid(self): |
| """Retrieve the validity status from the parser context """ |
| ret = libxml2mod.xmlTextReaderIsValid(self._o) |
| return ret |
| |
| def LocalName(self): |
| """The local name of the node. """ |
| ret = libxml2mod.xmlTextReaderConstLocalName(self._o) |
| return ret |
| |
| def LookupNamespace(self, prefix): |
| """Resolves a namespace prefix in the scope of the current |
| element. """ |
| ret = libxml2mod.xmlTextReaderLookupNamespace(self._o, prefix) |
| return ret |
| |
| def MoveToAttribute(self, name): |
| """Moves the position of the current instance to the attribute |
| with the specified qualified name. """ |
| ret = libxml2mod.xmlTextReaderMoveToAttribute(self._o, name) |
| return ret |
| |
| def MoveToAttributeNo(self, no): |
| """Moves the position of the current instance to the attribute |
| with the specified index relative to the containing element. """ |
| ret = libxml2mod.xmlTextReaderMoveToAttributeNo(self._o, no) |
| return ret |
| |
| def MoveToAttributeNs(self, localName, namespaceURI): |
| """Moves the position of the current instance to the attribute |
| with the specified local name and namespace URI. """ |
| ret = libxml2mod.xmlTextReaderMoveToAttributeNs(self._o, localName, namespaceURI) |
| return ret |
| |
| def MoveToElement(self): |
| """Moves the position of the current instance to the node that |
| contains the current Attribute node. """ |
| ret = libxml2mod.xmlTextReaderMoveToElement(self._o) |
| return ret |
| |
| def MoveToFirstAttribute(self): |
| """Moves the position of the current instance to the first |
| attribute associated with the current node. """ |
| ret = libxml2mod.xmlTextReaderMoveToFirstAttribute(self._o) |
| return ret |
| |
| def MoveToNextAttribute(self): |
| """Moves the position of the current instance to the next |
| attribute associated with the current node. """ |
| ret = libxml2mod.xmlTextReaderMoveToNextAttribute(self._o) |
| return ret |
| |
| def Name(self): |
| """The qualified name of the node, equal to Prefix :LocalName. """ |
| ret = libxml2mod.xmlTextReaderConstName(self._o) |
| return ret |
| |
| def NamespaceUri(self): |
| """The URI defining the namespace associated with the node. """ |
| ret = libxml2mod.xmlTextReaderConstNamespaceUri(self._o) |
| return ret |
| |
| def NewDoc(self, cur, URL, encoding, options): |
| """Setup an xmltextReader to parse an XML in-memory document. |
| The parsing flags @options are a combination of |
| xmlParserOption. This reuses the existing @reader |
| xmlTextReader. """ |
| ret = libxml2mod.xmlReaderNewDoc(self._o, cur, URL, encoding, options) |
| return ret |
| |
| def NewFd(self, fd, URL, encoding, options): |
| """Setup an xmltextReader to parse an XML from a file |
| descriptor. NOTE that the file descriptor will not be |
| closed when the reader is closed or reset. The parsing |
| flags @options are a combination of xmlParserOption. This |
| reuses the existing @reader xmlTextReader. """ |
| ret = libxml2mod.xmlReaderNewFd(self._o, fd, URL, encoding, options) |
| return ret |
| |
| def NewFile(self, filename, encoding, options): |
| """parse an XML file from the filesystem or the network. The |
| parsing flags @options are a combination of |
| xmlParserOption. This reuses the existing @reader |
| xmlTextReader. """ |
| ret = libxml2mod.xmlReaderNewFile(self._o, filename, encoding, options) |
| return ret |
| |
| def NewMemory(self, buffer, size, URL, encoding, options): |
| """Setup an xmltextReader to parse an XML in-memory document. |
| The parsing flags @options are a combination of |
| xmlParserOption. This reuses the existing @reader |
| xmlTextReader. """ |
| ret = libxml2mod.xmlReaderNewMemory(self._o, buffer, size, URL, encoding, options) |
| return ret |
| |
| def NewWalker(self, doc): |
| """Setup an xmltextReader to parse a preparsed XML document. |
| This reuses the existing @reader xmlTextReader. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlReaderNewWalker(self._o, doc__o) |
| return ret |
| |
| def Next(self): |
| """Skip to the node following the current one in document |
| order while avoiding the subtree if any. """ |
| ret = libxml2mod.xmlTextReaderNext(self._o) |
| return ret |
| |
| def NextSibling(self): |
| """Skip to the node following the current one in document |
| order while avoiding the subtree if any. Currently |
| implemented only for Readers built on a document """ |
| ret = libxml2mod.xmlTextReaderNextSibling(self._o) |
| return ret |
| |
| def NodeType(self): |
| """Get the node type of the current node Reference: |
| http://www.gnu.org/software/dotgnu/pnetlib-doc/System/Xml/Xm |
| lNodeType.html """ |
| ret = libxml2mod.xmlTextReaderNodeType(self._o) |
| return ret |
| |
| def Normalization(self): |
| """The value indicating whether to normalize white space and |
| attribute values. Since attribute value and end of line |
| normalizations are a MUST in the XML specification only the |
| value true is accepted. The broken bahaviour of accepting |
| out of range character entities like � is of course not |
| supported either. """ |
| ret = libxml2mod.xmlTextReaderNormalization(self._o) |
| return ret |
| |
| def Prefix(self): |
| """A shorthand reference to the namespace associated with the |
| node. """ |
| ret = libxml2mod.xmlTextReaderConstPrefix(self._o) |
| return ret |
| |
| def Preserve(self): |
| """This tells the XML Reader to preserve the current node. The |
| caller must also use xmlTextReaderCurrentDoc() to keep an |
| handle on the resulting document once parsing has finished """ |
| ret = libxml2mod.xmlTextReaderPreserve(self._o) |
| if ret is None:raise treeError('xmlTextReaderPreserve() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def QuoteChar(self): |
| """The quotation mark character used to enclose the value of |
| an attribute. """ |
| ret = libxml2mod.xmlTextReaderQuoteChar(self._o) |
| return ret |
| |
| def Read(self): |
| """Moves the position of the current instance to the next node |
| in the stream, exposing its properties. """ |
| ret = libxml2mod.xmlTextReaderRead(self._o) |
| return ret |
| |
| def ReadAttributeValue(self): |
| """Parses an attribute value into one or more Text and |
| EntityReference nodes. """ |
| ret = libxml2mod.xmlTextReaderReadAttributeValue(self._o) |
| return ret |
| |
| def ReadInnerXml(self): |
| """Reads the contents of the current node, including child |
| nodes and markup. """ |
| ret = libxml2mod.xmlTextReaderReadInnerXml(self._o) |
| return ret |
| |
| def ReadOuterXml(self): |
| """Reads the contents of the current node, including child |
| nodes and markup. """ |
| ret = libxml2mod.xmlTextReaderReadOuterXml(self._o) |
| return ret |
| |
| def ReadState(self): |
| """Gets the read state of the reader. """ |
| ret = libxml2mod.xmlTextReaderReadState(self._o) |
| return ret |
| |
| def ReadString(self): |
| """Reads the contents of an element or a text node as a string. """ |
| ret = libxml2mod.xmlTextReaderReadString(self._o) |
| return ret |
| |
| def RelaxNGSetSchema(self, schema): |
| """Use RelaxNG to validate the document as it is processed. |
| Activation is only possible before the first Read(). if |
| @schema is None, then RelaxNG validation is desactivated. @ |
| The @schema should not be freed until the reader is |
| deallocated or its use has been deactivated. """ |
| if schema is None: schema__o = None |
| else: schema__o = schema._o |
| ret = libxml2mod.xmlTextReaderRelaxNGSetSchema(self._o, schema__o) |
| return ret |
| |
| def RelaxNGValidate(self, rng): |
| """Use RelaxNG schema to validate the document as it is |
| processed. Activation is only possible before the first |
| Read(). If @rng is None, then RelaxNG schema validation is |
| deactivated. """ |
| ret = libxml2mod.xmlTextReaderRelaxNGValidate(self._o, rng) |
| return ret |
| |
| def RelaxNGValidateCtxt(self, ctxt, options): |
| """Use RelaxNG schema context to validate the document as it |
| is processed. Activation is only possible before the first |
| Read(). If @ctxt is None, then RelaxNG schema validation is |
| deactivated. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlTextReaderRelaxNGValidateCtxt(self._o, ctxt__o, options) |
| return ret |
| |
| def SchemaValidate(self, xsd): |
| """Use W3C XSD schema to validate the document as it is |
| processed. Activation is only possible before the first |
| Read(). If @xsd is None, then XML Schema validation is |
| deactivated. """ |
| ret = libxml2mod.xmlTextReaderSchemaValidate(self._o, xsd) |
| return ret |
| |
| def SchemaValidateCtxt(self, ctxt, options): |
| """Use W3C XSD schema context to validate the document as it |
| is processed. Activation is only possible before the first |
| Read(). If @ctxt is None, then XML Schema validation is |
| deactivated. """ |
| if ctxt is None: ctxt__o = None |
| else: ctxt__o = ctxt._o |
| ret = libxml2mod.xmlTextReaderSchemaValidateCtxt(self._o, ctxt__o, options) |
| return ret |
| |
| def SetParserProp(self, prop, value): |
| """Change the parser processing behaviour by changing some of |
| its internal properties. Note that some properties can only |
| be changed before any read has been done. """ |
| ret = libxml2mod.xmlTextReaderSetParserProp(self._o, prop, value) |
| return ret |
| |
| def SetSchema(self, schema): |
| """Use XSD Schema to validate the document as it is processed. |
| Activation is only possible before the first Read(). if |
| @schema is None, then Schema validation is desactivated. @ |
| The @schema should not be freed until the reader is |
| deallocated or its use has been deactivated. """ |
| if schema is None: schema__o = None |
| else: schema__o = schema._o |
| ret = libxml2mod.xmlTextReaderSetSchema(self._o, schema__o) |
| return ret |
| |
| def Setup(self, input, URL, encoding, options): |
| """Setup an XML reader with new options """ |
| if input is None: input__o = None |
| else: input__o = input._o |
| ret = libxml2mod.xmlTextReaderSetup(self._o, input__o, URL, encoding, options) |
| return ret |
| |
| def Standalone(self): |
| """Determine the standalone status of the document being read. """ |
| ret = libxml2mod.xmlTextReaderStandalone(self._o) |
| return ret |
| |
| def String(self, str): |
| """Get an interned string from the reader, allows for example |
| to speedup string name comparisons """ |
| ret = libxml2mod.xmlTextReaderConstString(self._o, str) |
| return ret |
| |
| def Value(self): |
| """Provides the text value of the node if present """ |
| ret = libxml2mod.xmlTextReaderConstValue(self._o) |
| return ret |
| |
| def XmlLang(self): |
| """The xml:lang scope within which the node resides. """ |
| ret = libxml2mod.xmlTextReaderConstXmlLang(self._o) |
| return ret |
| |
| def XmlVersion(self): |
| """Determine the XML version of the document being read. """ |
| ret = libxml2mod.xmlTextReaderConstXmlVersion(self._o) |
| return ret |
| |
| class URI: |
| def __init__(self, _obj=None): |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlFreeURI(self._o) |
| self._o = None |
| |
| # accessors for URI |
| def authority(self): |
| """Get the authority part from an URI """ |
| ret = libxml2mod.xmlURIGetAuthority(self._o) |
| return ret |
| |
| def fragment(self): |
| """Get the fragment part from an URI """ |
| ret = libxml2mod.xmlURIGetFragment(self._o) |
| return ret |
| |
| def opaque(self): |
| """Get the opaque part from an URI """ |
| ret = libxml2mod.xmlURIGetOpaque(self._o) |
| return ret |
| |
| def path(self): |
| """Get the path part from an URI """ |
| ret = libxml2mod.xmlURIGetPath(self._o) |
| return ret |
| |
| def port(self): |
| """Get the port part from an URI """ |
| ret = libxml2mod.xmlURIGetPort(self._o) |
| return ret |
| |
| def query(self): |
| """Get the query part from an URI """ |
| ret = libxml2mod.xmlURIGetQuery(self._o) |
| return ret |
| |
| def queryRaw(self): |
| """Get the raw query part from an URI (i.e. the unescaped |
| form). """ |
| ret = libxml2mod.xmlURIGetQueryRaw(self._o) |
| return ret |
| |
| def scheme(self): |
| """Get the scheme part from an URI """ |
| ret = libxml2mod.xmlURIGetScheme(self._o) |
| return ret |
| |
| def server(self): |
| """Get the server part from an URI """ |
| ret = libxml2mod.xmlURIGetServer(self._o) |
| return ret |
| |
| def setAuthority(self, authority): |
| """Set the authority part of an URI. """ |
| libxml2mod.xmlURISetAuthority(self._o, authority) |
| |
| def setFragment(self, fragment): |
| """Set the fragment part of an URI. """ |
| libxml2mod.xmlURISetFragment(self._o, fragment) |
| |
| def setOpaque(self, opaque): |
| """Set the opaque part of an URI. """ |
| libxml2mod.xmlURISetOpaque(self._o, opaque) |
| |
| def setPath(self, path): |
| """Set the path part of an URI. """ |
| libxml2mod.xmlURISetPath(self._o, path) |
| |
| def setPort(self, port): |
| """Set the port part of an URI. """ |
| libxml2mod.xmlURISetPort(self._o, port) |
| |
| def setQuery(self, query): |
| """Set the query part of an URI. """ |
| libxml2mod.xmlURISetQuery(self._o, query) |
| |
| def setQueryRaw(self, query_raw): |
| """Set the raw query part of an URI (i.e. the unescaped form). """ |
| libxml2mod.xmlURISetQueryRaw(self._o, query_raw) |
| |
| def setScheme(self, scheme): |
| """Set the scheme part of an URI. """ |
| libxml2mod.xmlURISetScheme(self._o, scheme) |
| |
| def setServer(self, server): |
| """Set the server part of an URI. """ |
| libxml2mod.xmlURISetServer(self._o, server) |
| |
| def setUser(self, user): |
| """Set the user part of an URI. """ |
| libxml2mod.xmlURISetUser(self._o, user) |
| |
| def user(self): |
| """Get the user part from an URI """ |
| ret = libxml2mod.xmlURIGetUser(self._o) |
| return ret |
| |
| # |
| # URI functions from module uri |
| # |
| |
| def parseURIReference(self, str): |
| """Parse an URI reference string based on RFC 3986 and fills |
| in the appropriate fields of the @uri structure |
| URI-reference = URI / relative-ref """ |
| ret = libxml2mod.xmlParseURIReference(self._o, str) |
| return ret |
| |
| def printURI(self, stream): |
| """Prints the URI in the stream @stream. """ |
| libxml2mod.xmlPrintURI(stream, self._o) |
| |
| def saveUri(self): |
| """Save the URI as an escaped string """ |
| ret = libxml2mod.xmlSaveUri(self._o) |
| return ret |
| |
| class ValidCtxt(ValidCtxtCore): |
| def __init__(self, _obj=None): |
| self._o = _obj |
| ValidCtxtCore.__init__(self, _obj=_obj) |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlFreeValidCtxt(self._o) |
| self._o = None |
| |
| # |
| # ValidCtxt functions from module valid |
| # |
| |
| def validCtxtNormalizeAttributeValue(self, doc, elem, name, value): |
| """Does the validation related extra step of the normalization |
| of attribute values: If the declared value is not CDATA, |
| then the XML processor must further process the normalized |
| attribute value by discarding any leading and trailing |
| space (#x20) characters, and by replacing sequences of |
| space (#x20) characters by single space (#x20) character. |
| Also check VC: Standalone Document Declaration in P32, and |
| update ctxt->valid accordingly """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlValidCtxtNormalizeAttributeValue(self._o, doc__o, elem__o, name, value) |
| return ret |
| |
| def validateDocument(self, doc): |
| """Try to validate the document instance basically it does |
| the all the checks described by the XML Rec i.e. validates |
| the internal and external subset (if present) and validate |
| the document tree. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlValidateDocument(self._o, doc__o) |
| return ret |
| |
| def validateDocumentFinal(self, doc): |
| """Does the final step for the document validation once all |
| the incremental validation steps have been completed |
| basically it does the following checks described by the XML |
| Rec Check all the IDREF/IDREFS attributes definition for |
| validity """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlValidateDocumentFinal(self._o, doc__o) |
| return ret |
| |
| def validateDtd(self, doc, dtd): |
| """Try to validate the document against the dtd instance |
| Basically it does check all the definitions in the DtD. |
| Note the the internal subset (if present) is de-coupled |
| (i.e. not used), which could give problems if ID or IDREF |
| is present. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if dtd is None: dtd__o = None |
| else: dtd__o = dtd._o |
| ret = libxml2mod.xmlValidateDtd(self._o, doc__o, dtd__o) |
| return ret |
| |
| def validateDtdFinal(self, doc): |
| """Does the final step for the dtds validation once all the |
| subsets have been parsed basically it does the following |
| checks described by the XML Rec - check that ENTITY and |
| ENTITIES type attributes default or possible values matches |
| one of the defined entities. - check that NOTATION type |
| attributes default or possible values matches one of the |
| defined notations. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlValidateDtdFinal(self._o, doc__o) |
| return ret |
| |
| def validateElement(self, doc, elem): |
| """Try to validate the subtree under an element """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlValidateElement(self._o, doc__o, elem__o) |
| return ret |
| |
| def validateNotationUse(self, doc, notationName): |
| """Validate that the given name match a notation declaration. |
| - [ VC: Notation Declared ] """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlValidateNotationUse(self._o, doc__o, notationName) |
| return ret |
| |
| def validateOneAttribute(self, doc, elem, attr, value): |
| """Try to validate a single attribute for an element basically |
| it does the following checks as described by the XML-1.0 |
| recommendation: - [ VC: Attribute Value Type ] - [ VC: |
| Fixed Attribute Default ] - [ VC: Entity Name ] - [ VC: |
| Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC: Entity |
| Name ] - [ VC: Notation Attributes ] The ID/IDREF |
| uniqueness and matching are done separately """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| if attr is None: attr__o = None |
| else: attr__o = attr._o |
| ret = libxml2mod.xmlValidateOneAttribute(self._o, doc__o, elem__o, attr__o, value) |
| return ret |
| |
| def validateOneElement(self, doc, elem): |
| """Try to validate a single element and it's attributes, |
| basically it does the following checks as described by the |
| XML-1.0 recommendation: - [ VC: Element Valid ] - [ VC: |
| Required Attribute ] Then call xmlValidateOneAttribute() |
| for each attribute present. The ID/IDREF checkings are |
| done separately """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlValidateOneElement(self._o, doc__o, elem__o) |
| return ret |
| |
| def validateOneNamespace(self, doc, elem, prefix, ns, value): |
| """Try to validate a single namespace declaration for an |
| element basically it does the following checks as described |
| by the XML-1.0 recommendation: - [ VC: Attribute Value Type |
| ] - [ VC: Fixed Attribute Default ] - [ VC: Entity Name ] - |
| [ VC: Name Token ] - [ VC: ID ] - [ VC: IDREF ] - [ VC: |
| Entity Name ] - [ VC: Notation Attributes ] The ID/IDREF |
| uniqueness and matching are done separately """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| if ns is None: ns__o = None |
| else: ns__o = ns._o |
| ret = libxml2mod.xmlValidateOneNamespace(self._o, doc__o, elem__o, prefix, ns__o, value) |
| return ret |
| |
| def validatePopElement(self, doc, elem, qname): |
| """Pop the element end from the validation stack. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlValidatePopElement(self._o, doc__o, elem__o, qname) |
| return ret |
| |
| def validatePushCData(self, data, len): |
| """check the CData parsed for validation in the current stack """ |
| ret = libxml2mod.xmlValidatePushCData(self._o, data, len) |
| return ret |
| |
| def validatePushElement(self, doc, elem, qname): |
| """Push a new element start on the validation stack. """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| if elem is None: elem__o = None |
| else: elem__o = elem._o |
| ret = libxml2mod.xmlValidatePushElement(self._o, doc__o, elem__o, qname) |
| return ret |
| |
| def validateRoot(self, doc): |
| """Try to validate a the root element basically it does the |
| following check as described by the XML-1.0 recommendation: |
| - [ VC: Root Element Type ] it doesn't try to recurse or |
| apply other check to the element """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| ret = libxml2mod.xmlValidateRoot(self._o, doc__o) |
| return ret |
| |
| class xpathContext: |
| def __init__(self, _obj=None): |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| # accessors for xpathContext |
| def contextDoc(self): |
| """Get the doc from an xpathContext """ |
| ret = libxml2mod.xmlXPathGetContextDoc(self._o) |
| if ret is None:raise xpathError('xmlXPathGetContextDoc() failed') |
| __tmp = xmlDoc(_obj=ret) |
| return __tmp |
| |
| def contextNode(self): |
| """Get the current node from an xpathContext """ |
| ret = libxml2mod.xmlXPathGetContextNode(self._o) |
| if ret is None:raise xpathError('xmlXPathGetContextNode() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def contextPosition(self): |
| """Get the current node from an xpathContext """ |
| ret = libxml2mod.xmlXPathGetContextPosition(self._o) |
| return ret |
| |
| def contextSize(self): |
| """Get the current node from an xpathContext """ |
| ret = libxml2mod.xmlXPathGetContextSize(self._o) |
| return ret |
| |
| def function(self): |
| """Get the current function name xpathContext """ |
| ret = libxml2mod.xmlXPathGetFunction(self._o) |
| return ret |
| |
| def functionURI(self): |
| """Get the current function name URI xpathContext """ |
| ret = libxml2mod.xmlXPathGetFunctionURI(self._o) |
| return ret |
| |
| def setContextDoc(self, doc): |
| """Set the doc of an xpathContext """ |
| if doc is None: doc__o = None |
| else: doc__o = doc._o |
| libxml2mod.xmlXPathSetContextDoc(self._o, doc__o) |
| |
| def setContextNode(self, node): |
| """Set the current node of an xpathContext """ |
| if node is None: node__o = None |
| else: node__o = node._o |
| libxml2mod.xmlXPathSetContextNode(self._o, node__o) |
| |
| # |
| # xpathContext functions from module python |
| # |
| |
| def registerXPathFunction(self, name, ns_uri, f): |
| """Register a Python written function to the XPath interpreter """ |
| ret = libxml2mod.xmlRegisterXPathFunction(self._o, name, ns_uri, f) |
| return ret |
| |
| def xpathRegisterVariable(self, name, ns_uri, value): |
| """Register a variable with the XPath context """ |
| ret = libxml2mod.xmlXPathRegisterVariable(self._o, name, ns_uri, value) |
| return ret |
| |
| # |
| # xpathContext functions from module xpath |
| # |
| |
| def xpathContextSetCache(self, active, value, options): |
| """Creates/frees an object cache on the XPath context. If |
| activates XPath objects (xmlXPathObject) will be cached |
| internally to be reused. @options: 0: This will set the |
| XPath object caching: @value: This will set the maximum |
| number of XPath objects to be cached per slot There are 5 |
| slots for: node-set, string, number, boolean, and misc |
| objects. Use <0 for the default number (100). Other values |
| for @options have currently no effect. """ |
| ret = libxml2mod.xmlXPathContextSetCache(self._o, active, value, options) |
| return ret |
| |
| def xpathEval(self, str): |
| """Evaluate the XPath Location Path in the given context. """ |
| ret = libxml2mod.xmlXPathEval(str, self._o) |
| if ret is None:raise xpathError('xmlXPathEval() failed') |
| return xpathObjectRet(ret) |
| |
| def xpathEvalExpression(self, str): |
| """Evaluate the XPath expression in the given context. """ |
| ret = libxml2mod.xmlXPathEvalExpression(str, self._o) |
| if ret is None:raise xpathError('xmlXPathEvalExpression() failed') |
| return xpathObjectRet(ret) |
| |
| def xpathFreeContext(self): |
| """Free up an xmlXPathContext """ |
| libxml2mod.xmlXPathFreeContext(self._o) |
| |
| # |
| # xpathContext functions from module xpathInternals |
| # |
| |
| def xpathNewParserContext(self, str): |
| """Create a new xmlXPathParserContext """ |
| ret = libxml2mod.xmlXPathNewParserContext(str, self._o) |
| if ret is None:raise xpathError('xmlXPathNewParserContext() failed') |
| __tmp = xpathParserContext(_obj=ret) |
| return __tmp |
| |
| def xpathNsLookup(self, prefix): |
| """Search in the namespace declaration array of the context |
| for the given namespace name associated to the given prefix """ |
| ret = libxml2mod.xmlXPathNsLookup(self._o, prefix) |
| return ret |
| |
| def xpathRegisterAllFunctions(self): |
| """Registers all default XPath functions in this context """ |
| libxml2mod.xmlXPathRegisterAllFunctions(self._o) |
| |
| def xpathRegisterNs(self, prefix, ns_uri): |
| """Register a new namespace. If @ns_uri is None it unregisters |
| the namespace """ |
| ret = libxml2mod.xmlXPathRegisterNs(self._o, prefix, ns_uri) |
| return ret |
| |
| def xpathRegisteredFuncsCleanup(self): |
| """Cleanup the XPath context data associated to registered |
| functions """ |
| libxml2mod.xmlXPathRegisteredFuncsCleanup(self._o) |
| |
| def xpathRegisteredNsCleanup(self): |
| """Cleanup the XPath context data associated to registered |
| variables """ |
| libxml2mod.xmlXPathRegisteredNsCleanup(self._o) |
| |
| def xpathRegisteredVariablesCleanup(self): |
| """Cleanup the XPath context data associated to registered |
| variables """ |
| libxml2mod.xmlXPathRegisteredVariablesCleanup(self._o) |
| |
| def xpathVariableLookup(self, name): |
| """Search in the Variable array of the context for the given |
| variable value. """ |
| ret = libxml2mod.xmlXPathVariableLookup(self._o, name) |
| if ret is None:raise xpathError('xmlXPathVariableLookup() failed') |
| return xpathObjectRet(ret) |
| |
| def xpathVariableLookupNS(self, name, ns_uri): |
| """Search in the Variable array of the context for the given |
| variable value. """ |
| ret = libxml2mod.xmlXPathVariableLookupNS(self._o, name, ns_uri) |
| if ret is None:raise xpathError('xmlXPathVariableLookupNS() failed') |
| return xpathObjectRet(ret) |
| |
| # |
| # xpathContext functions from module xpointer |
| # |
| |
| def xpointerEval(self, str): |
| """Evaluate the XPath Location Path in the given context. """ |
| ret = libxml2mod.xmlXPtrEval(str, self._o) |
| if ret is None:raise treeError('xmlXPtrEval() failed') |
| return xpathObjectRet(ret) |
| |
| class xpathParserContext: |
| def __init__(self, _obj=None): |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| # accessors for xpathParserContext |
| def context(self): |
| """Get the xpathContext from an xpathParserContext """ |
| ret = libxml2mod.xmlXPathParserGetContext(self._o) |
| if ret is None:raise xpathError('xmlXPathParserGetContext() failed') |
| __tmp = xpathContext(_obj=ret) |
| return __tmp |
| |
| # |
| # xpathParserContext functions from module xpathInternals |
| # |
| |
| def xpathAddValues(self): |
| """Implement the add operation on XPath objects: The numeric |
| operators convert their operands to numbers as if by |
| calling the number function. """ |
| libxml2mod.xmlXPathAddValues(self._o) |
| |
| def xpathBooleanFunction(self, nargs): |
| """Implement the boolean() XPath function boolean |
| boolean(object) The boolean function converts its argument |
| to a boolean as follows: - a number is true if and only if |
| it is neither positive or negative zero nor NaN - a |
| node-set is true if and only if it is non-empty - a string |
| is true if and only if its length is non-zero """ |
| libxml2mod.xmlXPathBooleanFunction(self._o, nargs) |
| |
| def xpathCeilingFunction(self, nargs): |
| """Implement the ceiling() XPath function number |
| ceiling(number) The ceiling function returns the smallest |
| (closest to negative infinity) number that is not less than |
| the argument and that is an integer. """ |
| libxml2mod.xmlXPathCeilingFunction(self._o, nargs) |
| |
| def xpathCompareValues(self, inf, strict): |
| """Implement the compare operation on XPath objects: @arg1 < |
| @arg2 (1, 1, ... @arg1 <= @arg2 (1, 0, ... @arg1 > |
| @arg2 (0, 1, ... @arg1 >= @arg2 (0, 0, ... When |
| neither object to be compared is a node-set and the |
| operator is <=, <, >=, >, then the objects are compared by |
| converted both objects to numbers and comparing the numbers |
| according to IEEE 754. The < comparison will be true if and |
| only if the first number is less than the second number. |
| The <= comparison will be true if and only if the first |
| number is less than or equal to the second number. The > |
| comparison will be true if and only if the first number is |
| greater than the second number. The >= comparison will be |
| true if and only if the first number is greater than or |
| equal to the second number. """ |
| ret = libxml2mod.xmlXPathCompareValues(self._o, inf, strict) |
| return ret |
| |
| def xpathConcatFunction(self, nargs): |
| """Implement the concat() XPath function string concat(string, |
| string, string*) The concat function returns the |
| concatenation of its arguments. """ |
| libxml2mod.xmlXPathConcatFunction(self._o, nargs) |
| |
| def xpathContainsFunction(self, nargs): |
| """Implement the contains() XPath function boolean |
| contains(string, string) The contains function returns true |
| if the first argument string contains the second argument |
| string, and otherwise returns false. """ |
| libxml2mod.xmlXPathContainsFunction(self._o, nargs) |
| |
| def xpathCountFunction(self, nargs): |
| """Implement the count() XPath function number count(node-set) """ |
| libxml2mod.xmlXPathCountFunction(self._o, nargs) |
| |
| def xpathDivValues(self): |
| """Implement the div operation on XPath objects @arg1 / @arg2: |
| The numeric operators convert their operands to numbers as |
| if by calling the number function. """ |
| libxml2mod.xmlXPathDivValues(self._o) |
| |
| def xpathEqualValues(self): |
| """Implement the equal operation on XPath objects content: |
| @arg1 == @arg2 """ |
| ret = libxml2mod.xmlXPathEqualValues(self._o) |
| return ret |
| |
| def xpathErr(self, error): |
| """Handle an XPath error """ |
| libxml2mod.xmlXPathErr(self._o, error) |
| |
| def xpathEvalExpr(self): |
| """Parse and evaluate an XPath expression in the given |
| context, then push the result on the context stack """ |
| libxml2mod.xmlXPathEvalExpr(self._o) |
| |
| def xpathFalseFunction(self, nargs): |
| """Implement the false() XPath function boolean false() """ |
| libxml2mod.xmlXPathFalseFunction(self._o, nargs) |
| |
| def xpathFloorFunction(self, nargs): |
| """Implement the floor() XPath function number floor(number) |
| The floor function returns the largest (closest to positive |
| infinity) number that is not greater than the argument and |
| that is an integer. """ |
| libxml2mod.xmlXPathFloorFunction(self._o, nargs) |
| |
| def xpathFreeParserContext(self): |
| """Free up an xmlXPathParserContext """ |
| libxml2mod.xmlXPathFreeParserContext(self._o) |
| |
| def xpathIdFunction(self, nargs): |
| """Implement the id() XPath function node-set id(object) The |
| id function selects elements by their unique ID (see [5.2.1 |
| Unique IDs]). When the argument to id is of type node-set, |
| then the result is the union of the result of applying id |
| to the string value of each of the nodes in the argument |
| node-set. When the argument to id is of any other type, the |
| argument is converted to a string as if by a call to the |
| string function; the string is split into a |
| whitespace-separated list of tokens (whitespace is any |
| sequence of characters matching the production S); the |
| result is a node-set containing the elements in the same |
| document as the context node that have a unique ID equal to |
| any of the tokens in the list. """ |
| libxml2mod.xmlXPathIdFunction(self._o, nargs) |
| |
| def xpathLangFunction(self, nargs): |
| """Implement the lang() XPath function boolean lang(string) |
| The lang function returns true or false depending on |
| whether the language of the context node as specified by |
| xml:lang attributes is the same as or is a sublanguage of |
| the language specified by the argument string. The language |
| of the context node is determined by the value of the |
| xml:lang attribute on the context node, or, if the context |
| node has no xml:lang attribute, by the value of the |
| xml:lang attribute on the nearest ancestor of the context |
| node that has an xml:lang attribute. If there is no such |
| attribute, then lang """ |
| libxml2mod.xmlXPathLangFunction(self._o, nargs) |
| |
| def xpathLastFunction(self, nargs): |
| """Implement the last() XPath function number last() The last |
| function returns the number of nodes in the context node |
| list. """ |
| libxml2mod.xmlXPathLastFunction(self._o, nargs) |
| |
| def xpathLocalNameFunction(self, nargs): |
| """Implement the local-name() XPath function string |
| local-name(node-set?) The local-name function returns a |
| string containing the local part of the name of the node in |
| the argument node-set that is first in document order. If |
| the node-set is empty or the first node has no name, an |
| empty string is returned. If the argument is omitted it |
| defaults to the context node. """ |
| libxml2mod.xmlXPathLocalNameFunction(self._o, nargs) |
| |
| def xpathModValues(self): |
| """Implement the mod operation on XPath objects: @arg1 / @arg2 |
| The numeric operators convert their operands to numbers as |
| if by calling the number function. """ |
| libxml2mod.xmlXPathModValues(self._o) |
| |
| def xpathMultValues(self): |
| """Implement the multiply operation on XPath objects: The |
| numeric operators convert their operands to numbers as if |
| by calling the number function. """ |
| libxml2mod.xmlXPathMultValues(self._o) |
| |
| def xpathNamespaceURIFunction(self, nargs): |
| """Implement the namespace-uri() XPath function string |
| namespace-uri(node-set?) The namespace-uri function returns |
| a string containing the namespace URI of the expanded name |
| of the node in the argument node-set that is first in |
| document order. If the node-set is empty, the first node |
| has no name, or the expanded name has no namespace URI, an |
| empty string is returned. If the argument is omitted it |
| defaults to the context node. """ |
| libxml2mod.xmlXPathNamespaceURIFunction(self._o, nargs) |
| |
| def xpathNextAncestor(self, cur): |
| """Traversal function for the "ancestor" direction the |
| ancestor axis contains the ancestors of the context node; |
| the ancestors of the context node consist of the parent of |
| context node and the parent's parent and so on; the nodes |
| are ordered in reverse document order; thus the parent is |
| the first node on the axis, and the parent's parent is the |
| second node on the axis """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextAncestor(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextAncestor() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextAncestorOrSelf(self, cur): |
| """Traversal function for the "ancestor-or-self" direction he |
| ancestor-or-self axis contains the context node and |
| ancestors of the context node in reverse document order; |
| thus the context node is the first node on the axis, and |
| the context node's parent the second; parent here is |
| defined the same as with the parent axis. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextAncestorOrSelf(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextAncestorOrSelf() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextAttribute(self, cur): |
| """Traversal function for the "attribute" direction TODO: |
| support DTD inherited default attributes """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextAttribute(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextAttribute() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextChild(self, cur): |
| """Traversal function for the "child" direction The child axis |
| contains the children of the context node in document order. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextChild(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextChild() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextDescendant(self, cur): |
| """Traversal function for the "descendant" direction the |
| descendant axis contains the descendants of the context |
| node in document order; a descendant is a child or a child |
| of a child and so on. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextDescendant(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextDescendant() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextDescendantOrSelf(self, cur): |
| """Traversal function for the "descendant-or-self" direction |
| the descendant-or-self axis contains the context node and |
| the descendants of the context node in document order; thus |
| the context node is the first node on the axis, and the |
| first child of the context node is the second node on the |
| axis """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextDescendantOrSelf(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextDescendantOrSelf() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextFollowing(self, cur): |
| """Traversal function for the "following" direction The |
| following axis contains all nodes in the same document as |
| the context node that are after the context node in |
| document order, excluding any descendants and excluding |
| attribute nodes and namespace nodes; the nodes are ordered |
| in document order """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextFollowing(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextFollowing() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextFollowingSibling(self, cur): |
| """Traversal function for the "following-sibling" direction |
| The following-sibling axis contains the following siblings |
| of the context node in document order. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextFollowingSibling(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextFollowingSibling() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextNamespace(self, cur): |
| """Traversal function for the "namespace" direction the |
| namespace axis contains the namespace nodes of the context |
| node; the order of nodes on this axis is |
| implementation-defined; the axis will be empty unless the |
| context node is an element We keep the XML namespace node |
| at the end of the list. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextNamespace(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextNamespace() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextParent(self, cur): |
| """Traversal function for the "parent" direction The parent |
| axis contains the parent of the context node, if there is |
| one. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextParent(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextParent() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextPreceding(self, cur): |
| """Traversal function for the "preceding" direction the |
| preceding axis contains all nodes in the same document as |
| the context node that are before the context node in |
| document order, excluding any ancestors and excluding |
| attribute nodes and namespace nodes; the nodes are ordered |
| in reverse document order """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextPreceding(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextPreceding() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextPrecedingSibling(self, cur): |
| """Traversal function for the "preceding-sibling" direction |
| The preceding-sibling axis contains the preceding siblings |
| of the context node in reverse document order; the first |
| preceding sibling is first on the axis; the sibling |
| preceding that node is the second on the axis and so on. """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextPrecedingSibling(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextPrecedingSibling() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNextSelf(self, cur): |
| """Traversal function for the "self" direction The self axis |
| contains just the context node itself """ |
| if cur is None: cur__o = None |
| else: cur__o = cur._o |
| ret = libxml2mod.xmlXPathNextSelf(self._o, cur__o) |
| if ret is None:raise xpathError('xmlXPathNextSelf() failed') |
| __tmp = xmlNode(_obj=ret) |
| return __tmp |
| |
| def xpathNormalizeFunction(self, nargs): |
| """Implement the normalize-space() XPath function string |
| normalize-space(string?) The normalize-space function |
| returns the argument string with white space normalized by |
| stripping leading and trailing whitespace and replacing |
| sequences of whitespace characters by a single space. |
| Whitespace characters are the same allowed by the S |
| production in XML. If the argument is omitted, it defaults |
| to the context node converted to a string, in other words |
| the value of the context node. """ |
| libxml2mod.xmlXPathNormalizeFunction(self._o, nargs) |
| |
| def xpathNotEqualValues(self): |
| """Implement the equal operation on XPath objects content: |
| @arg1 == @arg2 """ |
| ret = libxml2mod.xmlXPathNotEqualValues(self._o) |
| return ret |
| |
| def xpathNotFunction(self, nargs): |
| """Implement the not() XPath function boolean not(boolean) The |
| not function returns true if its argument is false, and |
| false otherwise. """ |
| libxml2mod.xmlXPathNotFunction(self._o, nargs) |
| |
| def xpathNumberFunction(self, nargs): |
| """Implement the number() XPath function number number(object?) """ |
| libxml2mod.xmlXPathNumberFunction(self._o, nargs) |
| |
| def xpathParseNCName(self): |
| """parse an XML namespace non qualified name. [NS 3] NCName |
| ::= (Letter | '_') (NCNameChar)* [NS 4] NCNameChar ::= |
| Letter | Digit | '.' | '-' | '_' | CombiningChar | Extender """ |
| ret = libxml2mod.xmlXPathParseNCName(self._o) |
| return ret |
| |
| def xpathParseName(self): |
| """parse an XML name [4] NameChar ::= Letter | Digit | '.' | |
| '-' | '_' | ':' | CombiningChar | Extender [5] Name ::= |
| (Letter | '_' | ':') (NameChar)* """ |
| ret = libxml2mod.xmlXPathParseName(self._o) |
| return ret |
| |
| def xpathPopBoolean(self): |
| """Pops a boolean from the stack, handling conversion if |
| needed. Check error with #xmlXPathCheckError. """ |
| ret = libxml2mod.xmlXPathPopBoolean(self._o) |
| return ret |
| |
| def xpathPopNumber(self): |
| """Pops a number from the stack, handling conversion if |
| needed. Check error with #xmlXPathCheckError. """ |
| ret = libxml2mod.xmlXPathPopNumber(self._o) |
| return ret |
| |
| def xpathPopString(self): |
| """Pops a string from the stack, handling conversion if |
| needed. Check error with #xmlXPathCheckError. """ |
| ret = libxml2mod.xmlXPathPopString(self._o) |
| return ret |
| |
| def xpathPositionFunction(self, nargs): |
| """Implement the position() XPath function number position() |
| The position function returns the position of the context |
| node in the context node list. The first position is 1, and |
| so the last position will be equal to last(). """ |
| libxml2mod.xmlXPathPositionFunction(self._o, nargs) |
| |
| def xpathRoot(self): |
| """Initialize the context to the root of the document """ |
| libxml2mod.xmlXPathRoot(self._o) |
| |
| def xpathRoundFunction(self, nargs): |
| """Implement the round() XPath function number round(number) |
| The round function returns the number that is closest to |
| the argument and that is an integer. If there are two such |
| numbers, then the one that is even is returned. """ |
| libxml2mod.xmlXPathRoundFunction(self._o, nargs) |
| |
| def xpathStartsWithFunction(self, nargs): |
| """Implement the starts-with() XPath function boolean |
| starts-with(string, string) The starts-with function |
| returns true if the first argument string starts with the |
| second argument string, and otherwise returns false. """ |
| libxml2mod.xmlXPathStartsWithFunction(self._o, nargs) |
| |
| def xpathStringFunction(self, nargs): |
| """Implement the string() XPath function string |
| string(object?) The string function converts an object to a |
| string as follows: - A node-set is converted to a string by |
| returning the value of the node in the node-set that is |
| first in document order. If the node-set is empty, an empty |
| string is returned. - A number is converted to a string as |
| follows + NaN is converted to the string NaN + positive |
| zero is converted to the string 0 + negative zero is |
| converted to the string 0 + positive infinity is converted |
| to the string Infinity + negative infinity is converted to |
| the string -Infinity + if the number is an integer, the |
| number is represented in decimal form as a Number with no |
| decimal point and no leading zeros, preceded by a minus |
| sign (-) if the number is negative + otherwise, the number |
| is represented in decimal form as a Number including a |
| decimal point with at least one digit before the decimal |
| point and at least one digit after the decimal point, |
| preceded by a minus sign (-) if the number is negative; |
| there must be no leading zeros before the decimal point |
| apart possibly from the one required digit immediately |
| before the decimal point; beyond the one required digit |
| after the decimal point there must be as many, but only as |
| many, more digits as are needed to uniquely distinguish the |
| number from all other IEEE 754 numeric values. - The |
| boolean false value is converted to the string false. The |
| boolean true value is converted to the string true. If the |
| argument is omitted, it defaults to a node-set with the |
| context node as its only member. """ |
| libxml2mod.xmlXPathStringFunction(self._o, nargs) |
| |
| def xpathStringLengthFunction(self, nargs): |
| """Implement the string-length() XPath function number |
| string-length(string?) The string-length returns the number |
| of characters in the string (see [3.6 Strings]). If the |
| argument is omitted, it defaults to the context node |
| converted to a string, in other words the value of the |
| context node. """ |
| libxml2mod.xmlXPathStringLengthFunction(self._o, nargs) |
| |
| def xpathSubValues(self): |
| """Implement the subtraction operation on XPath objects: The |
| numeric operators convert their operands to numbers as if |
| by calling the number function. """ |
| libxml2mod.xmlXPathSubValues(self._o) |
| |
| def xpathSubstringAfterFunction(self, nargs): |
| """Implement the substring-after() XPath function string |
| substring-after(string, string) The substring-after |
| function returns the substring of the first argument string |
| that follows the first occurrence of the second argument |
| string in the first argument string, or the empty stringi |
| if the first argument string does not contain the second |
| argument string. For example, |
| substring-after("1999/04/01","/") returns 04/01, and |
| substring-after("1999/04/01","19") returns 99/04/01. """ |
| libxml2mod.xmlXPathSubstringAfterFunction(self._o, nargs) |
| |
| def xpathSubstringBeforeFunction(self, nargs): |
| """Implement the substring-before() XPath function string |
| substring-before(string, string) The substring-before |
| function returns the substring of the first argument string |
| that precedes the first occurrence of the second argument |
| string in the first argument string, or the empty string if |
| the first argument string does not contain the second |
| argument string. For example, |
| substring-before("1999/04/01","/") returns 1999. """ |
| libxml2mod.xmlXPathSubstringBeforeFunction(self._o, nargs) |
| |
| def xpathSubstringFunction(self, nargs): |
| """Implement the substring() XPath function string |
| substring(string, number, number?) The substring function |
| returns the substring of the first argument starting at the |
| position specified in the second argument with length |
| specified in the third argument. For example, |
| substring("12345",2,3) returns "234". If the third argument |
| is not specified, it returns the substring starting at the |
| position specified in the second argument and continuing to |
| the end of the string. For example, substring("12345",2) |
| returns "2345". More precisely, each character in the |
| string (see [3.6 Strings]) is considered to have a numeric |
| position: the position of the first character is 1, the |
| position of the second character is 2 and so on. The |
| returned substring contains those characters for which the |
| position of the character is greater than or equal to the |
| second argument and, if the third argument is specified, |
| less than the sum of the second and third arguments; the |
| comparisons and addition used for the above follow the |
| standard IEEE 754 rules. Thus: - substring("12345", 1.5, |
| 2.6) returns "234" - substring("12345", 0, 3) returns "12" |
| - substring("12345", 0 div 0, 3) returns "" - |
| substring("12345", 1, 0 div 0) returns "" - |
| substring("12345", -42, 1 div 0) returns "12345" - |
| substring("12345", -1 div 0, 1 div 0) returns "" """ |
| libxml2mod.xmlXPathSubstringFunction(self._o, nargs) |
| |
| def xpathSumFunction(self, nargs): |
| """Implement the sum() XPath function number sum(node-set) The |
| sum function returns the sum of the values of the nodes in |
| the argument node-set. """ |
| libxml2mod.xmlXPathSumFunction(self._o, nargs) |
| |
| def xpathTranslateFunction(self, nargs): |
| """Implement the translate() XPath function string |
| translate(string, string, string) The translate function |
| returns the first argument string with occurrences of |
| characters in the second argument string replaced by the |
| character at the corresponding position in the third |
| argument string. For example, translate("bar","abc","ABC") |
| returns the string BAr. If there is a character in the |
| second argument string with no character at a corresponding |
| position in the third argument string (because the second |
| argument string is longer than the third argument string), |
| then occurrences of that character in the first argument |
| string are removed. For example, |
| translate("--aaa--","abc-","ABC") """ |
| libxml2mod.xmlXPathTranslateFunction(self._o, nargs) |
| |
| def xpathTrueFunction(self, nargs): |
| """Implement the true() XPath function boolean true() """ |
| libxml2mod.xmlXPathTrueFunction(self._o, nargs) |
| |
| def xpathValueFlipSign(self): |
| """Implement the unary - operation on an XPath object The |
| numeric operators convert their operands to numbers as if |
| by calling the number function. """ |
| libxml2mod.xmlXPathValueFlipSign(self._o) |
| |
| def xpatherror(self, file, line, no): |
| """Formats an error message. """ |
| libxml2mod.xmlXPatherror(self._o, file, line, no) |
| |
| # |
| # xpathParserContext functions from module xpointer |
| # |
| |
| def xpointerEvalRangePredicate(self): |
| """[8] Predicate ::= '[' PredicateExpr ']' [9] |
| PredicateExpr ::= Expr Evaluate a predicate as in |
| xmlXPathEvalPredicate() but for a Location Set instead of a |
| node set """ |
| libxml2mod.xmlXPtrEvalRangePredicate(self._o) |
| |
| def xpointerRangeToFunction(self, nargs): |
| """Implement the range-to() XPointer function """ |
| libxml2mod.xmlXPtrRangeToFunction(self._o, nargs) |
| |
| # xlinkShow |
| XLINK_SHOW_NONE = 0 |
| XLINK_SHOW_NEW = 1 |
| XLINK_SHOW_EMBED = 2 |
| XLINK_SHOW_REPLACE = 3 |
| |
| # xmlRelaxNGParserFlag |
| XML_RELAXNGP_NONE = 0 |
| XML_RELAXNGP_FREE_DOC = 1 |
| XML_RELAXNGP_CRNG = 2 |
| |
| # xmlBufferAllocationScheme |
| XML_BUFFER_ALLOC_DOUBLEIT = 1 |
| XML_BUFFER_ALLOC_EXACT = 2 |
| XML_BUFFER_ALLOC_IMMUTABLE = 3 |
| XML_BUFFER_ALLOC_IO = 4 |
| XML_BUFFER_ALLOC_HYBRID = 5 |
| XML_BUFFER_ALLOC_BOUNDED = 6 |
| |
| # xmlParserSeverities |
| XML_PARSER_SEVERITY_VALIDITY_WARNING = 1 |
| XML_PARSER_SEVERITY_VALIDITY_ERROR = 2 |
| XML_PARSER_SEVERITY_WARNING = 3 |
| XML_PARSER_SEVERITY_ERROR = 4 |
| |
| # xmlAttributeDefault |
| XML_ATTRIBUTE_NONE = 1 |
| XML_ATTRIBUTE_REQUIRED = 2 |
| XML_ATTRIBUTE_IMPLIED = 3 |
| XML_ATTRIBUTE_FIXED = 4 |
| |
| # xmlSchemaValType |
| XML_SCHEMAS_UNKNOWN = 0 |
| XML_SCHEMAS_STRING = 1 |
| XML_SCHEMAS_NORMSTRING = 2 |
| XML_SCHEMAS_DECIMAL = 3 |
| XML_SCHEMAS_TIME = 4 |
| XML_SCHEMAS_GDAY = 5 |
| XML_SCHEMAS_GMONTH = 6 |
| XML_SCHEMAS_GMONTHDAY = 7 |
| XML_SCHEMAS_GYEAR = 8 |
| XML_SCHEMAS_GYEARMONTH = 9 |
| XML_SCHEMAS_DATE = 10 |
| XML_SCHEMAS_DATETIME = 11 |
| XML_SCHEMAS_DURATION = 12 |
| XML_SCHEMAS_FLOAT = 13 |
| XML_SCHEMAS_DOUBLE = 14 |
| XML_SCHEMAS_BOOLEAN = 15 |
| XML_SCHEMAS_TOKEN = 16 |
| XML_SCHEMAS_LANGUAGE = 17 |
| XML_SCHEMAS_NMTOKEN = 18 |
| XML_SCHEMAS_NMTOKENS = 19 |
| XML_SCHEMAS_NAME = 20 |
| XML_SCHEMAS_QNAME = 21 |
| XML_SCHEMAS_NCNAME = 22 |
| XML_SCHEMAS_ID = 23 |
| XML_SCHEMAS_IDREF = 24 |
| XML_SCHEMAS_IDREFS = 25 |
| XML_SCHEMAS_ENTITY = 26 |
| XML_SCHEMAS_ENTITIES = 27 |
| XML_SCHEMAS_NOTATION = 28 |
| XML_SCHEMAS_ANYURI = 29 |
| XML_SCHEMAS_INTEGER = 30 |
| XML_SCHEMAS_NPINTEGER = 31 |
| XML_SCHEMAS_NINTEGER = 32 |
| XML_SCHEMAS_NNINTEGER = 33 |
| XML_SCHEMAS_PINTEGER = 34 |
| XML_SCHEMAS_INT = 35 |
| XML_SCHEMAS_UINT = 36 |
| XML_SCHEMAS_LONG = 37 |
| XML_SCHEMAS_ULONG = 38 |
| XML_SCHEMAS_SHORT = 39 |
| XML_SCHEMAS_USHORT = 40 |
| XML_SCHEMAS_BYTE = 41 |
| XML_SCHEMAS_UBYTE = 42 |
| XML_SCHEMAS_HEXBINARY = 43 |
| XML_SCHEMAS_BASE64BINARY = 44 |
| XML_SCHEMAS_ANYTYPE = 45 |
| XML_SCHEMAS_ANYSIMPLETYPE = 46 |
| |
| # xmlParserInputState |
| XML_PARSER_EOF = -1 |
| XML_PARSER_START = 0 |
| XML_PARSER_MISC = 1 |
| XML_PARSER_PI = 2 |
| XML_PARSER_DTD = 3 |
| XML_PARSER_PROLOG = 4 |
| XML_PARSER_COMMENT = 5 |
| XML_PARSER_START_TAG = 6 |
| XML_PARSER_CONTENT = 7 |
| XML_PARSER_CDATA_SECTION = 8 |
| XML_PARSER_END_TAG = 9 |
| XML_PARSER_ENTITY_DECL = 10 |
| XML_PARSER_ENTITY_VALUE = 11 |
| XML_PARSER_ATTRIBUTE_VALUE = 12 |
| XML_PARSER_SYSTEM_LITERAL = 13 |
| XML_PARSER_EPILOG = 14 |
| XML_PARSER_IGNORE = 15 |
| XML_PARSER_PUBLIC_LITERAL = 16 |
| |
| # xmlEntityType |
| XML_INTERNAL_GENERAL_ENTITY = 1 |
| XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2 |
| XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3 |
| XML_INTERNAL_PARAMETER_ENTITY = 4 |
| XML_EXTERNAL_PARAMETER_ENTITY = 5 |
| XML_INTERNAL_PREDEFINED_ENTITY = 6 |
| |
| # xmlSaveOption |
| XML_SAVE_FORMAT = 1 |
| XML_SAVE_NO_DECL = 2 |
| XML_SAVE_NO_EMPTY = 4 |
| XML_SAVE_NO_XHTML = 8 |
| XML_SAVE_XHTML = 16 |
| XML_SAVE_AS_XML = 32 |
| XML_SAVE_AS_HTML = 64 |
| XML_SAVE_WSNONSIG = 128 |
| |
| # xmlPatternFlags |
| XML_PATTERN_DEFAULT = 0 |
| XML_PATTERN_XPATH = 1 |
| XML_PATTERN_XSSEL = 2 |
| XML_PATTERN_XSFIELD = 4 |
| |
| # xmlParserErrors |
| XML_ERR_OK = 0 |
| XML_ERR_INTERNAL_ERROR = 1 |
| XML_ERR_NO_MEMORY = 2 |
| XML_ERR_DOCUMENT_START = 3 |
| XML_ERR_DOCUMENT_EMPTY = 4 |
| XML_ERR_DOCUMENT_END = 5 |
| XML_ERR_INVALID_HEX_CHARREF = 6 |
| XML_ERR_INVALID_DEC_CHARREF = 7 |
| XML_ERR_INVALID_CHARREF = 8 |
| XML_ERR_INVALID_CHAR = 9 |
| XML_ERR_CHARREF_AT_EOF = 10 |
| XML_ERR_CHARREF_IN_PROLOG = 11 |
| XML_ERR_CHARREF_IN_EPILOG = 12 |
| XML_ERR_CHARREF_IN_DTD = 13 |
| XML_ERR_ENTITYREF_AT_EOF = 14 |
| XML_ERR_ENTITYREF_IN_PROLOG = 15 |
| XML_ERR_ENTITYREF_IN_EPILOG = 16 |
| XML_ERR_ENTITYREF_IN_DTD = 17 |
| XML_ERR_PEREF_AT_EOF = 18 |
| XML_ERR_PEREF_IN_PROLOG = 19 |
| XML_ERR_PEREF_IN_EPILOG = 20 |
| XML_ERR_PEREF_IN_INT_SUBSET = 21 |
| XML_ERR_ENTITYREF_NO_NAME = 22 |
| XML_ERR_ENTITYREF_SEMICOL_MISSING = 23 |
| XML_ERR_PEREF_NO_NAME = 24 |
| XML_ERR_PEREF_SEMICOL_MISSING = 25 |
| XML_ERR_UNDECLARED_ENTITY = 26 |
| XML_WAR_UNDECLARED_ENTITY = 27 |
| XML_ERR_UNPARSED_ENTITY = 28 |
| XML_ERR_ENTITY_IS_EXTERNAL = 29 |
| XML_ERR_ENTITY_IS_PARAMETER = 30 |
| XML_ERR_UNKNOWN_ENCODING = 31 |
| XML_ERR_UNSUPPORTED_ENCODING = 32 |
| XML_ERR_STRING_NOT_STARTED = 33 |
| XML_ERR_STRING_NOT_CLOSED = 34 |
| XML_ERR_NS_DECL_ERROR = 35 |
| XML_ERR_ENTITY_NOT_STARTED = 36 |
| XML_ERR_ENTITY_NOT_FINISHED = 37 |
| XML_ERR_LT_IN_ATTRIBUTE = 38 |
| XML_ERR_ATTRIBUTE_NOT_STARTED = 39 |
| XML_ERR_ATTRIBUTE_NOT_FINISHED = 40 |
| XML_ERR_ATTRIBUTE_WITHOUT_VALUE = 41 |
| XML_ERR_ATTRIBUTE_REDEFINED = 42 |
| XML_ERR_LITERAL_NOT_STARTED = 43 |
| XML_ERR_LITERAL_NOT_FINISHED = 44 |
| XML_ERR_COMMENT_NOT_FINISHED = 45 |
| XML_ERR_PI_NOT_STARTED = 46 |
| XML_ERR_PI_NOT_FINISHED = 47 |
| XML_ERR_NOTATION_NOT_STARTED = 48 |
| XML_ERR_NOTATION_NOT_FINISHED = 49 |
| XML_ERR_ATTLIST_NOT_STARTED = 50 |
| XML_ERR_ATTLIST_NOT_FINISHED = 51 |
| XML_ERR_MIXED_NOT_STARTED = 52 |
| XML_ERR_MIXED_NOT_FINISHED = 53 |
| XML_ERR_ELEMCONTENT_NOT_STARTED = 54 |
| XML_ERR_ELEMCONTENT_NOT_FINISHED = 55 |
| XML_ERR_XMLDECL_NOT_STARTED = 56 |
| XML_ERR_XMLDECL_NOT_FINISHED = 57 |
| XML_ERR_CONDSEC_NOT_STARTED = 58 |
| XML_ERR_CONDSEC_NOT_FINISHED = 59 |
| XML_ERR_EXT_SUBSET_NOT_FINISHED = 60 |
| XML_ERR_DOCTYPE_NOT_FINISHED = 61 |
| XML_ERR_MISPLACED_CDATA_END = 62 |
| XML_ERR_CDATA_NOT_FINISHED = 63 |
| XML_ERR_RESERVED_XML_NAME = 64 |
| XML_ERR_SPACE_REQUIRED = 65 |
| XML_ERR_SEPARATOR_REQUIRED = 66 |
| XML_ERR_NMTOKEN_REQUIRED = 67 |
| XML_ERR_NAME_REQUIRED = 68 |
| XML_ERR_PCDATA_REQUIRED = 69 |
| XML_ERR_URI_REQUIRED = 70 |
| XML_ERR_PUBID_REQUIRED = 71 |
| XML_ERR_LT_REQUIRED = 72 |
| XML_ERR_GT_REQUIRED = 73 |
| XML_ERR_LTSLASH_REQUIRED = 74 |
| XML_ERR_EQUAL_REQUIRED = 75 |
| XML_ERR_TAG_NAME_MISMATCH = 76 |
| XML_ERR_TAG_NOT_FINISHED = 77 |
| XML_ERR_STANDALONE_VALUE = 78 |
| XML_ERR_ENCODING_NAME = 79 |
| XML_ERR_HYPHEN_IN_COMMENT = 80 |
| XML_ERR_INVALID_ENCODING = 81 |
| XML_ERR_EXT_ENTITY_STANDALONE = 82 |
| XML_ERR_CONDSEC_INVALID = 83 |
| XML_ERR_VALUE_REQUIRED = 84 |
| XML_ERR_NOT_WELL_BALANCED = 85 |
| XML_ERR_EXTRA_CONTENT = 86 |
| XML_ERR_ENTITY_CHAR_ERROR = 87 |
| XML_ERR_ENTITY_PE_INTERNAL = 88 |
| XML_ERR_ENTITY_LOOP = 89 |
| XML_ERR_ENTITY_BOUNDARY = 90 |
| XML_ERR_INVALID_URI = 91 |
| XML_ERR_URI_FRAGMENT = 92 |
| XML_WAR_CATALOG_PI = 93 |
| XML_ERR_NO_DTD = 94 |
| XML_ERR_CONDSEC_INVALID_KEYWORD = 95 |
| XML_ERR_VERSION_MISSING = 96 |
| XML_WAR_UNKNOWN_VERSION = 97 |
| XML_WAR_LANG_VALUE = 98 |
| XML_WAR_NS_URI = 99 |
| XML_WAR_NS_URI_RELATIVE = 100 |
| XML_ERR_MISSING_ENCODING = 101 |
| XML_WAR_SPACE_VALUE = 102 |
| XML_ERR_NOT_STANDALONE = 103 |
| XML_ERR_ENTITY_PROCESSING = 104 |
| XML_ERR_NOTATION_PROCESSING = 105 |
| XML_WAR_NS_COLUMN = 106 |
| XML_WAR_ENTITY_REDEFINED = 107 |
| XML_ERR_UNKNOWN_VERSION = 108 |
| XML_ERR_VERSION_MISMATCH = 109 |
| XML_ERR_NAME_TOO_LONG = 110 |
| XML_ERR_USER_STOP = 111 |
| XML_NS_ERR_XML_NAMESPACE = 200 |
| XML_NS_ERR_UNDEFINED_NAMESPACE = 201 |
| XML_NS_ERR_QNAME = 202 |
| XML_NS_ERR_ATTRIBUTE_REDEFINED = 203 |
| XML_NS_ERR_EMPTY = 204 |
| XML_NS_ERR_COLON = 205 |
| XML_DTD_ATTRIBUTE_DEFAULT = 500 |
| XML_DTD_ATTRIBUTE_REDEFINED = 501 |
| XML_DTD_ATTRIBUTE_VALUE = 502 |
| XML_DTD_CONTENT_ERROR = 503 |
| XML_DTD_CONTENT_MODEL = 504 |
| XML_DTD_CONTENT_NOT_DETERMINIST = 505 |
| XML_DTD_DIFFERENT_PREFIX = 506 |
| XML_DTD_ELEM_DEFAULT_NAMESPACE = 507 |
| XML_DTD_ELEM_NAMESPACE = 508 |
| XML_DTD_ELEM_REDEFINED = 509 |
| XML_DTD_EMPTY_NOTATION = 510 |
| XML_DTD_ENTITY_TYPE = 511 |
| XML_DTD_ID_FIXED = 512 |
| XML_DTD_ID_REDEFINED = 513 |
| XML_DTD_ID_SUBSET = 514 |
| XML_DTD_INVALID_CHILD = 515 |
| XML_DTD_INVALID_DEFAULT = 516 |
| XML_DTD_LOAD_ERROR = 517 |
| XML_DTD_MISSING_ATTRIBUTE = 518 |
| XML_DTD_MIXED_CORRUPT = 519 |
| XML_DTD_MULTIPLE_ID = 520 |
| XML_DTD_NO_DOC = 521 |
| XML_DTD_NO_DTD = 522 |
| XML_DTD_NO_ELEM_NAME = 523 |
| XML_DTD_NO_PREFIX = 524 |
| XML_DTD_NO_ROOT = 525 |
| XML_DTD_NOTATION_REDEFINED = 526 |
| XML_DTD_NOTATION_VALUE = 527 |
| XML_DTD_NOT_EMPTY = 528 |
| XML_DTD_NOT_PCDATA = 529 |
| XML_DTD_NOT_STANDALONE = 530 |
| XML_DTD_ROOT_NAME = 531 |
| XML_DTD_STANDALONE_WHITE_SPACE = 532 |
| XML_DTD_UNKNOWN_ATTRIBUTE = 533 |
| XML_DTD_UNKNOWN_ELEM = 534 |
| XML_DTD_UNKNOWN_ENTITY = 535 |
| XML_DTD_UNKNOWN_ID = 536 |
| XML_DTD_UNKNOWN_NOTATION = 537 |
| XML_DTD_STANDALONE_DEFAULTED = 538 |
| XML_DTD_XMLID_VALUE = 539 |
| XML_DTD_XMLID_TYPE = 540 |
| XML_DTD_DUP_TOKEN = 541 |
| XML_HTML_STRUCURE_ERROR = 800 |
| XML_HTML_UNKNOWN_TAG = 801 |
| XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000 |
| XML_RNGP_ATTR_CONFLICT = 1001 |
| XML_RNGP_ATTRIBUTE_CHILDREN = 1002 |
| XML_RNGP_ATTRIBUTE_CONTENT = 1003 |
| XML_RNGP_ATTRIBUTE_EMPTY = 1004 |
| XML_RNGP_ATTRIBUTE_NOOP = 1005 |
| XML_RNGP_CHOICE_CONTENT = 1006 |
| XML_RNGP_CHOICE_EMPTY = 1007 |
| XML_RNGP_CREATE_FAILURE = 1008 |
| XML_RNGP_DATA_CONTENT = 1009 |
| XML_RNGP_DEF_CHOICE_AND_INTERLEAVE = 1010 |
| XML_RNGP_DEFINE_CREATE_FAILED = 1011 |
| XML_RNGP_DEFINE_EMPTY = 1012 |
| XML_RNGP_DEFINE_MISSING = 1013 |
| XML_RNGP_DEFINE_NAME_MISSING = 1014 |
| XML_RNGP_ELEM_CONTENT_EMPTY = 1015 |
| XML_RNGP_ELEM_CONTENT_ERROR = 1016 |
| XML_RNGP_ELEMENT_EMPTY = 1017 |
| XML_RNGP_ELEMENT_CONTENT = 1018 |
| XML_RNGP_ELEMENT_NAME = 1019 |
| XML_RNGP_ELEMENT_NO_CONTENT = 1020 |
| XML_RNGP_ELEM_TEXT_CONFLICT = 1021 |
| XML_RNGP_EMPTY = 1022 |
| XML_RNGP_EMPTY_CONSTRUCT = 1023 |
| XML_RNGP_EMPTY_CONTENT = 1024 |
| XML_RNGP_EMPTY_NOT_EMPTY = 1025 |
| XML_RNGP_ERROR_TYPE_LIB = 1026 |
| XML_RNGP_EXCEPT_EMPTY = 1027 |
| XML_RNGP_EXCEPT_MISSING = 1028 |
| XML_RNGP_EXCEPT_MULTIPLE = 1029 |
| XML_RNGP_EXCEPT_NO_CONTENT = 1030 |
| XML_RNGP_EXTERNALREF_EMTPY = 1031 |
| XML_RNGP_EXTERNAL_REF_FAILURE = 1032 |
| XML_RNGP_EXTERNALREF_RECURSE = 1033 |
| XML_RNGP_FORBIDDEN_ATTRIBUTE = 1034 |
| XML_RNGP_FOREIGN_ELEMENT = 1035 |
| XML_RNGP_GRAMMAR_CONTENT = 1036 |
| XML_RNGP_GRAMMAR_EMPTY = 1037 |
| XML_RNGP_GRAMMAR_MISSING = 1038 |
| XML_RNGP_GRAMMAR_NO_START = 1039 |
| XML_RNGP_GROUP_ATTR_CONFLICT = 1040 |
| XML_RNGP_HREF_ERROR = 1041 |
| XML_RNGP_INCLUDE_EMPTY = 1042 |
| XML_RNGP_INCLUDE_FAILURE = 1043 |
| XML_RNGP_INCLUDE_RECURSE = 1044 |
| XML_RNGP_INTERLEAVE_ADD = 1045 |
| XML_RNGP_INTERLEAVE_CREATE_FAILED = 1046 |
| XML_RNGP_INTERLEAVE_EMPTY = 1047 |
| XML_RNGP_INTERLEAVE_NO_CONTENT = 1048 |
| XML_RNGP_INVALID_DEFINE_NAME = 1049 |
| XML_RNGP_INVALID_URI = 1050 |
| XML_RNGP_INVALID_VALUE = 1051 |
| XML_RNGP_MISSING_HREF = 1052 |
| XML_RNGP_NAME_MISSING = 1053 |
| XML_RNGP_NEED_COMBINE = 1054 |
| XML_RNGP_NOTALLOWED_NOT_EMPTY = 1055 |
| XML_RNGP_NSNAME_ATTR_ANCESTOR = 1056 |
| XML_RNGP_NSNAME_NO_NS = 1057 |
| XML_RNGP_PARAM_FORBIDDEN = 1058 |
| XML_RNGP_PARAM_NAME_MISSING = 1059 |
| XML_RNGP_PARENTREF_CREATE_FAILED = 1060 |
| XML_RNGP_PARENTREF_NAME_INVALID = 1061 |
| XML_RNGP_PARENTREF_NO_NAME = 1062 |
| XML_RNGP_PARENTREF_NO_PARENT = 1063 |
| XML_RNGP_PARENTREF_NOT_EMPTY = 1064 |
| XML_RNGP_PARSE_ERROR = 1065 |
| XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME = 1066 |
| XML_RNGP_PAT_ATTR_ATTR = 1067 |
| XML_RNGP_PAT_ATTR_ELEM = 1068 |
| XML_RNGP_PAT_DATA_EXCEPT_ATTR = 1069 |
| XML_RNGP_PAT_DATA_EXCEPT_ELEM = 1070 |
| XML_RNGP_PAT_DATA_EXCEPT_EMPTY = 1071 |
| XML_RNGP_PAT_DATA_EXCEPT_GROUP = 1072 |
| XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE = 1073 |
| XML_RNGP_PAT_DATA_EXCEPT_LIST = 1074 |
| XML_RNGP_PAT_DATA_EXCEPT_ONEMORE = 1075 |
| XML_RNGP_PAT_DATA_EXCEPT_REF = 1076 |
| XML_RNGP_PAT_DATA_EXCEPT_TEXT = 1077 |
| XML_RNGP_PAT_LIST_ATTR = 1078 |
| XML_RNGP_PAT_LIST_ELEM = 1079 |
| XML_RNGP_PAT_LIST_INTERLEAVE = 1080 |
| XML_RNGP_PAT_LIST_LIST = 1081 |
| XML_RNGP_PAT_LIST_REF = 1082 |
| XML_RNGP_PAT_LIST_TEXT = 1083 |
| XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME = 1084 |
| XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME = 1085 |
| XML_RNGP_PAT_ONEMORE_GROUP_ATTR = 1086 |
| XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR = 1087 |
| XML_RNGP_PAT_START_ATTR = 1088 |
| XML_RNGP_PAT_START_DATA = 1089 |
| XML_RNGP_PAT_START_EMPTY = 1090 |
| XML_RNGP_PAT_START_GROUP = 1091 |
| XML_RNGP_PAT_START_INTERLEAVE = 1092 |
| XML_RNGP_PAT_START_LIST = 1093 |
| XML_RNGP_PAT_START_ONEMORE = 1094 |
| XML_RNGP_PAT_START_TEXT = 1095 |
| XML_RNGP_PAT_START_VALUE = 1096 |
| XML_RNGP_PREFIX_UNDEFINED = 1097 |
| XML_RNGP_REF_CREATE_FAILED = 1098 |
| XML_RNGP_REF_CYCLE = 1099 |
| XML_RNGP_REF_NAME_INVALID = 1100 |
| XML_RNGP_REF_NO_DEF = 1101 |
| XML_RNGP_REF_NO_NAME = 1102 |
| XML_RNGP_REF_NOT_EMPTY = 1103 |
| XML_RNGP_START_CHOICE_AND_INTERLEAVE = 1104 |
| XML_RNGP_START_CONTENT = 1105 |
| XML_RNGP_START_EMPTY = 1106 |
| XML_RNGP_START_MISSING = 1107 |
| XML_RNGP_TEXT_EXPECTED = 1108 |
| XML_RNGP_TEXT_HAS_CHILD = 1109 |
| XML_RNGP_TYPE_MISSING = 1110 |
| XML_RNGP_TYPE_NOT_FOUND = 1111 |
| XML_RNGP_TYPE_VALUE = 1112 |
| XML_RNGP_UNKNOWN_ATTRIBUTE = 1113 |
| XML_RNGP_UNKNOWN_COMBINE = 1114 |
| XML_RNGP_UNKNOWN_CONSTRUCT = 1115 |
| XML_RNGP_UNKNOWN_TYPE_LIB = 1116 |
| XML_RNGP_URI_FRAGMENT = 1117 |
| XML_RNGP_URI_NOT_ABSOLUTE = 1118 |
| XML_RNGP_VALUE_EMPTY = 1119 |
| XML_RNGP_VALUE_NO_CONTENT = 1120 |
| XML_RNGP_XMLNS_NAME = 1121 |
| XML_RNGP_XML_NS = 1122 |
| XML_XPATH_EXPRESSION_OK = 1200 |
| XML_XPATH_NUMBER_ERROR = 1201 |
| XML_XPATH_UNFINISHED_LITERAL_ERROR = 1202 |
| XML_XPATH_START_LITERAL_ERROR = 1203 |
| XML_XPATH_VARIABLE_REF_ERROR = 1204 |
| XML_XPATH_UNDEF_VARIABLE_ERROR = 1205 |
| XML_XPATH_INVALID_PREDICATE_ERROR = 1206 |
| XML_XPATH_EXPR_ERROR = 1207 |
| XML_XPATH_UNCLOSED_ERROR = 1208 |
| XML_XPATH_UNKNOWN_FUNC_ERROR = 1209 |
| XML_XPATH_INVALID_OPERAND = 1210 |
| XML_XPATH_INVALID_TYPE = 1211 |
| XML_XPATH_INVALID_ARITY = 1212 |
| XML_XPATH_INVALID_CTXT_SIZE = 1213 |
| XML_XPATH_INVALID_CTXT_POSITION = 1214 |
| XML_XPATH_MEMORY_ERROR = 1215 |
| XML_XPTR_SYNTAX_ERROR = 1216 |
| XML_XPTR_RESOURCE_ERROR = 1217 |
| XML_XPTR_SUB_RESOURCE_ERROR = 1218 |
| XML_XPATH_UNDEF_PREFIX_ERROR = 1219 |
| XML_XPATH_ENCODING_ERROR = 1220 |
| XML_XPATH_INVALID_CHAR_ERROR = 1221 |
| XML_TREE_INVALID_HEX = 1300 |
| XML_TREE_INVALID_DEC = 1301 |
| XML_TREE_UNTERMINATED_ENTITY = 1302 |
| XML_TREE_NOT_UTF8 = 1303 |
| XML_SAVE_NOT_UTF8 = 1400 |
| XML_SAVE_CHAR_INVALID = 1401 |
| XML_SAVE_NO_DOCTYPE = 1402 |
| XML_SAVE_UNKNOWN_ENCODING = 1403 |
| XML_REGEXP_COMPILE_ERROR = 1450 |
| XML_IO_UNKNOWN = 1500 |
| XML_IO_EACCES = 1501 |
| XML_IO_EAGAIN = 1502 |
| XML_IO_EBADF = 1503 |
| XML_IO_EBADMSG = 1504 |
| XML_IO_EBUSY = 1505 |
| XML_IO_ECANCELED = 1506 |
| XML_IO_ECHILD = 1507 |
| XML_IO_EDEADLK = 1508 |
| XML_IO_EDOM = 1509 |
| XML_IO_EEXIST = 1510 |
| XML_IO_EFAULT = 1511 |
| XML_IO_EFBIG = 1512 |
| XML_IO_EINPROGRESS = 1513 |
| XML_IO_EINTR = 1514 |
| XML_IO_EINVAL = 1515 |
| XML_IO_EIO = 1516 |
| XML_IO_EISDIR = 1517 |
| XML_IO_EMFILE = 1518 |
| XML_IO_EMLINK = 1519 |
| XML_IO_EMSGSIZE = 1520 |
| XML_IO_ENAMETOOLONG = 1521 |
| XML_IO_ENFILE = 1522 |
| XML_IO_ENODEV = 1523 |
| XML_IO_ENOENT = 1524 |
| XML_IO_ENOEXEC = 1525 |
| XML_IO_ENOLCK = 1526 |
| XML_IO_ENOMEM = 1527 |
| XML_IO_ENOSPC = 1528 |
| XML_IO_ENOSYS = 1529 |
| XML_IO_ENOTDIR = 1530 |
| XML_IO_ENOTEMPTY = 1531 |
| XML_IO_ENOTSUP = 1532 |
| XML_IO_ENOTTY = 1533 |
| XML_IO_ENXIO = 1534 |
| XML_IO_EPERM = 1535 |
| XML_IO_EPIPE = 1536 |
| XML_IO_ERANGE = 1537 |
| XML_IO_EROFS = 1538 |
| XML_IO_ESPIPE = 1539 |
| XML_IO_ESRCH = 1540 |
| XML_IO_ETIMEDOUT = 1541 |
| XML_IO_EXDEV = 1542 |
| XML_IO_NETWORK_ATTEMPT = 1543 |
| XML_IO_ENCODER = 1544 |
| XML_IO_FLUSH = 1545 |
| XML_IO_WRITE = 1546 |
| XML_IO_NO_INPUT = 1547 |
| XML_IO_BUFFER_FULL = 1548 |
| XML_IO_LOAD_ERROR = 1549 |
| XML_IO_ENOTSOCK = 1550 |
| XML_IO_EISCONN = 1551 |
| XML_IO_ECONNREFUSED = 1552 |
| XML_IO_ENETUNREACH = 1553 |
| XML_IO_EADDRINUSE = 1554 |
| XML_IO_EALREADY = 1555 |
| XML_IO_EAFNOSUPPORT = 1556 |
| XML_XINCLUDE_RECURSION = 1600 |
| XML_XINCLUDE_PARSE_VALUE = 1601 |
| XML_XINCLUDE_ENTITY_DEF_MISMATCH = 1602 |
| XML_XINCLUDE_NO_HREF = 1603 |
| XML_XINCLUDE_NO_FALLBACK = 1604 |
| XML_XINCLUDE_HREF_URI = 1605 |
| XML_XINCLUDE_TEXT_FRAGMENT = 1606 |
| XML_XINCLUDE_TEXT_DOCUMENT = 1607 |
| XML_XINCLUDE_INVALID_CHAR = 1608 |
| XML_XINCLUDE_BUILD_FAILED = 1609 |
| XML_XINCLUDE_UNKNOWN_ENCODING = 1610 |
| XML_XINCLUDE_MULTIPLE_ROOT = 1611 |
| XML_XINCLUDE_XPTR_FAILED = 1612 |
| XML_XINCLUDE_XPTR_RESULT = 1613 |
| XML_XINCLUDE_INCLUDE_IN_INCLUDE = 1614 |
| XML_XINCLUDE_FALLBACKS_IN_INCLUDE = 1615 |
| XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE = 1616 |
| XML_XINCLUDE_DEPRECATED_NS = 1617 |
| XML_XINCLUDE_FRAGMENT_ID = 1618 |
| XML_CATALOG_MISSING_ATTR = 1650 |
| XML_CATALOG_ENTRY_BROKEN = 1651 |
| XML_CATALOG_PREFER_VALUE = 1652 |
| XML_CATALOG_NOT_CATALOG = 1653 |
| XML_CATALOG_RECURSION = 1654 |
| XML_SCHEMAP_PREFIX_UNDEFINED = 1700 |
| XML_SCHEMAP_ATTRFORMDEFAULT_VALUE = 1701 |
| XML_SCHEMAP_ATTRGRP_NONAME_NOREF = 1702 |
| XML_SCHEMAP_ATTR_NONAME_NOREF = 1703 |
| XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF = 1704 |
| XML_SCHEMAP_ELEMFORMDEFAULT_VALUE = 1705 |
| XML_SCHEMAP_ELEM_NONAME_NOREF = 1706 |
| XML_SCHEMAP_EXTENSION_NO_BASE = 1707 |
| XML_SCHEMAP_FACET_NO_VALUE = 1708 |
| XML_SCHEMAP_FAILED_BUILD_IMPORT = 1709 |
| XML_SCHEMAP_GROUP_NONAME_NOREF = 1710 |
| XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI = 1711 |
| XML_SCHEMAP_IMPORT_REDEFINE_NSNAME = 1712 |
| XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI = 1713 |
| XML_SCHEMAP_INVALID_BOOLEAN = 1714 |
| XML_SCHEMAP_INVALID_ENUM = 1715 |
| XML_SCHEMAP_INVALID_FACET = 1716 |
| XML_SCHEMAP_INVALID_FACET_VALUE = 1717 |
| XML_SCHEMAP_INVALID_MAXOCCURS = 1718 |
| XML_SCHEMAP_INVALID_MINOCCURS = 1719 |
| XML_SCHEMAP_INVALID_REF_AND_SUBTYPE = 1720 |
| XML_SCHEMAP_INVALID_WHITE_SPACE = 1721 |
| XML_SCHEMAP_NOATTR_NOREF = 1722 |
| XML_SCHEMAP_NOTATION_NO_NAME = 1723 |
| XML_SCHEMAP_NOTYPE_NOREF = 1724 |
| XML_SCHEMAP_REF_AND_SUBTYPE = 1725 |
| XML_SCHEMAP_RESTRICTION_NONAME_NOREF = 1726 |
| XML_SCHEMAP_SIMPLETYPE_NONAME = 1727 |
| XML_SCHEMAP_TYPE_AND_SUBTYPE = 1728 |
| XML_SCHEMAP_UNKNOWN_ALL_CHILD = 1729 |
| XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD = 1730 |
| XML_SCHEMAP_UNKNOWN_ATTR_CHILD = 1731 |
| XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD = 1732 |
| XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP = 1733 |
| XML_SCHEMAP_UNKNOWN_BASE_TYPE = 1734 |
| XML_SCHEMAP_UNKNOWN_CHOICE_CHILD = 1735 |
| XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD = 1736 |
| XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD = 1737 |
| XML_SCHEMAP_UNKNOWN_ELEM_CHILD = 1738 |
| XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD = 1739 |
| XML_SCHEMAP_UNKNOWN_FACET_CHILD = 1740 |
| XML_SCHEMAP_UNKNOWN_FACET_TYPE = 1741 |
| XML_SCHEMAP_UNKNOWN_GROUP_CHILD = 1742 |
| XML_SCHEMAP_UNKNOWN_IMPORT_CHILD = 1743 |
| XML_SCHEMAP_UNKNOWN_LIST_CHILD = 1744 |
| XML_SCHEMAP_UNKNOWN_NOTATION_CHILD = 1745 |
| XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD = 1746 |
| XML_SCHEMAP_UNKNOWN_REF = 1747 |
| XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD = 1748 |
| XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD = 1749 |
| XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD = 1750 |
| XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD = 1751 |
| XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD = 1752 |
| XML_SCHEMAP_UNKNOWN_TYPE = 1753 |
| XML_SCHEMAP_UNKNOWN_UNION_CHILD = 1754 |
| XML_SCHEMAP_ELEM_DEFAULT_FIXED = 1755 |
| XML_SCHEMAP_REGEXP_INVALID = 1756 |
| XML_SCHEMAP_FAILED_LOAD = 1757 |
| XML_SCHEMAP_NOTHING_TO_PARSE = 1758 |
| XML_SCHEMAP_NOROOT = 1759 |
| XML_SCHEMAP_REDEFINED_GROUP = 1760 |
| XML_SCHEMAP_REDEFINED_TYPE = 1761 |
| XML_SCHEMAP_REDEFINED_ELEMENT = 1762 |
| XML_SCHEMAP_REDEFINED_ATTRGROUP = 1763 |
| XML_SCHEMAP_REDEFINED_ATTR = 1764 |
| XML_SCHEMAP_REDEFINED_NOTATION = 1765 |
| XML_SCHEMAP_FAILED_PARSE = 1766 |
| XML_SCHEMAP_UNKNOWN_PREFIX = 1767 |
| XML_SCHEMAP_DEF_AND_PREFIX = 1768 |
| XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD = 1769 |
| XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI = 1770 |
| XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI = 1771 |
| XML_SCHEMAP_NOT_SCHEMA = 1772 |
| XML_SCHEMAP_UNKNOWN_MEMBER_TYPE = 1773 |
| XML_SCHEMAP_INVALID_ATTR_USE = 1774 |
| XML_SCHEMAP_RECURSIVE = 1775 |
| XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE = 1776 |
| XML_SCHEMAP_INVALID_ATTR_COMBINATION = 1777 |
| XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION = 1778 |
| XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD = 1779 |
| XML_SCHEMAP_INVALID_ATTR_NAME = 1780 |
| XML_SCHEMAP_REF_AND_CONTENT = 1781 |
| XML_SCHEMAP_CT_PROPS_CORRECT_1 = 1782 |
| XML_SCHEMAP_CT_PROPS_CORRECT_2 = 1783 |
| XML_SCHEMAP_CT_PROPS_CORRECT_3 = 1784 |
| XML_SCHEMAP_CT_PROPS_CORRECT_4 = 1785 |
| XML_SCHEMAP_CT_PROPS_CORRECT_5 = 1786 |
| XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1 = 1787 |
| XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1 = 1788 |
| XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2 = 1789 |
| XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2 = 1790 |
| XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3 = 1791 |
| XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER = 1792 |
| XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE = 1793 |
| XML_SCHEMAP_UNION_NOT_EXPRESSIBLE = 1794 |
| XML_SCHEMAP_SRC_IMPORT_3_1 = 1795 |
| XML_SCHEMAP_SRC_IMPORT_3_2 = 1796 |
| XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1 = 1797 |
| XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2 = 1798 |
| XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3 = 1799 |
| XML_SCHEMAP_COS_CT_EXTENDS_1_3 = 1800 |
| XML_SCHEMAV_NOROOT = 1801 |
| XML_SCHEMAV_UNDECLAREDELEM = 1802 |
| XML_SCHEMAV_NOTTOPLEVEL = 1803 |
| XML_SCHEMAV_MISSING = 1804 |
| XML_SCHEMAV_WRONGELEM = 1805 |
| XML_SCHEMAV_NOTYPE = 1806 |
| XML_SCHEMAV_NOROLLBACK = 1807 |
| XML_SCHEMAV_ISABSTRACT = 1808 |
| XML_SCHEMAV_NOTEMPTY = 1809 |
| XML_SCHEMAV_ELEMCONT = 1810 |
| XML_SCHEMAV_HAVEDEFAULT = 1811 |
| XML_SCHEMAV_NOTNILLABLE = 1812 |
| XML_SCHEMAV_EXTRACONTENT = 1813 |
| XML_SCHEMAV_INVALIDATTR = 1814 |
| XML_SCHEMAV_INVALIDELEM = 1815 |
| XML_SCHEMAV_NOTDETERMINIST = 1816 |
| XML_SCHEMAV_CONSTRUCT = 1817 |
| XML_SCHEMAV_INTERNAL = 1818 |
| XML_SCHEMAV_NOTSIMPLE = 1819 |
| XML_SCHEMAV_ATTRUNKNOWN = 1820 |
| XML_SCHEMAV_ATTRINVALID = 1821 |
| XML_SCHEMAV_VALUE = 1822 |
| XML_SCHEMAV_FACET = 1823 |
| XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1 = 1824 |
| XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2 = 1825 |
| XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3 = 1826 |
| XML_SCHEMAV_CVC_TYPE_3_1_1 = 1827 |
| XML_SCHEMAV_CVC_TYPE_3_1_2 = 1828 |
| XML_SCHEMAV_CVC_FACET_VALID = 1829 |
| XML_SCHEMAV_CVC_LENGTH_VALID = 1830 |
| XML_SCHEMAV_CVC_MINLENGTH_VALID = 1831 |
| XML_SCHEMAV_CVC_MAXLENGTH_VALID = 1832 |
| XML_SCHEMAV_CVC_MININCLUSIVE_VALID = 1833 |
| XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID = 1834 |
| XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID = 1835 |
| XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID = 1836 |
| XML_SCHEMAV_CVC_TOTALDIGITS_VALID = 1837 |
| XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID = 1838 |
| XML_SCHEMAV_CVC_PATTERN_VALID = 1839 |
| XML_SCHEMAV_CVC_ENUMERATION_VALID = 1840 |
| XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1 = 1841 |
| XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2 = 1842 |
| XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3 = 1843 |
| XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4 = 1844 |
| XML_SCHEMAV_CVC_ELT_1 = 1845 |
| XML_SCHEMAV_CVC_ELT_2 = 1846 |
| XML_SCHEMAV_CVC_ELT_3_1 = 1847 |
| XML_SCHEMAV_CVC_ELT_3_2_1 = 1848 |
| XML_SCHEMAV_CVC_ELT_3_2_2 = 1849 |
| XML_SCHEMAV_CVC_ELT_4_1 = 1850 |
| XML_SCHEMAV_CVC_ELT_4_2 = 1851 |
| XML_SCHEMAV_CVC_ELT_4_3 = 1852 |
| XML_SCHEMAV_CVC_ELT_5_1_1 = 1853 |
| XML_SCHEMAV_CVC_ELT_5_1_2 = 1854 |
| XML_SCHEMAV_CVC_ELT_5_2_1 = 1855 |
| XML_SCHEMAV_CVC_ELT_5_2_2_1 = 1856 |
| XML_SCHEMAV_CVC_ELT_5_2_2_2_1 = 1857 |
| XML_SCHEMAV_CVC_ELT_5_2_2_2_2 = 1858 |
| XML_SCHEMAV_CVC_ELT_6 = 1859 |
| XML_SCHEMAV_CVC_ELT_7 = 1860 |
| XML_SCHEMAV_CVC_ATTRIBUTE_1 = 1861 |
| XML_SCHEMAV_CVC_ATTRIBUTE_2 = 1862 |
| XML_SCHEMAV_CVC_ATTRIBUTE_3 = 1863 |
| XML_SCHEMAV_CVC_ATTRIBUTE_4 = 1864 |
| XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1 = 1865 |
| XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1 = 1866 |
| XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2 = 1867 |
| XML_SCHEMAV_CVC_COMPLEX_TYPE_4 = 1868 |
| XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1 = 1869 |
| XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2 = 1870 |
| XML_SCHEMAV_ELEMENT_CONTENT = 1871 |
| XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING = 1872 |
| XML_SCHEMAV_CVC_COMPLEX_TYPE_1 = 1873 |
| XML_SCHEMAV_CVC_AU = 1874 |
| XML_SCHEMAV_CVC_TYPE_1 = 1875 |
| XML_SCHEMAV_CVC_TYPE_2 = 1876 |
| XML_SCHEMAV_CVC_IDC = 1877 |
| XML_SCHEMAV_CVC_WILDCARD = 1878 |
| XML_SCHEMAV_MISC = 1879 |
| XML_XPTR_UNKNOWN_SCHEME = 1900 |
| XML_XPTR_CHILDSEQ_START = 1901 |
| XML_XPTR_EVAL_FAILED = 1902 |
| XML_XPTR_EXTRA_OBJECTS = 1903 |
| XML_C14N_CREATE_CTXT = 1950 |
| XML_C14N_REQUIRES_UTF8 = 1951 |
| XML_C14N_CREATE_STACK = 1952 |
| XML_C14N_INVALID_NODE = 1953 |
| XML_C14N_UNKNOW_NODE = 1954 |
| XML_C14N_RELATIVE_NAMESPACE = 1955 |
| XML_FTP_PASV_ANSWER = 2000 |
| XML_FTP_EPSV_ANSWER = 2001 |
| XML_FTP_ACCNT = 2002 |
| XML_FTP_URL_SYNTAX = 2003 |
| XML_HTTP_URL_SYNTAX = 2020 |
| XML_HTTP_USE_IP = 2021 |
| XML_HTTP_UNKNOWN_HOST = 2022 |
| XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000 |
| XML_SCHEMAP_SRC_SIMPLE_TYPE_2 = 3001 |
| XML_SCHEMAP_SRC_SIMPLE_TYPE_3 = 3002 |
| XML_SCHEMAP_SRC_SIMPLE_TYPE_4 = 3003 |
| XML_SCHEMAP_SRC_RESOLVE = 3004 |
| XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE = 3005 |
| XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE = 3006 |
| XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES = 3007 |
| XML_SCHEMAP_ST_PROPS_CORRECT_1 = 3008 |
| XML_SCHEMAP_ST_PROPS_CORRECT_2 = 3009 |
| XML_SCHEMAP_ST_PROPS_CORRECT_3 = 3010 |
| XML_SCHEMAP_COS_ST_RESTRICTS_1_1 = 3011 |
| XML_SCHEMAP_COS_ST_RESTRICTS_1_2 = 3012 |
| XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1 = 3013 |
| XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2 = 3014 |
| XML_SCHEMAP_COS_ST_RESTRICTS_2_1 = 3015 |
| XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1 = 3016 |
| XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2 = 3017 |
| XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1 = 3018 |
| XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2 = 3019 |
| XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3 = 3020 |
| XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4 = 3021 |
| XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5 = 3022 |
| XML_SCHEMAP_COS_ST_RESTRICTS_3_1 = 3023 |
| XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1 = 3024 |
| XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2 = 3025 |
| XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2 = 3026 |
| XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1 = 3027 |
| XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3 = 3028 |
| XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4 = 3029 |
| XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5 = 3030 |
| XML_SCHEMAP_COS_ST_DERIVED_OK_2_1 = 3031 |
| XML_SCHEMAP_COS_ST_DERIVED_OK_2_2 = 3032 |
| XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED = 3033 |
| XML_SCHEMAP_S4S_ELEM_MISSING = 3034 |
| XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED = 3035 |
| XML_SCHEMAP_S4S_ATTR_MISSING = 3036 |
| XML_SCHEMAP_S4S_ATTR_INVALID_VALUE = 3037 |
| XML_SCHEMAP_SRC_ELEMENT_1 = 3038 |
| XML_SCHEMAP_SRC_ELEMENT_2_1 = 3039 |
| XML_SCHEMAP_SRC_ELEMENT_2_2 = 3040 |
| XML_SCHEMAP_SRC_ELEMENT_3 = 3041 |
| XML_SCHEMAP_P_PROPS_CORRECT_1 = 3042 |
| XML_SCHEMAP_P_PROPS_CORRECT_2_1 = 3043 |
| XML_SCHEMAP_P_PROPS_CORRECT_2_2 = 3044 |
| XML_SCHEMAP_E_PROPS_CORRECT_2 = 3045 |
| XML_SCHEMAP_E_PROPS_CORRECT_3 = 3046 |
| XML_SCHEMAP_E_PROPS_CORRECT_4 = 3047 |
| XML_SCHEMAP_E_PROPS_CORRECT_5 = 3048 |
| XML_SCHEMAP_E_PROPS_CORRECT_6 = 3049 |
| XML_SCHEMAP_SRC_INCLUDE = 3050 |
| XML_SCHEMAP_SRC_ATTRIBUTE_1 = 3051 |
| XML_SCHEMAP_SRC_ATTRIBUTE_2 = 3052 |
| XML_SCHEMAP_SRC_ATTRIBUTE_3_1 = 3053 |
| XML_SCHEMAP_SRC_ATTRIBUTE_3_2 = 3054 |
| XML_SCHEMAP_SRC_ATTRIBUTE_4 = 3055 |
| XML_SCHEMAP_NO_XMLNS = 3056 |
| XML_SCHEMAP_NO_XSI = 3057 |
| XML_SCHEMAP_COS_VALID_DEFAULT_1 = 3058 |
| XML_SCHEMAP_COS_VALID_DEFAULT_2_1 = 3059 |
| XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1 = 3060 |
| XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2 = 3061 |
| XML_SCHEMAP_CVC_SIMPLE_TYPE = 3062 |
| XML_SCHEMAP_COS_CT_EXTENDS_1_1 = 3063 |
| XML_SCHEMAP_SRC_IMPORT_1_1 = 3064 |
| XML_SCHEMAP_SRC_IMPORT_1_2 = 3065 |
| XML_SCHEMAP_SRC_IMPORT_2 = 3066 |
| XML_SCHEMAP_SRC_IMPORT_2_1 = 3067 |
| XML_SCHEMAP_SRC_IMPORT_2_2 = 3068 |
| XML_SCHEMAP_INTERNAL = 3069 |
| XML_SCHEMAP_NOT_DETERMINISTIC = 3070 |
| XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1 = 3071 |
| XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2 = 3072 |
| XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3 = 3073 |
| XML_SCHEMAP_MG_PROPS_CORRECT_1 = 3074 |
| XML_SCHEMAP_MG_PROPS_CORRECT_2 = 3075 |
| XML_SCHEMAP_SRC_CT_1 = 3076 |
| XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3 = 3077 |
| XML_SCHEMAP_AU_PROPS_CORRECT_2 = 3078 |
| XML_SCHEMAP_A_PROPS_CORRECT_2 = 3079 |
| XML_SCHEMAP_C_PROPS_CORRECT = 3080 |
| XML_SCHEMAP_SRC_REDEFINE = 3081 |
| XML_SCHEMAP_SRC_IMPORT = 3082 |
| XML_SCHEMAP_WARN_SKIP_SCHEMA = 3083 |
| XML_SCHEMAP_WARN_UNLOCATED_SCHEMA = 3084 |
| XML_SCHEMAP_WARN_ATTR_REDECL_PROH = 3085 |
| XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH = 3086 |
| XML_SCHEMAP_AG_PROPS_CORRECT = 3087 |
| XML_SCHEMAP_COS_CT_EXTENDS_1_2 = 3088 |
| XML_SCHEMAP_AU_PROPS_CORRECT = 3089 |
| XML_SCHEMAP_A_PROPS_CORRECT_3 = 3090 |
| XML_SCHEMAP_COS_ALL_LIMITED = 3091 |
| XML_SCHEMATRONV_ASSERT = 4000 |
| XML_SCHEMATRONV_REPORT = 4001 |
| XML_MODULE_OPEN = 4900 |
| XML_MODULE_CLOSE = 4901 |
| XML_CHECK_FOUND_ELEMENT = 5000 |
| XML_CHECK_FOUND_ATTRIBUTE = 5001 |
| XML_CHECK_FOUND_TEXT = 5002 |
| XML_CHECK_FOUND_CDATA = 5003 |
| XML_CHECK_FOUND_ENTITYREF = 5004 |
| XML_CHECK_FOUND_ENTITY = 5005 |
| XML_CHECK_FOUND_PI = 5006 |
| XML_CHECK_FOUND_COMMENT = 5007 |
| XML_CHECK_FOUND_DOCTYPE = 5008 |
| XML_CHECK_FOUND_FRAGMENT = 5009 |
| XML_CHECK_FOUND_NOTATION = 5010 |
| XML_CHECK_UNKNOWN_NODE = 5011 |
| XML_CHECK_ENTITY_TYPE = 5012 |
| XML_CHECK_NO_PARENT = 5013 |
| XML_CHECK_NO_DOC = 5014 |
| XML_CHECK_NO_NAME = 5015 |
| XML_CHECK_NO_ELEM = 5016 |
| XML_CHECK_WRONG_DOC = 5017 |
| XML_CHECK_NO_PREV = 5018 |
| XML_CHECK_WRONG_PREV = 5019 |
| XML_CHECK_NO_NEXT = 5020 |
| XML_CHECK_WRONG_NEXT = 5021 |
| XML_CHECK_NOT_DTD = 5022 |
| XML_CHECK_NOT_ATTR = 5023 |
| XML_CHECK_NOT_ATTR_DECL = 5024 |
| XML_CHECK_NOT_ELEM_DECL = 5025 |
| XML_CHECK_NOT_ENTITY_DECL = 5026 |
| XML_CHECK_NOT_NS_DECL = 5027 |
| XML_CHECK_NO_HREF = 5028 |
| XML_CHECK_WRONG_PARENT = 5029 |
| XML_CHECK_NS_SCOPE = 5030 |
| XML_CHECK_NS_ANCESTOR = 5031 |
| XML_CHECK_NOT_UTF8 = 5032 |
| XML_CHECK_NO_DICT = 5033 |
| XML_CHECK_NOT_NCNAME = 5034 |
| XML_CHECK_OUTSIDE_DICT = 5035 |
| XML_CHECK_WRONG_NAME = 5036 |
| XML_CHECK_NAME_NOT_NULL = 5037 |
| XML_I18N_NO_NAME = 6000 |
| XML_I18N_NO_HANDLER = 6001 |
| XML_I18N_EXCESS_HANDLER = 6002 |
| XML_I18N_CONV_FAILED = 6003 |
| XML_I18N_NO_OUTPUT = 6004 |
| XML_BUF_OVERFLOW = 7000 |
| |
| # xmlExpNodeType |
| XML_EXP_EMPTY = 0 |
| XML_EXP_FORBID = 1 |
| XML_EXP_ATOM = 2 |
| XML_EXP_SEQ = 3 |
| XML_EXP_OR = 4 |
| XML_EXP_COUNT = 5 |
| |
| # xmlElementContentType |
| XML_ELEMENT_CONTENT_PCDATA = 1 |
| XML_ELEMENT_CONTENT_ELEMENT = 2 |
| XML_ELEMENT_CONTENT_SEQ = 3 |
| XML_ELEMENT_CONTENT_OR = 4 |
| |
| # xmlParserProperties |
| XML_PARSER_LOADDTD = 1 |
| XML_PARSER_DEFAULTATTRS = 2 |
| XML_PARSER_VALIDATE = 3 |
| XML_PARSER_SUBST_ENTITIES = 4 |
| |
| # xmlReaderTypes |
| XML_READER_TYPE_NONE = 0 |
| XML_READER_TYPE_ELEMENT = 1 |
| XML_READER_TYPE_ATTRIBUTE = 2 |
| XML_READER_TYPE_TEXT = 3 |
| XML_READER_TYPE_CDATA = 4 |
| XML_READER_TYPE_ENTITY_REFERENCE = 5 |
| XML_READER_TYPE_ENTITY = 6 |
| XML_READER_TYPE_PROCESSING_INSTRUCTION = 7 |
| XML_READER_TYPE_COMMENT = 8 |
| XML_READER_TYPE_DOCUMENT = 9 |
| XML_READER_TYPE_DOCUMENT_TYPE = 10 |
| XML_READER_TYPE_DOCUMENT_FRAGMENT = 11 |
| XML_READER_TYPE_NOTATION = 12 |
| XML_READER_TYPE_WHITESPACE = 13 |
| XML_READER_TYPE_SIGNIFICANT_WHITESPACE = 14 |
| XML_READER_TYPE_END_ELEMENT = 15 |
| XML_READER_TYPE_END_ENTITY = 16 |
| XML_READER_TYPE_XML_DECLARATION = 17 |
| |
| # xmlCatalogPrefer |
| XML_CATA_PREFER_NONE = 0 |
| XML_CATA_PREFER_PUBLIC = 1 |
| XML_CATA_PREFER_SYSTEM = 2 |
| |
| # xmlElementType |
| XML_ELEMENT_NODE = 1 |
| XML_ATTRIBUTE_NODE = 2 |
| XML_TEXT_NODE = 3 |
| XML_CDATA_SECTION_NODE = 4 |
| XML_ENTITY_REF_NODE = 5 |
| XML_ENTITY_NODE = 6 |
| XML_PI_NODE = 7 |
| XML_COMMENT_NODE = 8 |
| XML_DOCUMENT_NODE = 9 |
| XML_DOCUMENT_TYPE_NODE = 10 |
| XML_DOCUMENT_FRAG_NODE = 11 |
| XML_NOTATION_NODE = 12 |
| XML_HTML_DOCUMENT_NODE = 13 |
| XML_DTD_NODE = 14 |
| XML_ELEMENT_DECL = 15 |
| XML_ATTRIBUTE_DECL = 16 |
| XML_ENTITY_DECL = 17 |
| XML_NAMESPACE_DECL = 18 |
| XML_XINCLUDE_START = 19 |
| XML_XINCLUDE_END = 20 |
| XML_DOCB_DOCUMENT_NODE = 21 |
| |
| # xlinkActuate |
| XLINK_ACTUATE_NONE = 0 |
| XLINK_ACTUATE_AUTO = 1 |
| XLINK_ACTUATE_ONREQUEST = 2 |
| |
| # xmlFeature |
| XML_WITH_THREAD = 1 |
| XML_WITH_TREE = 2 |
| XML_WITH_OUTPUT = 3 |
| XML_WITH_PUSH = 4 |
| XML_WITH_READER = 5 |
| XML_WITH_PATTERN = 6 |
| XML_WITH_WRITER = 7 |
| XML_WITH_SAX1 = 8 |
| XML_WITH_FTP = 9 |
| XML_WITH_HTTP = 10 |
| XML_WITH_VALID = 11 |
| XML_WITH_HTML = 12 |
| XML_WITH_LEGACY = 13 |
| XML_WITH_C14N = 14 |
| XML_WITH_CATALOG = 15 |
| XML_WITH_XPATH = 16 |
| XML_WITH_XPTR = 17 |
| XML_WITH_XINCLUDE = 18 |
| XML_WITH_ICONV = 19 |
| XML_WITH_ISO8859X = 20 |
| XML_WITH_UNICODE = 21 |
| XML_WITH_REGEXP = 22 |
| XML_WITH_AUTOMATA = 23 |
| XML_WITH_EXPR = 24 |
| XML_WITH_SCHEMAS = 25 |
| XML_WITH_SCHEMATRON = 26 |
| XML_WITH_MODULES = 27 |
| XML_WITH_DEBUG = 28 |
| XML_WITH_DEBUG_MEM = 29 |
| XML_WITH_DEBUG_RUN = 30 |
| XML_WITH_ZLIB = 31 |
| XML_WITH_ICU = 32 |
| XML_WITH_LZMA = 33 |
| XML_WITH_NONE = 99999 |
| |
| # xmlElementContentOccur |
| XML_ELEMENT_CONTENT_ONCE = 1 |
| XML_ELEMENT_CONTENT_OPT = 2 |
| XML_ELEMENT_CONTENT_MULT = 3 |
| XML_ELEMENT_CONTENT_PLUS = 4 |
| |
| # xmlXPathError |
| XPATH_EXPRESSION_OK = 0 |
| XPATH_NUMBER_ERROR = 1 |
| XPATH_UNFINISHED_LITERAL_ERROR = 2 |
| XPATH_START_LITERAL_ERROR = 3 |
| XPATH_VARIABLE_REF_ERROR = 4 |
| XPATH_UNDEF_VARIABLE_ERROR = 5 |
| XPATH_INVALID_PREDICATE_ERROR = 6 |
| XPATH_EXPR_ERROR = 7 |
| XPATH_UNCLOSED_ERROR = 8 |
| XPATH_UNKNOWN_FUNC_ERROR = 9 |
| XPATH_INVALID_OPERAND = 10 |
| XPATH_INVALID_TYPE = 11 |
| XPATH_INVALID_ARITY = 12 |
| XPATH_INVALID_CTXT_SIZE = 13 |
| XPATH_INVALID_CTXT_POSITION = 14 |
| XPATH_MEMORY_ERROR = 15 |
| XPTR_SYNTAX_ERROR = 16 |
| XPTR_RESOURCE_ERROR = 17 |
| XPTR_SUB_RESOURCE_ERROR = 18 |
| XPATH_UNDEF_PREFIX_ERROR = 19 |
| XPATH_ENCODING_ERROR = 20 |
| XPATH_INVALID_CHAR_ERROR = 21 |
| XPATH_INVALID_CTXT = 22 |
| XPATH_STACK_ERROR = 23 |
| XPATH_FORBID_VARIABLE_ERROR = 24 |
| |
| # xmlTextReaderMode |
| XML_TEXTREADER_MODE_INITIAL = 0 |
| XML_TEXTREADER_MODE_INTERACTIVE = 1 |
| XML_TEXTREADER_MODE_ERROR = 2 |
| XML_TEXTREADER_MODE_EOF = 3 |
| XML_TEXTREADER_MODE_CLOSED = 4 |
| XML_TEXTREADER_MODE_READING = 5 |
| |
| # xmlErrorLevel |
| XML_ERR_NONE = 0 |
| XML_ERR_WARNING = 1 |
| XML_ERR_ERROR = 2 |
| XML_ERR_FATAL = 3 |
| |
| # xmlCharEncoding |
| XML_CHAR_ENCODING_ERROR = -1 |
| XML_CHAR_ENCODING_NONE = 0 |
| XML_CHAR_ENCODING_UTF8 = 1 |
| XML_CHAR_ENCODING_UTF16LE = 2 |
| XML_CHAR_ENCODING_UTF16BE = 3 |
| XML_CHAR_ENCODING_UCS4LE = 4 |
| XML_CHAR_ENCODING_UCS4BE = 5 |
| XML_CHAR_ENCODING_EBCDIC = 6 |
| XML_CHAR_ENCODING_UCS4_2143 = 7 |
| XML_CHAR_ENCODING_UCS4_3412 = 8 |
| XML_CHAR_ENCODING_UCS2 = 9 |
| XML_CHAR_ENCODING_8859_1 = 10 |
| XML_CHAR_ENCODING_8859_2 = 11 |
| XML_CHAR_ENCODING_8859_3 = 12 |
| XML_CHAR_ENCODING_8859_4 = 13 |
| XML_CHAR_ENCODING_8859_5 = 14 |
| XML_CHAR_ENCODING_8859_6 = 15 |
| XML_CHAR_ENCODING_8859_7 = 16 |
| XML_CHAR_ENCODING_8859_8 = 17 |
| XML_CHAR_ENCODING_8859_9 = 18 |
| XML_CHAR_ENCODING_2022_JP = 19 |
| XML_CHAR_ENCODING_SHIFT_JIS = 20 |
| XML_CHAR_ENCODING_EUC_JP = 21 |
| XML_CHAR_ENCODING_ASCII = 22 |
| |
| # xmlErrorDomain |
| XML_FROM_NONE = 0 |
| XML_FROM_PARSER = 1 |
| XML_FROM_TREE = 2 |
| XML_FROM_NAMESPACE = 3 |
| XML_FROM_DTD = 4 |
| XML_FROM_HTML = 5 |
| XML_FROM_MEMORY = 6 |
| XML_FROM_OUTPUT = 7 |
| XML_FROM_IO = 8 |
| XML_FROM_FTP = 9 |
| XML_FROM_HTTP = 10 |
| XML_FROM_XINCLUDE = 11 |
| XML_FROM_XPATH = 12 |
| XML_FROM_XPOINTER = 13 |
| XML_FROM_REGEXP = 14 |
| XML_FROM_DATATYPE = 15 |
| XML_FROM_SCHEMASP = 16 |
| XML_FROM_SCHEMASV = 17 |
| XML_FROM_RELAXNGP = 18 |
| XML_FROM_RELAXNGV = 19 |
| XML_FROM_CATALOG = 20 |
| XML_FROM_C14N = 21 |
| XML_FROM_XSLT = 22 |
| XML_FROM_VALID = 23 |
| XML_FROM_CHECK = 24 |
| XML_FROM_WRITER = 25 |
| XML_FROM_MODULE = 26 |
| XML_FROM_I18N = 27 |
| XML_FROM_SCHEMATRONV = 28 |
| XML_FROM_BUFFER = 29 |
| XML_FROM_URI = 30 |
| |
| # htmlStatus |
| HTML_NA = 0 |
| HTML_INVALID = 1 |
| HTML_DEPRECATED = 2 |
| HTML_VALID = 4 |
| HTML_REQUIRED = 12 |
| |
| # xmlSchemaValidOption |
| XML_SCHEMA_VAL_VC_I_CREATE = 1 |
| |
| # xmlSchemaWhitespaceValueType |
| XML_SCHEMA_WHITESPACE_UNKNOWN = 0 |
| XML_SCHEMA_WHITESPACE_PRESERVE = 1 |
| XML_SCHEMA_WHITESPACE_REPLACE = 2 |
| XML_SCHEMA_WHITESPACE_COLLAPSE = 3 |
| |
| # htmlParserOption |
| HTML_PARSE_RECOVER = 1 |
| HTML_PARSE_NODEFDTD = 4 |
| HTML_PARSE_NOERROR = 32 |
| HTML_PARSE_NOWARNING = 64 |
| HTML_PARSE_PEDANTIC = 128 |
| HTML_PARSE_NOBLANKS = 256 |
| HTML_PARSE_NONET = 2048 |
| HTML_PARSE_NOIMPLIED = 8192 |
| HTML_PARSE_COMPACT = 65536 |
| HTML_PARSE_IGNORE_ENC = 2097152 |
| |
| # xmlRelaxNGValidErr |
| XML_RELAXNG_OK = 0 |
| XML_RELAXNG_ERR_MEMORY = 1 |
| XML_RELAXNG_ERR_TYPE = 2 |
| XML_RELAXNG_ERR_TYPEVAL = 3 |
| XML_RELAXNG_ERR_DUPID = 4 |
| XML_RELAXNG_ERR_TYPECMP = 5 |
| XML_RELAXNG_ERR_NOSTATE = 6 |
| XML_RELAXNG_ERR_NODEFINE = 7 |
| XML_RELAXNG_ERR_LISTEXTRA = 8 |
| XML_RELAXNG_ERR_LISTEMPTY = 9 |
| XML_RELAXNG_ERR_INTERNODATA = 10 |
| XML_RELAXNG_ERR_INTERSEQ = 11 |
| XML_RELAXNG_ERR_INTEREXTRA = 12 |
| XML_RELAXNG_ERR_ELEMNAME = 13 |
| XML_RELAXNG_ERR_ATTRNAME = 14 |
| XML_RELAXNG_ERR_ELEMNONS = 15 |
| XML_RELAXNG_ERR_ATTRNONS = 16 |
| XML_RELAXNG_ERR_ELEMWRONGNS = 17 |
| XML_RELAXNG_ERR_ATTRWRONGNS = 18 |
| XML_RELAXNG_ERR_ELEMEXTRANS = 19 |
| XML_RELAXNG_ERR_ATTREXTRANS = 20 |
| XML_RELAXNG_ERR_ELEMNOTEMPTY = 21 |
| XML_RELAXNG_ERR_NOELEM = 22 |
| XML_RELAXNG_ERR_NOTELEM = 23 |
| XML_RELAXNG_ERR_ATTRVALID = 24 |
| XML_RELAXNG_ERR_CONTENTVALID = 25 |
| XML_RELAXNG_ERR_EXTRACONTENT = 26 |
| XML_RELAXNG_ERR_INVALIDATTR = 27 |
| XML_RELAXNG_ERR_DATAELEM = 28 |
| XML_RELAXNG_ERR_VALELEM = 29 |
| XML_RELAXNG_ERR_LISTELEM = 30 |
| XML_RELAXNG_ERR_DATATYPE = 31 |
| XML_RELAXNG_ERR_VALUE = 32 |
| XML_RELAXNG_ERR_LIST = 33 |
| XML_RELAXNG_ERR_NOGRAMMAR = 34 |
| XML_RELAXNG_ERR_EXTRADATA = 35 |
| XML_RELAXNG_ERR_LACKDATA = 36 |
| XML_RELAXNG_ERR_INTERNAL = 37 |
| XML_RELAXNG_ERR_ELEMWRONG = 38 |
| XML_RELAXNG_ERR_TEXTWRONG = 39 |
| |
| # xmlCatalogAllow |
| XML_CATA_ALLOW_NONE = 0 |
| XML_CATA_ALLOW_GLOBAL = 1 |
| XML_CATA_ALLOW_DOCUMENT = 2 |
| XML_CATA_ALLOW_ALL = 3 |
| |
| # xmlAttributeType |
| XML_ATTRIBUTE_CDATA = 1 |
| XML_ATTRIBUTE_ID = 2 |
| XML_ATTRIBUTE_IDREF = 3 |
| XML_ATTRIBUTE_IDREFS = 4 |
| XML_ATTRIBUTE_ENTITY = 5 |
| XML_ATTRIBUTE_ENTITIES = 6 |
| XML_ATTRIBUTE_NMTOKEN = 7 |
| XML_ATTRIBUTE_NMTOKENS = 8 |
| XML_ATTRIBUTE_ENUMERATION = 9 |
| XML_ATTRIBUTE_NOTATION = 10 |
| |
| # xmlSchematronValidOptions |
| XML_SCHEMATRON_OUT_QUIET = 1 |
| XML_SCHEMATRON_OUT_TEXT = 2 |
| XML_SCHEMATRON_OUT_XML = 4 |
| XML_SCHEMATRON_OUT_ERROR = 8 |
| XML_SCHEMATRON_OUT_FILE = 256 |
| XML_SCHEMATRON_OUT_BUFFER = 512 |
| XML_SCHEMATRON_OUT_IO = 1024 |
| |
| # xmlSchemaContentType |
| XML_SCHEMA_CONTENT_UNKNOWN = 0 |
| XML_SCHEMA_CONTENT_EMPTY = 1 |
| XML_SCHEMA_CONTENT_ELEMENTS = 2 |
| XML_SCHEMA_CONTENT_MIXED = 3 |
| XML_SCHEMA_CONTENT_SIMPLE = 4 |
| XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS = 5 |
| XML_SCHEMA_CONTENT_BASIC = 6 |
| XML_SCHEMA_CONTENT_ANY = 7 |
| |
| # xmlSchemaTypeType |
| XML_SCHEMA_TYPE_BASIC = 1 |
| XML_SCHEMA_TYPE_ANY = 2 |
| XML_SCHEMA_TYPE_FACET = 3 |
| XML_SCHEMA_TYPE_SIMPLE = 4 |
| XML_SCHEMA_TYPE_COMPLEX = 5 |
| XML_SCHEMA_TYPE_SEQUENCE = 6 |
| XML_SCHEMA_TYPE_CHOICE = 7 |
| XML_SCHEMA_TYPE_ALL = 8 |
| XML_SCHEMA_TYPE_SIMPLE_CONTENT = 9 |
| XML_SCHEMA_TYPE_COMPLEX_CONTENT = 10 |
| XML_SCHEMA_TYPE_UR = 11 |
| XML_SCHEMA_TYPE_RESTRICTION = 12 |
| XML_SCHEMA_TYPE_EXTENSION = 13 |
| XML_SCHEMA_TYPE_ELEMENT = 14 |
| XML_SCHEMA_TYPE_ATTRIBUTE = 15 |
| XML_SCHEMA_TYPE_ATTRIBUTEGROUP = 16 |
| XML_SCHEMA_TYPE_GROUP = 17 |
| XML_SCHEMA_TYPE_NOTATION = 18 |
| XML_SCHEMA_TYPE_LIST = 19 |
| XML_SCHEMA_TYPE_UNION = 20 |
| XML_SCHEMA_TYPE_ANY_ATTRIBUTE = 21 |
| XML_SCHEMA_TYPE_IDC_UNIQUE = 22 |
| XML_SCHEMA_TYPE_IDC_KEY = 23 |
| XML_SCHEMA_TYPE_IDC_KEYREF = 24 |
| XML_SCHEMA_TYPE_PARTICLE = 25 |
| XML_SCHEMA_TYPE_ATTRIBUTE_USE = 26 |
| XML_SCHEMA_FACET_MININCLUSIVE = 1000 |
| XML_SCHEMA_FACET_MINEXCLUSIVE = 1001 |
| XML_SCHEMA_FACET_MAXINCLUSIVE = 1002 |
| XML_SCHEMA_FACET_MAXEXCLUSIVE = 1003 |
| XML_SCHEMA_FACET_TOTALDIGITS = 1004 |
| XML_SCHEMA_FACET_FRACTIONDIGITS = 1005 |
| XML_SCHEMA_FACET_PATTERN = 1006 |
| XML_SCHEMA_FACET_ENUMERATION = 1007 |
| XML_SCHEMA_FACET_WHITESPACE = 1008 |
| XML_SCHEMA_FACET_LENGTH = 1009 |
| XML_SCHEMA_FACET_MAXLENGTH = 1010 |
| XML_SCHEMA_FACET_MINLENGTH = 1011 |
| XML_SCHEMA_EXTRA_QNAMEREF = 2000 |
| XML_SCHEMA_EXTRA_ATTR_USE_PROHIB = 2001 |
| |
| # xmlModuleOption |
| XML_MODULE_LAZY = 1 |
| XML_MODULE_LOCAL = 2 |
| |
| # xmlParserMode |
| XML_PARSE_UNKNOWN = 0 |
| XML_PARSE_DOM = 1 |
| XML_PARSE_SAX = 2 |
| XML_PARSE_PUSH_DOM = 3 |
| XML_PARSE_PUSH_SAX = 4 |
| XML_PARSE_READER = 5 |
| |
| # xmlC14NMode |
| XML_C14N_1_0 = 0 |
| XML_C14N_EXCLUSIVE_1_0 = 1 |
| XML_C14N_1_1 = 2 |
| |
| # xmlParserOption |
| XML_PARSE_RECOVER = 1 |
| XML_PARSE_NOENT = 2 |
| XML_PARSE_DTDLOAD = 4 |
| XML_PARSE_DTDATTR = 8 |
| XML_PARSE_DTDVALID = 16 |
| XML_PARSE_NOERROR = 32 |
| XML_PARSE_NOWARNING = 64 |
| XML_PARSE_PEDANTIC = 128 |
| XML_PARSE_NOBLANKS = 256 |
| XML_PARSE_SAX1 = 512 |
| XML_PARSE_XINCLUDE = 1024 |
| XML_PARSE_NONET = 2048 |
| XML_PARSE_NODICT = 4096 |
| XML_PARSE_NSCLEAN = 8192 |
| XML_PARSE_NOCDATA = 16384 |
| XML_PARSE_NOXINCNODE = 32768 |
| XML_PARSE_COMPACT = 65536 |
| XML_PARSE_OLD10 = 131072 |
| XML_PARSE_NOBASEFIX = 262144 |
| XML_PARSE_HUGE = 524288 |
| XML_PARSE_OLDSAX = 1048576 |
| XML_PARSE_IGNORE_ENC = 2097152 |
| XML_PARSE_BIG_LINES = 4194304 |
| |
| # xmlElementTypeVal |
| XML_ELEMENT_TYPE_UNDEFINED = 0 |
| XML_ELEMENT_TYPE_EMPTY = 1 |
| XML_ELEMENT_TYPE_ANY = 2 |
| XML_ELEMENT_TYPE_MIXED = 3 |
| XML_ELEMENT_TYPE_ELEMENT = 4 |
| |
| # xmlDocProperties |
| XML_DOC_WELLFORMED = 1 |
| XML_DOC_NSVALID = 2 |
| XML_DOC_OLD10 = 4 |
| XML_DOC_DTDVALID = 8 |
| XML_DOC_XINCLUDE = 16 |
| XML_DOC_USERBUILT = 32 |
| XML_DOC_INTERNAL = 64 |
| XML_DOC_HTML = 128 |
| |
| # xlinkType |
| XLINK_TYPE_NONE = 0 |
| XLINK_TYPE_SIMPLE = 1 |
| XLINK_TYPE_EXTENDED = 2 |
| XLINK_TYPE_EXTENDED_SET = 3 |
| |
| # xmlXPathObjectType |
| XPATH_UNDEFINED = 0 |
| XPATH_NODESET = 1 |
| XPATH_BOOLEAN = 2 |
| XPATH_NUMBER = 3 |
| XPATH_STRING = 4 |
| XPATH_POINT = 5 |
| XPATH_RANGE = 6 |
| XPATH_LOCATIONSET = 7 |
| XPATH_USERS = 8 |
| XPATH_XSLT_TREE = 9 |
| |
| # xmlSchemaValidError |
| XML_SCHEMAS_ERR_OK = 0 |
| XML_SCHEMAS_ERR_NOROOT = 1 |
| XML_SCHEMAS_ERR_UNDECLAREDELEM = 2 |
| XML_SCHEMAS_ERR_NOTTOPLEVEL = 3 |
| XML_SCHEMAS_ERR_MISSING = 4 |
| XML_SCHEMAS_ERR_WRONGELEM = 5 |
| XML_SCHEMAS_ERR_NOTYPE = 6 |
| XML_SCHEMAS_ERR_NOROLLBACK = 7 |
| XML_SCHEMAS_ERR_ISABSTRACT = 8 |
| XML_SCHEMAS_ERR_NOTEMPTY = 9 |
| XML_SCHEMAS_ERR_ELEMCONT = 10 |
| XML_SCHEMAS_ERR_HAVEDEFAULT = 11 |
| XML_SCHEMAS_ERR_NOTNILLABLE = 12 |
| XML_SCHEMAS_ERR_EXTRACONTENT = 13 |
| XML_SCHEMAS_ERR_INVALIDATTR = 14 |
| XML_SCHEMAS_ERR_INVALIDELEM = 15 |
| XML_SCHEMAS_ERR_NOTDETERMINIST = 16 |
| XML_SCHEMAS_ERR_CONSTRUCT = 17 |
| XML_SCHEMAS_ERR_INTERNAL = 18 |
| XML_SCHEMAS_ERR_NOTSIMPLE = 19 |
| XML_SCHEMAS_ERR_ATTRUNKNOWN = 20 |
| XML_SCHEMAS_ERR_ATTRINVALID = 21 |
| XML_SCHEMAS_ERR_VALUE = 22 |
| XML_SCHEMAS_ERR_FACET = 23 |
| XML_SCHEMAS_ERR_ = 24 |
| XML_SCHEMAS_ERR_XXX = 25 |
| |