Annotation of embedaddon/libxml2/python/drv_libxml2.py, revision 1.1
1.1 ! misho 1: # -*- coding: iso-8859-1 -*-
! 2: """ A SAX2 driver for libxml2, on top of it's XmlReader API
! 3:
! 4: USAGE
! 5: # put this file (drv_libxml2.py) in PYTHONPATH
! 6: import xml.sax
! 7: reader = xml.sax.make_parser(["drv_libxml2"])
! 8: # ...and the rest is standard python sax.
! 9:
! 10: CAVEATS
! 11: - Lexical handlers are supported, except for start/endEntity
! 12: (waiting for XmlReader.ResolveEntity) and start/endDTD
! 13: - Error callbacks are not exactly synchronous, they tend
! 14: to be invoked before the corresponding content callback,
! 15: because the underlying reader interface parses
! 16: data by chunks of 512 bytes
! 17:
! 18: TODO
! 19: - search for TODO
! 20: - some ErrorHandler events (warning)
! 21: - some ContentHandler events (setDocumentLocator, skippedEntity)
! 22: - EntityResolver (using libxml2.?)
! 23: - DTDHandler (if/when libxml2 exposes such node types)
! 24: - DeclHandler (if/when libxml2 exposes such node types)
! 25: - property_xml_string?
! 26: - feature_string_interning?
! 27: - Incremental parser
! 28: - additional performance tuning:
! 29: - one might cache callbacks to avoid some name lookups
! 30: - one might implement a smarter way to pass attributes to startElement
! 31: (some kind of lazy evaluation?)
! 32: - there might be room for improvement in start/endPrefixMapping
! 33: - other?
! 34:
! 35: """
! 36:
! 37: __author__ = u"Stéphane Bidoul <sbi@skynet.be>"
! 38: __version__ = "0.3"
! 39:
! 40: import codecs
! 41: from types import StringType, UnicodeType
! 42: StringTypes = (StringType,UnicodeType)
! 43:
! 44: from xml.sax._exceptions import *
! 45: from xml.sax import xmlreader, saxutils
! 46: from xml.sax.handler import \
! 47: feature_namespaces, \
! 48: feature_namespace_prefixes, \
! 49: feature_string_interning, \
! 50: feature_validation, \
! 51: feature_external_ges, \
! 52: feature_external_pes, \
! 53: property_lexical_handler, \
! 54: property_declaration_handler, \
! 55: property_dom_node, \
! 56: property_xml_string
! 57:
! 58: # libxml2 returns strings as UTF8
! 59: _decoder = codecs.lookup("utf8")[1]
! 60: def _d(s):
! 61: if s is None:
! 62: return s
! 63: else:
! 64: return _decoder(s)[0]
! 65:
! 66: try:
! 67: import libxml2
! 68: except ImportError, e:
! 69: raise SAXReaderNotAvailable("libxml2 not available: " \
! 70: "import error was: %s" % e)
! 71:
! 72: class Locator(xmlreader.Locator):
! 73: """SAX Locator adapter for libxml2.xmlTextReaderLocator"""
! 74:
! 75: def __init__(self,locator):
! 76: self.__locator = locator
! 77:
! 78: def getColumnNumber(self):
! 79: "Return the column number where the current event ends."
! 80: return -1
! 81:
! 82: def getLineNumber(self):
! 83: "Return the line number where the current event ends."
! 84: return self.__locator.LineNumber()
! 85:
! 86: def getPublicId(self):
! 87: "Return the public identifier for the current event."
! 88: return None
! 89:
! 90: def getSystemId(self):
! 91: "Return the system identifier for the current event."
! 92: return self.__locator.BaseURI()
! 93:
! 94: class LibXml2Reader(xmlreader.XMLReader):
! 95:
! 96: def __init__(self):
! 97: xmlreader.XMLReader.__init__(self)
! 98: # features
! 99: self.__ns = 0
! 100: self.__nspfx = 0
! 101: self.__validate = 0
! 102: self.__extparams = 1
! 103: # parsing flag
! 104: self.__parsing = 0
! 105: # additional handlers
! 106: self.__lex_handler = None
! 107: self.__decl_handler = None
! 108: # error messages accumulator
! 109: self.__errors = None
! 110:
! 111: def _errorHandler(self,arg,msg,severity,locator):
! 112: if self.__errors is None:
! 113: self.__errors = []
! 114: self.__errors.append((severity,
! 115: SAXParseException(msg,None,
! 116: Locator(locator))))
! 117:
! 118: def _reportErrors(self,fatal):
! 119: for severity,exception in self.__errors:
! 120: if severity in (libxml2.PARSER_SEVERITY_VALIDITY_WARNING,
! 121: libxml2.PARSER_SEVERITY_WARNING):
! 122: self._err_handler.warning(exception)
! 123: else:
! 124: # when fatal is set, the parse will stop;
! 125: # we consider that the last error reported
! 126: # is the fatal one.
! 127: if fatal and exception is self.__errors[-1][1]:
! 128: self._err_handler.fatalError(exception)
! 129: else:
! 130: self._err_handler.error(exception)
! 131: self.__errors = None
! 132:
! 133: def parse(self, source):
! 134: self.__parsing = 1
! 135: try:
! 136: # prepare source and create reader
! 137: if type(source) in StringTypes:
! 138: reader = libxml2.newTextReaderFilename(source)
! 139: else:
! 140: source = saxutils.prepare_input_source(source)
! 141: input = libxml2.inputBuffer(source.getByteStream())
! 142: reader = input.newTextReader(source.getSystemId())
! 143: reader.SetErrorHandler(self._errorHandler,None)
! 144: # configure reader
! 145: if self.__extparams:
! 146: reader.SetParserProp(libxml2.PARSER_LOADDTD,1)
! 147: reader.SetParserProp(libxml2.PARSER_DEFAULTATTRS,1)
! 148: reader.SetParserProp(libxml2.PARSER_SUBST_ENTITIES,1)
! 149: reader.SetParserProp(libxml2.PARSER_VALIDATE,self.__validate)
! 150: else:
! 151: reader.SetParserProp(libxml2.PARSER_LOADDTD, 0)
! 152: # we reuse attribute maps (for a slight performance gain)
! 153: if self.__ns:
! 154: attributesNSImpl = xmlreader.AttributesNSImpl({},{})
! 155: else:
! 156: attributesImpl = xmlreader.AttributesImpl({})
! 157: # prefixes to pop (for endPrefixMapping)
! 158: prefixes = []
! 159: # start loop
! 160: self._cont_handler.startDocument()
! 161: while 1:
! 162: r = reader.Read()
! 163: # check for errors
! 164: if r == 1:
! 165: if not self.__errors is None:
! 166: self._reportErrors(0)
! 167: elif r == 0:
! 168: if not self.__errors is None:
! 169: self._reportErrors(0)
! 170: break # end of parse
! 171: else:
! 172: if not self.__errors is None:
! 173: self._reportErrors(1)
! 174: else:
! 175: self._err_handler.fatalError(\
! 176: SAXException("Read failed (no details available)"))
! 177: break # fatal parse error
! 178: # get node type
! 179: nodeType = reader.NodeType()
! 180: # Element
! 181: if nodeType == 1:
! 182: if self.__ns:
! 183: eltName = (_d(reader.NamespaceUri()),\
! 184: _d(reader.LocalName()))
! 185: eltQName = _d(reader.Name())
! 186: attributesNSImpl._attrs = attrs = {}
! 187: attributesNSImpl._qnames = qnames = {}
! 188: newPrefixes = []
! 189: while reader.MoveToNextAttribute():
! 190: qname = _d(reader.Name())
! 191: value = _d(reader.Value())
! 192: if qname.startswith("xmlns"):
! 193: if len(qname) > 5:
! 194: newPrefix = qname[6:]
! 195: else:
! 196: newPrefix = None
! 197: newPrefixes.append(newPrefix)
! 198: self._cont_handler.startPrefixMapping(\
! 199: newPrefix,value)
! 200: if not self.__nspfx:
! 201: continue # don't report xmlns attribute
! 202: attName = (_d(reader.NamespaceUri()),
! 203: _d(reader.LocalName()))
! 204: qnames[attName] = qname
! 205: attrs[attName] = value
! 206: reader.MoveToElement()
! 207: self._cont_handler.startElementNS( \
! 208: eltName,eltQName,attributesNSImpl)
! 209: if reader.IsEmptyElement():
! 210: self._cont_handler.endElementNS(eltName,eltQName)
! 211: for newPrefix in newPrefixes:
! 212: self._cont_handler.endPrefixMapping(newPrefix)
! 213: else:
! 214: prefixes.append(newPrefixes)
! 215: else:
! 216: eltName = _d(reader.Name())
! 217: attributesImpl._attrs = attrs = {}
! 218: while reader.MoveToNextAttribute():
! 219: attName = _d(reader.Name())
! 220: attrs[attName] = _d(reader.Value())
! 221: reader.MoveToElement()
! 222: self._cont_handler.startElement( \
! 223: eltName,attributesImpl)
! 224: if reader.IsEmptyElement():
! 225: self._cont_handler.endElement(eltName)
! 226: # EndElement
! 227: elif nodeType == 15:
! 228: if self.__ns:
! 229: self._cont_handler.endElementNS( \
! 230: (_d(reader.NamespaceUri()),_d(reader.LocalName())),
! 231: _d(reader.Name()))
! 232: for prefix in prefixes.pop():
! 233: self._cont_handler.endPrefixMapping(prefix)
! 234: else:
! 235: self._cont_handler.endElement(_d(reader.Name()))
! 236: # Text
! 237: elif nodeType == 3:
! 238: self._cont_handler.characters(_d(reader.Value()))
! 239: # Whitespace
! 240: elif nodeType == 13:
! 241: self._cont_handler.ignorableWhitespace(_d(reader.Value()))
! 242: # SignificantWhitespace
! 243: elif nodeType == 14:
! 244: self._cont_handler.characters(_d(reader.Value()))
! 245: # CDATA
! 246: elif nodeType == 4:
! 247: if not self.__lex_handler is None:
! 248: self.__lex_handler.startCDATA()
! 249: self._cont_handler.characters(_d(reader.Value()))
! 250: if not self.__lex_handler is None:
! 251: self.__lex_handler.endCDATA()
! 252: # EntityReference
! 253: elif nodeType == 5:
! 254: if not self.__lex_handler is None:
! 255: self.startEntity(_d(reader.Name()))
! 256: reader.ResolveEntity()
! 257: # EndEntity
! 258: elif nodeType == 16:
! 259: if not self.__lex_handler is None:
! 260: self.endEntity(_d(reader.Name()))
! 261: # ProcessingInstruction
! 262: elif nodeType == 7:
! 263: self._cont_handler.processingInstruction( \
! 264: _d(reader.Name()),_d(reader.Value()))
! 265: # Comment
! 266: elif nodeType == 8:
! 267: if not self.__lex_handler is None:
! 268: self.__lex_handler.comment(_d(reader.Value()))
! 269: # DocumentType
! 270: elif nodeType == 10:
! 271: #if not self.__lex_handler is None:
! 272: # self.__lex_handler.startDTD()
! 273: pass # TODO (how to detect endDTD? on first non-dtd event?)
! 274: # XmlDeclaration
! 275: elif nodeType == 17:
! 276: pass # TODO
! 277: # Entity
! 278: elif nodeType == 6:
! 279: pass # TODO (entity decl)
! 280: # Notation (decl)
! 281: elif nodeType == 12:
! 282: pass # TODO
! 283: # Attribute (never in this loop)
! 284: #elif nodeType == 2:
! 285: # pass
! 286: # Document (not exposed)
! 287: #elif nodeType == 9:
! 288: # pass
! 289: # DocumentFragment (never returned by XmlReader)
! 290: #elif nodeType == 11:
! 291: # pass
! 292: # None
! 293: #elif nodeType == 0:
! 294: # pass
! 295: # -
! 296: else:
! 297: raise SAXException("Unexpected node type %d" % nodeType)
! 298: if r == 0:
! 299: self._cont_handler.endDocument()
! 300: reader.Close()
! 301: finally:
! 302: self.__parsing = 0
! 303:
! 304: def setDTDHandler(self, handler):
! 305: # TODO (when supported, the inherited method works just fine)
! 306: raise SAXNotSupportedException("DTDHandler not supported")
! 307:
! 308: def setEntityResolver(self, resolver):
! 309: # TODO (when supported, the inherited method works just fine)
! 310: raise SAXNotSupportedException("EntityResolver not supported")
! 311:
! 312: def getFeature(self, name):
! 313: if name == feature_namespaces:
! 314: return self.__ns
! 315: elif name == feature_namespace_prefixes:
! 316: return self.__nspfx
! 317: elif name == feature_validation:
! 318: return self.__validate
! 319: elif name == feature_external_ges:
! 320: return 1 # TODO (does that relate to PARSER_LOADDTD)?
! 321: elif name == feature_external_pes:
! 322: return self.__extparams
! 323: else:
! 324: raise SAXNotRecognizedException("Feature '%s' not recognized" % \
! 325: name)
! 326:
! 327: def setFeature(self, name, state):
! 328: if self.__parsing:
! 329: raise SAXNotSupportedException("Cannot set feature %s " \
! 330: "while parsing" % name)
! 331: if name == feature_namespaces:
! 332: self.__ns = state
! 333: elif name == feature_namespace_prefixes:
! 334: self.__nspfx = state
! 335: elif name == feature_validation:
! 336: self.__validate = state
! 337: elif name == feature_external_ges:
! 338: if state == 0:
! 339: # TODO (does that relate to PARSER_LOADDTD)?
! 340: raise SAXNotSupportedException("Feature '%s' not supported" % \
! 341: name)
! 342: elif name == feature_external_pes:
! 343: self.__extparams = state
! 344: else:
! 345: raise SAXNotRecognizedException("Feature '%s' not recognized" % \
! 346: name)
! 347:
! 348: def getProperty(self, name):
! 349: if name == property_lexical_handler:
! 350: return self.__lex_handler
! 351: elif name == property_declaration_handler:
! 352: return self.__decl_handler
! 353: else:
! 354: raise SAXNotRecognizedException("Property '%s' not recognized" % \
! 355: name)
! 356:
! 357: def setProperty(self, name, value):
! 358: if name == property_lexical_handler:
! 359: self.__lex_handler = value
! 360: elif name == property_declaration_handler:
! 361: # TODO: remove if/when libxml2 supports dtd events
! 362: raise SAXNotSupportedException("Property '%s' not supported" % \
! 363: name)
! 364: self.__decl_handler = value
! 365: else:
! 366: raise SAXNotRecognizedException("Property '%s' not recognized" % \
! 367: name)
! 368:
! 369: def create_parser():
! 370: return LibXml2Reader()
! 371:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to drv_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