Lib/xml/sax/expatreader.py

   1 """
   2 SAX driver for the pyexpat C module.  This driver works with
   3 pyexpat.__version__ == '2.22'.
   4 """
   5
   6 version = "0.20"
   7
   8 from xml.sax._exceptions import *
   9 from xml.sax.handler import feature_validation, feature_namespaces
  10 from xml.sax.handler import feature_namespace_prefixes
  11 from xml.sax.handler import feature_external_ges, feature_external_pes
  12 from xml.sax.handler import feature_string_interning
  13 from xml.sax.handler import property_xml_string, property_interning_dict
  14
  15 # xml.parsers.expat does not raise ImportError in Jython
  16 import sys
  17 if sys.platform[:4] == "java":
  18     raise SAXReaderNotAvailable("expat not available in Java", None)
  19 del sys
  20
  21 try:
  22     from xml.parsers import expat
  23 except ImportError:
  24     raise SAXReaderNotAvailable("expat not supported", None)
  25 else:
  26     if not hasattr(expat, "ParserCreate"):
  27         raise SAXReaderNotAvailable("expat not supported", None)
  28 from xml.sax import xmlreader, saxutils, handler
  29
  30 AttributesImpl = xmlreader.AttributesImpl
  31 AttributesNSImpl = xmlreader.AttributesNSImpl
  32
  33 # If we're using a sufficiently recent version of Python, we can use
  34 # weak references to avoid cycles between the parser and content
  35 # handler, otherwise we'll just have to pretend.
  36 try:
  37     import _weakref
  38 except ImportError:
  39     def _mkproxy(o):
  40         return o
  41 else:
  42     import weakref
  43     _mkproxy = weakref.proxy
  44     del weakref, _weakref
  45
  46 # --- ExpatLocator
  47
  48 class ExpatLocator(xmlreader.Locator):
  49     """Locator for use with the ExpatParser class.
  50
  51     This uses a weak reference to the parser object to avoid creating
  52     a circular reference between the parser and the content handler.
  53     """
  54     def __init__(self, parser):
  55         self._ref = _mkproxy(parser)
  56
  57     def getColumnNumber(self):
  58         parser = self._ref
  59         if parser._parser is None:
  60             return None
  61         return parser._parser.ErrorColumnNumber
  62
  63     def getLineNumber(self):
  64         parser = self._ref
  65         if parser._parser is None:
  66             return 1
  67         return parser._parser.ErrorLineNumber
  68
  69     def getPublicId(self):
  70         parser = self._ref
  71         if parser is None:
  72             return None
  73         return parser._source.getPublicId()
  74
  75     def getSystemId(self):
  76         parser = self._ref
  77         if parser is None:
  78             return None
  79         return parser._source.getSystemId()
  80
  81
  82 # --- ExpatParser
  83
  84 class ExpatParser(xmlreader.IncrementalParser, xmlreader.Locator):
  85     """SAX driver for the pyexpat C module."""
  86
  87     def __init__(self, namespaceHandling=0, bufsize=2**16-20):
  88         xmlreader.IncrementalParser.__init__(self, bufsize)
  89         self._source = xmlreader.InputSource()
  90         self._parser = None
  91         self._namespaces = namespaceHandling
  92         self._lex_handler_prop = None
  93         self._parsing = 0
  94         self._entity_stack = []
  95         self._external_ges = 1
  96         self._interning = None
  97
  98     # XMLReader methods
  99
 100     def parse(self, source):
 101         "Parse an XML document from a URL or an InputSource."
 102         source = saxutils.prepare_input_source(source)
 103
 104         self._source = source
 105         self.reset()
 106         self._cont_handler.setDocumentLocator(ExpatLocator(self))
 107         xmlreader.IncrementalParser.parse(self, source)
 108
 109     def prepareParser(self, source):
 110         if source.getSystemId() is not None:
 111             self._parser.SetBase(source.getSystemId())
 112
 113     # Redefined setContentHandler to allow changing handlers during parsing
 114
 115     def setContentHandler(self, handler):
 116         xmlreader.IncrementalParser.setContentHandler(self, handler)
 117         if self._parsing:
 118             self._reset_cont_handler()
 119
 120     def getFeature(self, name):
 121         if name == feature_namespaces:
 122             return self._namespaces
 123         elif name == feature_string_interning:
 124             return self._interning is not None
 125         elif name in (feature_validation, feature_external_pes,
 126                       feature_namespace_prefixes):
 127             return 0
 128         elif name == feature_external_ges:
 129             return self._external_ges
 130         raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
 131
 132     def setFeature(self, name, state):
 133         if self._parsing:
 134             raise SAXNotSupportedException("Cannot set features while parsing")
 135
 136         if name == feature_namespaces:
 137             self._namespaces = state
 138         elif name == feature_external_ges:
 139             self._external_ges = state
 140         elif name == feature_string_interning:
 141             if state:
 142                 if self._interning is None:
 143                     self._interning = {}
 144             else:
 145                 self._interning = None
 146         elif name == feature_validation:
 147             if state:
 148                 raise SAXNotSupportedException(
 149                     "expat does not support validation")
 150         elif name == feature_external_pes:
 151             if state:
 152                 raise SAXNotSupportedException(
 153                     "expat does not read external parameter entities")
 154         elif name == feature_namespace_prefixes:
 155             if state:
 156                 raise SAXNotSupportedException(
 157                     "expat does not report namespace prefixes")
 158         else:
 159             raise SAXNotRecognizedException(
 160                 "Feature '%s' not recognized" % name)
 161
 162     def getProperty(self, name):
 163         if name == handler.property_lexical_handler:
 164             return self._lex_handler_prop
 165         elif name == property_interning_dict:
 166             return self._interning
 167         elif name == property_xml_string:
 168             if self._parser:
 169                 if hasattr(self._parser, "GetInputContext"):
 170                     return self._parser.GetInputContext()
 171                 else:
 172                     raise SAXNotRecognizedException(
 173                         "This version of expat does not support getting"
 174                         " the XML string")
 175             else:
 176                 raise SAXNotSupportedException(
 177                     "XML string cannot be returned when not parsing")
 178         raise SAXNotRecognizedException("Property '%s' not recognized" % name)
 179
 180     def setProperty(self, name, value):
 181         if name == handler.property_lexical_handler:
 182             self._lex_handler_prop = value
 183             if self._parsing:
 184                 self._reset_lex_handler_prop()
 185         elif name == property_interning_dict:
 186             self._interning = value
 187         elif name == property_xml_string:
 188             raise SAXNotSupportedException("Property '%s' cannot be set" %
 189                                            name)
 190         else:
 191             raise SAXNotRecognizedException("Property '%s' not recognized" %
 192                                             name)
 193
 194     # IncrementalParser methods
 195
 196     def feed(self, data, isFinal = 0):
 197         if not self._parsing:
 198             self.reset()
 199             self._parsing = 1
 200             self._cont_handler.startDocument()
 201
 202         try:
 203             # The isFinal parameter is internal to the expat reader.
 204             # If it is set to true, expat will check validity of the entire
 205             # document. When feeding chunks, they are not normally final -
 206             # except when invoked from close.
 207             self._parser.Parse(data, isFinal)
 208         except expat.error, e:
 209             exc = SAXParseException(expat.ErrorString(e.code), e, self)
 210             # FIXME: when to invoke error()?
 211             self._err_handler.fatalError(exc)
 212
 213     def close(self):
 214         if self._entity_stack:
 215             # If we are completing an external entity, do nothing here
 216             return
 217         self.feed("", isFinal = 1)
 218         self._cont_handler.endDocument()
 219         self._parsing = 0
 220         # break cycle created by expat handlers pointing to our methods
 221         self._parser = None
 222
 223     def _reset_cont_handler(self):
 224         self._parser.ProcessingInstructionHandler = \
 225                                     self._cont_handler.processingInstruction
 226         self._parser.CharacterDataHandler = self._cont_handler.characters
 227
 228     def _reset_lex_handler_prop(self):
 229         lex = self._lex_handler_prop
 230         parser = self._parser
 231         if lex is None:
 232             parser.CommentHandler = None
 233             parser.StartCdataSectionHandler = None
 234             parser.EndCdataSectionHandler = None
 235             parser.StartDoctypeDeclHandler = None
 236             parser.EndDoctypeDeclHandler = None
 237         else:
 238             parser.CommentHandler = lex.comment
 239             parser.StartCdataSectionHandler = lex.startCDATA
 240             parser.EndCdataSectionHandler = lex.endCDATA
 241             parser.StartDoctypeDeclHandler = self.start_doctype_decl
 242             parser.EndDoctypeDeclHandler = lex.endDTD
 243
 244     def reset(self):
 245         if self._namespaces:
 246             self._parser = expat.ParserCreate(self._source.getEncoding(), " ",
 247                                               intern=self._interning)
 248             self._parser.namespace_prefixes = 1
 249             self._parser.StartElementHandler = self.start_element_ns
 250             self._parser.EndElementHandler = self.end_element_ns
 251         else:
 252             self._parser = expat.ParserCreate(self._source.getEncoding(),
 253                                               intern = self._interning)
 254             self._parser.StartElementHandler = self.start_element
 255             self._parser.EndElementHandler = self.end_element
 256
 257         self._reset_cont_handler()
 258         self._parser.UnparsedEntityDeclHandler = self.unparsed_entity_decl
 259         self._parser.NotationDeclHandler = self.notation_decl
 260         self._parser.StartNamespaceDeclHandler = self.start_namespace_decl
 261         self._parser.EndNamespaceDeclHandler = self.end_namespace_decl
 262
 263         self._decl_handler_prop = None
 264         if self._lex_handler_prop:
 265             self._reset_lex_handler_prop()
 266 #         self._parser.DefaultHandler =
 267 #         self._parser.DefaultHandlerExpand =
 268 #         self._parser.NotStandaloneHandler =
 269         self._parser.ExternalEntityRefHandler = self.external_entity_ref
 270         try:
 271             self._parser.SkippedEntityHandler = self.skipped_entity_handler
 272         except AttributeError:
 273             # This pyexpat does not support SkippedEntity
 274             pass
 275         self._parser.SetParamEntityParsing(
 276             expat.XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
 277
 278         self._parsing = 0
 279         self._entity_stack = []
 280
 281     # Locator methods
 282
 283     def getColumnNumber(self):
 284         if self._parser is None:
 285             return None
 286         return self._parser.ErrorColumnNumber
 287
 288     def getLineNumber(self):
 289         if self._parser is None:
 290             return 1
 291         return self._parser.ErrorLineNumber
 292
 293     def getPublicId(self):
 294         return self._source.getPublicId()
 295
 296     def getSystemId(self):
 297         return self._source.getSystemId()
 298
 299     # event handlers
 300     def start_element(self, name, attrs):
 301         self._cont_handler.startElement(name, AttributesImpl(attrs))
 302
 303     def end_element(self, name):
 304         self._cont_handler.endElement(name)
 305
 306     def start_element_ns(self, name, attrs):
 307         pair = name.split()
 308         if len(pair) == 1:
 309             # no namespace
 310             pair = (None, name)
 311         elif len(pair) == 3:
 312             pair = pair[0], pair[1]
 313         else:
 314             # default namespace
 315             pair = tuple(pair)
 316
 317         newattrs = {}
 318         qnames = {}
 319         for (aname, value) in attrs.items():
 320             parts = aname.split()
 321             length = len(parts)
 322             if length == 1:
 323                 # no namespace
 324                 qname = aname
 325                 apair = (None, aname)
 326             elif length == 3:
 327                 qname = "%s:%s" % (parts[2], parts[1])
 328                 apair = parts[0], parts[1]
 329             else:
 330                 # default namespace
 331                 qname = parts[1]
 332                 apair = tuple(parts)
 333
 334             newattrs[apair] = value
 335             qnames[apair] = qname
 336
 337         self._cont_handler.startElementNS(pair, None,
 338                                           AttributesNSImpl(newattrs, qnames))
 339
 340     def end_element_ns(self, name):
 341         pair = name.split()
 342         if len(pair) == 1:
 343             pair = (None, name)
 344         elif len(pair) == 3:
 345             pair = pair[0], pair[1]
 346         else:
 347             pair = tuple(pair)
 348
 349         self._cont_handler.endElementNS(pair, None)
 350
 351     # this is not used (call directly to ContentHandler)
 352     def processing_instruction(self, target, data):
 353         self._cont_handler.processingInstruction(target, data)
 354
 355     # this is not used (call directly to ContentHandler)
 356     def character_data(self, data):
 357         self._cont_handler.characters(data)
 358
 359     def start_namespace_decl(self, prefix, uri):
 360         self._cont_handler.startPrefixMapping(prefix, uri)
 361
 362     def end_namespace_decl(self, prefix):
 363         self._cont_handler.endPrefixMapping(prefix)
 364
 365     def start_doctype_decl(self, name, sysid, pubid, has_internal_subset):
 366         self._lex_handler_prop.startDTD(name, pubid, sysid)
 367
 368     def unparsed_entity_decl(self, name, base, sysid, pubid, notation_name):
 369         self._dtd_handler.unparsedEntityDecl(name, pubid, sysid, notation_name)
 370
 371     def notation_decl(self, name, base, sysid, pubid):
 372         self._dtd_handler.notationDecl(name, pubid, sysid)
 373
 374     def external_entity_ref(self, context, base, sysid, pubid):
 375         if not self._external_ges:
 376             return 1
 377
 378         source = self._ent_handler.resolveEntity(pubid, sysid)
 379         source = saxutils.prepare_input_source(source,
 380                                                self._source.getSystemId() or
 381                                                "")
 382
 383         self._entity_stack.append((self._parser, self._source))
 384         self._parser = self._parser.ExternalEntityParserCreate(context)
 385         self._source = source
 386
 387         try:
 388             xmlreader.IncrementalParser.parse(self, source)
 389         except:
 390             return 0  # FIXME: save error info here?
 391
 392         (self._parser, self._source) = self._entity_stack[-1]
 393         del self._entity_stack[-1]
 394         return 1
 395
 396     def skipped_entity_handler(self, name, is_pe):
 397         if is_pe:
 398             # The SAX spec requires to report skipped PEs with a '%'
 399             name = '%'+name
 400         self._cont_handler.skippedEntity(name)
 401
 402 # ---
 403
 404 def create_parser(*args, **kwargs):
 405     return ExpatParser(*args, **kwargs)
 406
 407 # ---
 408
 409 if __name__ == "__main__":
 410     import xml.sax.saxutils
 411     p = create_parser()
 412     p.setContentHandler(xml.sax.saxutils.XMLGenerator())
 413     p.setErrorHandler(xml.sax.ErrorHandler())
 414     p.parse("http://www.ibiblio.org/xml/examples/shakespeare/hamlet.xml")