drv_libxml2.py@ 11632

Last change on this file since 11632 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
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 <[email protected]>"
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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: