VirtualBox

source: vbox/trunk/src/libs/libxml2-2.6.30/python/drv_libxml2.py@ 7138

Last change on this file since 7138 was 6076, checked in by vboxsync, 17 years ago

Merged dmik/s2 branch (r25959:26751) to the trunk.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Date Revision Author Id
File size: 14.7 KB
Line 
1# -*- coding: iso-8859-1 -*-
2""" A SAX2 driver for libxml2, on top of it's XmlReader API
3
4USAGE
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
10CAVEATS
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
18TODO
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
40import codecs
41from types import StringType, UnicodeType
42StringTypes = (StringType,UnicodeType)
43
44from xml.sax._exceptions import *
45from xml.sax import xmlreader, saxutils
46from 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]
60def _d(s):
61 if s is None:
62 return s
63 else:
64 return _decoder(s)[0]
65
66try:
67 import libxml2
68except ImportError, e:
69 raise SAXReaderNotAvailable("libxml2 not available: " \
70 "import error was: %s" % e)
71
72class 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
94class 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
369def create_parser():
370 return LibXml2Reader()
371
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette