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") 415
