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
  10 # xml.parsers.expat does not raise ImportError in Jython
  11 import sys
  12 if sys.platform[ : 4] == "java":
  13     raise SAXReaderNotAvailable("expat not available in Java", None)
  14 del sys
  15
  16 try:
  17     from xml.parsers import expat
  18 except ImportError:
  19     raise SAXReaderNotAvailable("expat not supported",None)
  20 from xml.sax import xmlreader, saxutils, handler
  21
  22 AttributesImpl = xmlreader.AttributesImpl
  23 AttributesNSImpl = xmlreader.AttributesNSImpl
  24
  25 import string
  26
  27 # --- ExpatParser
  28
  29 class ExpatParser(xmlreader.IncrementalParser, xmlreader.Locator):
  30     "SAX driver for the Pyexpat C module."
  31
  32     def __init__(self, namespaceHandling=0, bufsize=2**16-20):
  33         xmlreader.IncrementalParser.__init__(self, bufsize)
  34         self._source = xmlreader.InputSource()
  35         self._parser = None
  36         self._namespaces = namespaceHandling
  37         self._lex_handler_prop = None
  38         self._parsing = 0
  39         self._entity_stack = []
  40
  41     # XMLReader methods
  42
  43     def parse(self, source):
  44         "Parse an XML document from a URL or an InputSource."
  45         source = saxutils.prepare_input_source(source)
  46
  47         self._source = source
  48         self.reset()
  49         self._cont_handler.setDocumentLocator(self)
  50         xmlreader.IncrementalParser.parse(self, source)
  51
  52     def prepareParser(self, source):
  53         if source.getSystemId() != None:
  54             self._parser.SetBase(source.getSystemId())
  55
  56     # Redefined setContentHandle to allow changing handlers during parsing
  57
  58     def setContentHandler(self, handler):
  59         xmlreader.IncrementalParser.setContentHandler(self, handler)
  60         if self._parsing:
  61             self._reset_cont_handler()
  62
  63     def getFeature(self, name):
  64         if name == handler.feature_namespaces:
  65             return self._namespaces
  66         raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
  67
  68     def setFeature(self, name, state):
  69         if self._parsing:
  70             raise SAXNotSupportedException("Cannot set features while parsing")
  71         if name == handler.feature_namespaces:
  72             self._namespaces = state
  73         else:
  74             raise SAXNotRecognizedException("Feature '%s' not recognized" %
  75                                             name)
  76
  77     def getProperty(self, name):
  78         if name == handler.property_lexical_handler:
  79             return self._lex_handler_prop
  80         raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  81
  82     def setProperty(self, name, value):
  83         if name == handler.property_lexical_handler:
  84             self._lex_handler_prop = value
  85             if self._parsing:
  86                 self._reset_lex_handler_prop()
  87         else:
  88             raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  89
  90     # IncrementalParser methods
  91
  92     def feed(self, data, isFinal = 0):
  93         if not self._parsing:
  94             self.reset()
  95             self._parsing = 1
  96             self._cont_handler.startDocument()
  97
  98         try:
  99             # The isFinal parameter is internal to the expat reader.
 100             # If it is set to true, expat will check validity of the entire
 101             # document. When feeding chunks, they are not normally final -
 102             # except when invoked from close.
 103             self._parser.Parse(data, isFinal)
 104         except expat.error:
 105             error_code = self._parser.ErrorCode
 106             exc = SAXParseException(expat.ErrorString(error_code), None, self)
 107             # FIXME: when to invoke error()?
 108             self._err_handler.fatalError(exc)
 109
 110     def close(self):
 111         if self._entity_stack:
 112             # If we are completing an external entity, do nothing here
 113             return
 114         self.feed("", isFinal = 1)
 115         self._cont_handler.endDocument()
 116         self._parsing = 0
 117         # break cycle created by expat handlers pointing to our methods
 118         self._parser = None
 119
 120     def _reset_cont_handler(self):
 121         self._parser.ProcessingInstructionHandler = \
 122                                     self._cont_handler.processingInstruction
 123         self._parser.CharacterDataHandler = self._cont_handler.characters
 124
 125     def _reset_lex_handler_prop(self):
 126         self._parser.CommentHandler = self._lex_handler_prop.comment
 127         self._parser.StartCdataSectionHandler = self._lex_handler_prop.startCDATA
 128         self._parser.EndCdataSectionHandler = self._lex_handler_prop.endCDATA
 129
 130     def reset(self):
 131         if self._namespaces:
 132             self._parser = expat.ParserCreate(None, " ")
 133             self._parser.StartElementHandler = self.start_element_ns
 134             self._parser.EndElementHandler = self.end_element_ns
 135         else:
 136             self._parser = expat.ParserCreate()
 137             self._parser.StartElementHandler = self.start_element
 138             self._parser.EndElementHandler = self.end_element
 139
 140         self._reset_cont_handler()
 141         self._parser.UnparsedEntityDeclHandler = self.unparsed_entity_decl
 142         self._parser.NotationDeclHandler = self.notation_decl
 143         self._parser.StartNamespaceDeclHandler = self.start_namespace_decl
 144         self._parser.EndNamespaceDeclHandler = self.end_namespace_decl
 145
 146         self._decl_handler_prop = None
 147         if self._lex_handler_prop:
 148             self._reset_lex_handler_prop()
 149 #         self._parser.DefaultHandler =
 150 #         self._parser.DefaultHandlerExpand =
 151 #         self._parser.NotStandaloneHandler =
 152         self._parser.ExternalEntityRefHandler = self.external_entity_ref
 153
 154         self._parsing = 0
 155         self._entity_stack = []
 156
 157     # Locator methods
 158
 159     def getColumnNumber(self):
 160         if self._parser is None:
 161             return None
 162         return self._parser.ErrorColumnNumber
 163
 164     def getLineNumber(self):
 165         if self._parser is None:
 166             return 1
 167         return self._parser.ErrorLineNumber
 168
 169     def getPublicId(self):
 170         return self._source.getPublicId()
 171
 172     def getSystemId(self):
 173         return self._source.getSystemId()
 174
 175     # event handlers
 176     def start_element(self, name, attrs):
 177         self._cont_handler.startElement(name, AttributesImpl(attrs))
 178
 179     def end_element(self, name):
 180         self._cont_handler.endElement(name)
 181
 182     def start_element_ns(self, name, attrs):
 183         pair = string.split(name)
 184         if len(pair) == 1:
 185             pair = (None, name)
 186         else:
 187             pair = tuple(pair)
 188
 189         newattrs = {}
 190         for (aname, value) in attrs.items():
 191             apair = string.split(aname)
 192             if len(apair) == 1:
 193                 apair = (None, aname)
 194             else:
 195                 apair = tuple(apair)
 196
 197             newattrs[apair] = value
 198
 199         self._cont_handler.startElementNS(pair, None,
 200                                           AttributesNSImpl(newattrs, {}))
 201
 202     def end_element_ns(self, name):
 203         pair = string.split(name)
 204         if len(pair) == 1:
 205             pair = (None, name)
 206         else:
 207             pair = tuple(pair)
 208
 209         self._cont_handler.endElementNS(pair, None)
 210
 211     # this is not used (call directly to ContentHandler)
 212     def processing_instruction(self, target, data):
 213         self._cont_handler.processingInstruction(target, data)
 214
 215     # this is not used (call directly to ContentHandler)
 216     def character_data(self, data):
 217         self._cont_handler.characters(data)
 218
 219     def start_namespace_decl(self, prefix, uri):
 220         self._cont_handler.startPrefixMapping(prefix, uri)
 221
 222     def end_namespace_decl(self, prefix):
 223         self._cont_handler.endPrefixMapping(prefix)
 224
 225     def unparsed_entity_decl(self, name, base, sysid, pubid, notation_name):
 226         self._dtd_handler.unparsedEntityDecl(name, pubid, sysid, notation_name)
 227
 228     def notation_decl(self, name, base, sysid, pubid):
 229         self._dtd_handler.notationDecl(name, pubid, sysid)
 230
 231     def external_entity_ref(self, context, base, sysid, pubid):
 232         source = self._ent_handler.resolveEntity(pubid, sysid)
 233         source = saxutils.prepare_input_source(source,
 234                                                self._source.getSystemId() or
 235                                                "")
 236
 237         self._entity_stack.append((self._parser, self._source))
 238         self._parser = self._parser.ExternalEntityParserCreate(context)
 239         self._source = source
 240
 241         try:
 242             xmlreader.IncrementalParser.parse(self, source)
 243         except:
 244             return 0  # FIXME: save error info here?
 245
 246         (self._parser, self._source) = self._entity_stack[-1]
 247         del self._entity_stack[-1]
 248         return 1
 249
 250 # ---
 251
 252 def create_parser(*args, **kwargs):
 253     return apply(ExpatParser, args, kwargs)
 254
 255 # ---
 256
 257 if __name__ == "__main__":
 258     import xml.sax
 259     p = create_parser()
 260     p.setContentHandler(xml.sax.XMLGenerator())
 261     p.setErrorHandler(xml.sax.ErrorHandler())
 262     p.parse("../../../hamlet.xml")