python/drv_libxml2.py

   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