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