607 lines
21 KiB
Python
607 lines
21 KiB
Python
|
# coding: utf-8
|
||
|
|
|
||
|
|
#------------------------------------------------------------------------------
|
||
|
|
# Copyright (c) 2008 Sébastien Boisgérault
|
||
|
|
#
|
||
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
|
|
# of this software and associated documentation files (the "Software"), to deal
|
||
|
|
# in the Software without restriction, including without limitation the rights
|
||
|
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
|
|
# copies of the Software, and to permit persons to whom the Software is
|
||
|
|
# furnished to do so, subject to the following conditions:
|
||
|
|
#
|
||
|
|
# The above copyright notice and this permission notice shall be included in
|
||
|
|
# all copies or substantial portions of the Software.
|
||
|
|
#
|
||
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
|
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||
|
|
# THE SOFTWARE.
|
||
|
|
# -----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
__all__ = ["ExpatError", "ParserCreate", "XMLParserType", "error", "errors"]
|
||
|
|
|
||
|
|
# Jython check
|
||
|
|
import sys
|
||
|
|
if not sys.platform.startswith('java'):
|
||
|
|
raise ImportError("this version of expat requires the jython interpreter")
|
||
|
|
|
||
|
|
# Standard Python Library
|
||
|
|
import re
|
||
|
|
import types
|
||
|
|
|
||
|
|
# Jython
|
||
|
|
from org.python.core import Py
|
||
|
|
from org.python.core.util import StringUtil
|
||
|
|
from jarray import array
|
||
|
|
|
||
|
|
# Java Standard Edition
|
||
|
|
from java.io import ByteArrayInputStream
|
||
|
|
from java.lang import String, StringBuilder
|
||
|
|
from org.xml.sax import InputSource
|
||
|
|
from org.xml.sax import SAXNotRecognizedException, SAXParseException
|
||
|
|
from org.xml.sax.helpers import XMLReaderFactory
|
||
|
|
from org.xml.sax.ext import DefaultHandler2
|
||
|
|
|
||
|
|
# Xerces
|
||
|
|
try:
|
||
|
|
# Name mangled by jarjar?
|
||
|
|
import org.python.apache.xerces.parsers.SAXParser
|
||
|
|
_xerces_parser = "org.python.apache.xerces.parsers.SAXParser"
|
||
|
|
except ImportError:
|
||
|
|
_xerces_parser = "org.apache.xerces.parsers.SAXParser"
|
||
|
|
|
||
|
|
|
||
|
|
# @expat args registry
|
||
|
|
_register = {}
|
||
|
|
|
||
|
|
|
||
|
|
def ParserCreate(encoding=None, namespace_separator=None):
|
||
|
|
return XMLParser(encoding, namespace_separator)
|
||
|
|
|
||
|
|
|
||
|
|
class XMLParser(object):
|
||
|
|
|
||
|
|
def __init__(self, encoding, namespace_separator):
|
||
|
|
self.encoding = encoding
|
||
|
|
self.CurrentLineNumber = 1
|
||
|
|
self.CurrentColumnNumber = 0
|
||
|
|
self._NextLineNumber = 1
|
||
|
|
self._NextColumnNumber = 0
|
||
|
|
self.ErrorLineNumber = -1
|
||
|
|
self.ErrorColumnNumber = -1
|
||
|
|
self.ErrorCode = None
|
||
|
|
|
||
|
|
if namespace_separator is None:
|
||
|
|
self.namespace_separator = namespace_separator
|
||
|
|
elif isinstance(namespace_separator, basestring):
|
||
|
|
self.namespace_separator = str(namespace_separator)
|
||
|
|
if len(self.namespace_separator) > 1:
|
||
|
|
error = ("namespace_separator must be at most one character, "
|
||
|
|
"omitted, or None")
|
||
|
|
raise ValueError(error)
|
||
|
|
else:
|
||
|
|
error = ("ParserCreate() argument 2 must be string or None, "
|
||
|
|
"not %s" % type(namespace_separator).__name__)
|
||
|
|
raise TypeError(error)
|
||
|
|
|
||
|
|
self._reader = XMLReaderFactory.createXMLReader(_xerces_parser)
|
||
|
|
|
||
|
|
if self.namespace_separator is None:
|
||
|
|
try:
|
||
|
|
feature = "http://xml.org/sax/features/namespaces"
|
||
|
|
self._reader.setFeature(feature, False)
|
||
|
|
except SAXNotRecognizedException:
|
||
|
|
error = ("namespace support cannot be disabled; "
|
||
|
|
"set namespace_separator to a string of length 1.")
|
||
|
|
raise ValueError(error)
|
||
|
|
|
||
|
|
self._base = None
|
||
|
|
self._buffer_text = True
|
||
|
|
self._returns_unicode = True
|
||
|
|
|
||
|
|
self._data = StringBuilder()
|
||
|
|
|
||
|
|
self._handler = XMLEventHandler(self)
|
||
|
|
self._reader.setContentHandler(self._handler)
|
||
|
|
self._reader.setErrorHandler(self._handler)
|
||
|
|
self._reader.setDTDHandler(self._handler)
|
||
|
|
self._reader.setEntityResolver(self._handler)
|
||
|
|
|
||
|
|
sax_properties = ("lexical-handler", "declaration-handler")
|
||
|
|
for name in sax_properties:
|
||
|
|
try:
|
||
|
|
name = "http://xml.org/sax/properties/" + name
|
||
|
|
self._reader.setProperty(name, self._handler)
|
||
|
|
except SAXNotRecognizedException:
|
||
|
|
error = "can't set property %r" % name
|
||
|
|
raise NotImplementedError(error)
|
||
|
|
|
||
|
|
apache_features = (("nonvalidating/load-external-dtd", False),)
|
||
|
|
for name, value in apache_features:
|
||
|
|
try:
|
||
|
|
name = "http://apache.org/xml/features/" + name
|
||
|
|
self._reader.setFeature(name, value)
|
||
|
|
except SAXNotRecognizedException:
|
||
|
|
error = "can't set feature %r" % name
|
||
|
|
raise NotImplementedError(error)
|
||
|
|
|
||
|
|
# experimental
|
||
|
|
#f = "http://xml.org/sax/features/external-general-entities"
|
||
|
|
f = "http://xml.org/sax/features/external-parameter-entities"
|
||
|
|
#self._reader.setFeature(f, False)
|
||
|
|
|
||
|
|
# check
|
||
|
|
f = "http://xml.org/sax/features/use-entity-resolver2"
|
||
|
|
assert self._reader.getFeature(f)
|
||
|
|
|
||
|
|
def GetBase(self):
|
||
|
|
return self._base
|
||
|
|
|
||
|
|
def SetBase(self, base):
|
||
|
|
self._base = base
|
||
|
|
|
||
|
|
def _error(self, value=None):
|
||
|
|
raise AttributeError("'XMLParser' has no such attribute")
|
||
|
|
|
||
|
|
def _get_buffer_text(self):
|
||
|
|
return self._buffer_text
|
||
|
|
|
||
|
|
def _set_buffer_text(self, value):
|
||
|
|
self._buffer_text = bool(value)
|
||
|
|
|
||
|
|
def _get_returns_unicode(self):
|
||
|
|
return bool(self._returns_unicode)
|
||
|
|
|
||
|
|
def _set_returns_unicode(self, value):
|
||
|
|
self._returns_unicode = value
|
||
|
|
|
||
|
|
# 'ordered' and 'specified' attributes are not supported
|
||
|
|
ordered_attributes = property(_error, _error)
|
||
|
|
specified_attributes = property(_error, _error)
|
||
|
|
# any setting is allowed, but it won't make a difference
|
||
|
|
buffer_text = property(_get_buffer_text, _set_buffer_text)
|
||
|
|
# non-significant read-only values
|
||
|
|
buffer_used = property(lambda self: None)
|
||
|
|
buffer_size = property(lambda self: None)
|
||
|
|
# 'returns_unicode' attribute is properly supported
|
||
|
|
returns_unicode = property(_get_returns_unicode, _set_returns_unicode)
|
||
|
|
|
||
|
|
def _expat_error(self, sax_error):
|
||
|
|
sax_message = sax_error.getMessage()
|
||
|
|
pattern = 'The entity ".*" was referenced, but not declared\.'
|
||
|
|
if re.match(pattern, sax_message):
|
||
|
|
expat_message = "undefined entity: line %s, column %s" % \
|
||
|
|
(self.ErrorLineNumber, self.ErrorColumnNumber)
|
||
|
|
else:
|
||
|
|
expat_message = sax_message
|
||
|
|
error = ExpatError(expat_message)
|
||
|
|
error.lineno = self.ErrorLineNumber
|
||
|
|
error.offset = self.ErrorColumnNumber
|
||
|
|
error.code = self.ErrorCode
|
||
|
|
return error
|
||
|
|
|
||
|
|
def Parse(self, data, isfinal=False):
|
||
|
|
# The 'data' argument should be an encoded text: a str instance that
|
||
|
|
# represents an array of bytes. If instead it is a unicode string,
|
||
|
|
# only the us-ascii range is considered safe enough to be silently
|
||
|
|
# converted.
|
||
|
|
if isinstance(data, unicode):
|
||
|
|
data = data.encode(sys.getdefaultencoding())
|
||
|
|
|
||
|
|
self._data.append(data)
|
||
|
|
|
||
|
|
if isfinal:
|
||
|
|
bytes = StringUtil.toBytes(self._data.toString())
|
||
|
|
byte_stream = ByteArrayInputStream(bytes)
|
||
|
|
source = InputSource(byte_stream)
|
||
|
|
if self.encoding is not None:
|
||
|
|
source.setEncoding(self.encoding)
|
||
|
|
try:
|
||
|
|
self._reader.parse(source)
|
||
|
|
except SAXParseException, sax_error:
|
||
|
|
# Experiments tend to show that the '_Next*' parser locations
|
||
|
|
# match more closely expat behavior than the 'Current*' or sax
|
||
|
|
# error locations.
|
||
|
|
self.ErrorLineNumber = self._NextLineNumber
|
||
|
|
self.ErrorColumnNumber = self._NextColumnNumber
|
||
|
|
self.ErrorCode = None
|
||
|
|
raise self._expat_error(sax_error)
|
||
|
|
return 1
|
||
|
|
|
||
|
|
def ParseFile(self, file):
|
||
|
|
# TODO: pseudo-buffering if a read without argument is not supported.
|
||
|
|
# document parse / parsefile usage.
|
||
|
|
return self.Parse(file.read(), isfinal=True)
|
||
|
|
|
||
|
|
|
||
|
|
XMLParserType = XMLParser
|
||
|
|
|
||
|
|
|
||
|
|
def _encode(arg, encoding):
|
||
|
|
if isinstance(arg, unicode):
|
||
|
|
return arg.encode(encoding)
|
||
|
|
else:
|
||
|
|
if isinstance(arg, dict):
|
||
|
|
iterator = arg.iteritems()
|
||
|
|
else:
|
||
|
|
iterator = iter(arg)
|
||
|
|
return type(arg)(_encode(_arg, encoding) for _arg in iterator)
|
||
|
|
|
||
|
|
|
||
|
|
def expat(callback=None, guard=True, force=False, returns=None):
|
||
|
|
def _expat(method):
|
||
|
|
name = method.__name__
|
||
|
|
context = id(sys._getframe(1))
|
||
|
|
key = name, context
|
||
|
|
append = _register.setdefault(key, []).append
|
||
|
|
append((method, callback, guard, force, returns))
|
||
|
|
|
||
|
|
def new_method(*args):
|
||
|
|
self = args[0]
|
||
|
|
parser = self.parser
|
||
|
|
self._update_location(event=name) # bug if multiple method def
|
||
|
|
for (method, callback, guard, force, returns) in _register[key]:
|
||
|
|
if guard not in (True, False):
|
||
|
|
guard = getattr(self, guard)
|
||
|
|
_callback = callback and guard and \
|
||
|
|
getattr(parser, callback, None)
|
||
|
|
if _callback or force:
|
||
|
|
results = method(*args)
|
||
|
|
if _callback:
|
||
|
|
if not isinstance(results, tuple):
|
||
|
|
results = (results,)
|
||
|
|
if not parser.returns_unicode:
|
||
|
|
results = _encode(results, "utf-8")
|
||
|
|
_callback(*results)
|
||
|
|
return returns
|
||
|
|
|
||
|
|
new_method.__name__ = name
|
||
|
|
#new_method.__doc__ = method.__doc__ # what to do with multiple docs ?
|
||
|
|
return new_method
|
||
|
|
return _expat
|
||
|
|
|
||
|
|
|
||
|
|
class XMLEventHandler(DefaultHandler2):
|
||
|
|
|
||
|
|
def __init__(self, parser):
|
||
|
|
self.parser = parser
|
||
|
|
self._tags = {}
|
||
|
|
self.not_in_dtd = True
|
||
|
|
self._entity = {}
|
||
|
|
self._previous_event = None
|
||
|
|
|
||
|
|
# --- Helpers -------------------------------------------------------------
|
||
|
|
|
||
|
|
def _intern(self, tag):
|
||
|
|
return self._tags.setdefault(tag, tag)
|
||
|
|
|
||
|
|
def _qualify(self, local_name, qname, namespace=None):
|
||
|
|
namespace_separator = self.parser.namespace_separator
|
||
|
|
if namespace_separator is None:
|
||
|
|
return qname
|
||
|
|
if not namespace:
|
||
|
|
return local_name
|
||
|
|
else:
|
||
|
|
return namespace + namespace_separator + local_name
|
||
|
|
|
||
|
|
def _char_slice_to_unicode(self, characters, start, length):
|
||
|
|
"""Convert a char[] slice to a PyUnicode instance"""
|
||
|
|
text = Py.newUnicode(String(characters[start:start + length]))
|
||
|
|
return text
|
||
|
|
|
||
|
|
def _expat_content_model(self, name, model_):
|
||
|
|
# TODO : implement a model parser
|
||
|
|
return (name, model_) # does not fit expat conventions
|
||
|
|
|
||
|
|
def _update_location(self, event=None):
|
||
|
|
parser = self.parser
|
||
|
|
locator = self._locator
|
||
|
|
|
||
|
|
# ugly hack that takes care of a xerces-specific (?) locator issue:
|
||
|
|
# locate start and end elements at the '<' instead of the first tag
|
||
|
|
# type character.
|
||
|
|
if event == "startElement" and self._previous_event == "characters":
|
||
|
|
parser._NextColumnNumber = max(parser._NextColumnNumber - 1, 0)
|
||
|
|
if event == "endElement" and self._previous_event == "characters":
|
||
|
|
parser._NextColumnNumber = max(parser._NextColumnNumber - 2, 0)
|
||
|
|
# TODO: use the same trick to report accurate error locations ?
|
||
|
|
|
||
|
|
parser.CurrentLineNumber = parser._NextLineNumber
|
||
|
|
parser.CurrentColumnNumber = parser._NextColumnNumber
|
||
|
|
parser._NextLineNumber = locator.getLineNumber()
|
||
|
|
parser._NextColumnNumber = locator.getColumnNumber() - 1
|
||
|
|
|
||
|
|
self._previous_event = event
|
||
|
|
|
||
|
|
# --- ContentHandler Interface --------------------------------------------
|
||
|
|
|
||
|
|
@expat("ProcessingInstructionHandler")
|
||
|
|
def processingInstruction(self, target, data):
|
||
|
|
return target, data
|
||
|
|
|
||
|
|
@expat("StartElementHandler")
|
||
|
|
def startElement(self, namespace, local_name, qname, attributes):
|
||
|
|
tag = self._qualify(local_name, qname, namespace)
|
||
|
|
attribs = {}
|
||
|
|
length = attributes.getLength()
|
||
|
|
for index in range(length):
|
||
|
|
local_name = attributes.getLocalName(index)
|
||
|
|
qname = attributes.getQName(index)
|
||
|
|
namespace = attributes.getURI(index)
|
||
|
|
name = self._qualify(local_name, qname, namespace)
|
||
|
|
value = attributes.getValue(index)
|
||
|
|
attribs[name] = value
|
||
|
|
return self._intern(tag), attribs
|
||
|
|
|
||
|
|
@expat("EndElementHandler")
|
||
|
|
def endElement(self, namespace, local_name, qname):
|
||
|
|
return self._intern(self._qualify(local_name, qname, namespace))
|
||
|
|
|
||
|
|
@expat("CharacterDataHandler")
|
||
|
|
def characters(self, characters, start, length):
|
||
|
|
return self._char_slice_to_unicode(characters, start, length)
|
||
|
|
|
||
|
|
@expat("DefaultHandlerExpand")
|
||
|
|
def characters(self, characters, start, length):
|
||
|
|
return self._char_slice_to_unicode(characters, start, length)
|
||
|
|
|
||
|
|
@expat("DefaultHandler")
|
||
|
|
def characters(self, characters, start, length):
|
||
|
|
# TODO: make a helper function here
|
||
|
|
if self._entity["location"] == (self.parser.CurrentLineNumber,
|
||
|
|
self.parser.CurrentColumnNumber):
|
||
|
|
return "&%s;" % self._entity["name"]
|
||
|
|
else:
|
||
|
|
return self._char_slice_to_unicode(characters, start, length)
|
||
|
|
|
||
|
|
@expat("StartNamespaceDeclHandler")
|
||
|
|
def startPrefixMapping(self, prefix, uri):
|
||
|
|
return prefix, uri
|
||
|
|
|
||
|
|
@expat("EndNamespaceDeclHandler")
|
||
|
|
def endPrefixMapping(self, prefix):
|
||
|
|
return prefix
|
||
|
|
|
||
|
|
empty_source = InputSource(ByteArrayInputStream(array([], "b")))
|
||
|
|
|
||
|
|
@expat("ExternalEntityRefHandler", guard="not_in_dtd",
|
||
|
|
returns=empty_source)
|
||
|
|
def resolveEntity(self, name, publicId, baseURI, systemId):
|
||
|
|
context = name # wrong. see expat headers documentation.
|
||
|
|
base = self.parser.GetBase()
|
||
|
|
return context, base, systemId, publicId
|
||
|
|
|
||
|
|
@expat("DefaultHandlerExpand", guard="not_in_dtd",
|
||
|
|
returns=empty_source)
|
||
|
|
def resolveEntity(self, name, publicId, baseURI, systemId):
|
||
|
|
return "&%s;" % name
|
||
|
|
|
||
|
|
@expat("DefaultHandler", guard="not_in_dtd",
|
||
|
|
returns=empty_source)
|
||
|
|
def resolveEntity(self, name, publicId, baseURI, systemId):
|
||
|
|
return "&%s;" % name
|
||
|
|
|
||
|
|
@expat(force=True, returns=empty_source)
|
||
|
|
def resolveEntity(self, name, publicId, baseURI, systemId):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def setDocumentLocator(self, locator):
|
||
|
|
self._locator = locator
|
||
|
|
|
||
|
|
def skippedEntity(self, name):
|
||
|
|
error = ExpatError()
|
||
|
|
error.lineno = self.ErrorLineNumber = self.parser._NextLineNumber
|
||
|
|
error.offset = self.ErrorColumnNumber = self.parser._NextColumnNumber
|
||
|
|
error.code = self.ErrorCode = None
|
||
|
|
message = "undefined entity &%s;: line %s, column %s"
|
||
|
|
message = message % (name, error.lineno, error.offset)
|
||
|
|
error.__init__(message)
|
||
|
|
raise error
|
||
|
|
|
||
|
|
# --- LexicalHandler Interface --------------------------------------------
|
||
|
|
|
||
|
|
@expat("CommentHandler")
|
||
|
|
def comment(self, characters, start, length):
|
||
|
|
return self._char_slice_to_unicode(characters, start, length)
|
||
|
|
|
||
|
|
@expat("StartCdataSectionHandler")
|
||
|
|
def startCDATA(self):
|
||
|
|
return ()
|
||
|
|
|
||
|
|
@expat("EndCdataSectionHandler")
|
||
|
|
def endCDATA(self):
|
||
|
|
return ()
|
||
|
|
|
||
|
|
@expat("StartDoctypeDeclHandler", force=True)
|
||
|
|
def startDTD(self, name, publicId, systemId):
|
||
|
|
self.not_in_dtd = False
|
||
|
|
has_internal_subset = 0 # don't know this ...
|
||
|
|
return name, systemId, publicId, has_internal_subset
|
||
|
|
|
||
|
|
@expat("EndDoctypeDeclHandler", force=True)
|
||
|
|
def endDTD(self):
|
||
|
|
self.not_in_dtd = True
|
||
|
|
|
||
|
|
def startEntity(self, name):
|
||
|
|
self._entity = {}
|
||
|
|
self._entity["location"] = (self.parser._NextLineNumber,
|
||
|
|
self.parser._NextColumnNumber)
|
||
|
|
self._entity["name"] = name
|
||
|
|
|
||
|
|
def endEntity(self, name):
|
||
|
|
pass
|
||
|
|
|
||
|
|
# --- DTDHandler Interface ------------------------------------------------
|
||
|
|
|
||
|
|
@expat("NotationDeclHandler")
|
||
|
|
def notationDecl(self, name, publicId, systemId):
|
||
|
|
base = self.parser.GetBase()
|
||
|
|
return name, base, systemId, publicId
|
||
|
|
|
||
|
|
@expat("UnparsedEntityDeclHandler") # deprecated
|
||
|
|
def unparsedEntityDecl(self, name, publicId, systemId, notationName):
|
||
|
|
base = self.parser.GetBase()
|
||
|
|
return name, base, systemId, publicId, notationName
|
||
|
|
|
||
|
|
# --- DeclHandler Interface -----------------------------------------------
|
||
|
|
|
||
|
|
@expat("AttlistDeclHandler")
|
||
|
|
def attributeDecl(self, eName, aName, type, mode, value):
|
||
|
|
# TODO: adapt mode, required, etc.
|
||
|
|
required = False
|
||
|
|
return eName, aName, type, value, required
|
||
|
|
|
||
|
|
@expat("ElementDeclHandler")
|
||
|
|
def elementDecl(self, name, model):
|
||
|
|
return self._expat_content_model(name, model)
|
||
|
|
|
||
|
|
@expat("EntityDeclHandler")
|
||
|
|
def externalEntityDecl(self, name, publicId, systemId):
|
||
|
|
base = self.parser.GetBase()
|
||
|
|
value = None
|
||
|
|
is_parameter_entity = None
|
||
|
|
notation_name = None
|
||
|
|
return (name, is_parameter_entity, value, base, systemId, publicId,
|
||
|
|
notation_name)
|
||
|
|
|
||
|
|
@expat("EntityDeclHandler")
|
||
|
|
def internalEntityDecl(self, name, value):
|
||
|
|
base = self.parser.GetBase()
|
||
|
|
is_parameter_entity = None
|
||
|
|
notation_name = None
|
||
|
|
systemId, publicId = None, None
|
||
|
|
return (name, is_parameter_entity, value, base, systemId, publicId,
|
||
|
|
notation_name)
|
||
|
|
|
||
|
|
|
||
|
|
def _init_model():
|
||
|
|
global model
|
||
|
|
model = types.ModuleType("pyexpat.model")
|
||
|
|
model.__doc__ = "Constants used to interpret content model information."
|
||
|
|
quantifiers = "NONE, OPT, REP, PLUS"
|
||
|
|
for i, quantifier in enumerate(quantifiers.split(", ")):
|
||
|
|
setattr(model, "XML_CQUANT_" + quantifier, i)
|
||
|
|
types_ = "EMPTY, ANY, MIXED, NAME, CHOICE, SEQ"
|
||
|
|
for i, type_ in enumerate(types_.split(", ")):
|
||
|
|
setattr(model, "XML_CTYPE_" + type_, i+1)
|
||
|
|
|
||
|
|
_init_model()
|
||
|
|
del _init_model
|
||
|
|
|
||
|
|
|
||
|
|
class ExpatError(Exception):
|
||
|
|
pass
|
||
|
|
|
||
|
|
|
||
|
|
error = ExpatError
|
||
|
|
|
||
|
|
|
||
|
|
def _init_error_strings():
|
||
|
|
global ErrorString
|
||
|
|
error_strings = (
|
||
|
|
None,
|
||
|
|
"out of memory",
|
||
|
|
"syntax error",
|
||
|
|
"no element found",
|
||
|
|
"not well-formed (invalid token)",
|
||
|
|
"unclosed token",
|
||
|
|
"partial character",
|
||
|
|
"mismatched tag",
|
||
|
|
"duplicate attribute",
|
||
|
|
"junk after document element",
|
||
|
|
"illegal parameter entity reference",
|
||
|
|
"undefined entity",
|
||
|
|
"recursive entity reference",
|
||
|
|
"asynchronous entity",
|
||
|
|
"reference to invalid character number",
|
||
|
|
"reference to binary entity",
|
||
|
|
"reference to external entity in attribute",
|
||
|
|
"XML or text declaration not at start of entity",
|
||
|
|
"unknown encoding",
|
||
|
|
"encoding specified in XML declaration is incorrect",
|
||
|
|
"unclosed CDATA section",
|
||
|
|
"error in processing external entity reference",
|
||
|
|
"document is not standalone",
|
||
|
|
"unexpected parser state - please send a bug report",
|
||
|
|
"entity declared in parameter entity",
|
||
|
|
"requested feature requires XML_DTD support in Expat",
|
||
|
|
"cannot change setting once parsing has begun",
|
||
|
|
"unbound prefix",
|
||
|
|
"must not undeclare prefix",
|
||
|
|
"incomplete markup in parameter entity",
|
||
|
|
"XML declaration not well-formed",
|
||
|
|
"text declaration not well-formed",
|
||
|
|
"illegal character(s) in public id",
|
||
|
|
"parser suspended",
|
||
|
|
"parser not suspended",
|
||
|
|
"parsing aborted",
|
||
|
|
"parsing finished",
|
||
|
|
"cannot suspend in external parameter entity")
|
||
|
|
def ErrorString(code):
|
||
|
|
try:
|
||
|
|
return error_strings[code]
|
||
|
|
except IndexError:
|
||
|
|
return None
|
||
|
|
|
||
|
|
_init_error_strings()
|
||
|
|
del _init_error_strings
|
||
|
|
|
||
|
|
|
||
|
|
def _init_errors():
|
||
|
|
global errors
|
||
|
|
|
||
|
|
errors = types.ModuleType("pyexpat.errors")
|
||
|
|
errors.__doc__ = "Constants used to describe error conditions."
|
||
|
|
|
||
|
|
error_names = """
|
||
|
|
XML_ERROR_NONE
|
||
|
|
XML_ERROR_NONE,
|
||
|
|
XML_ERROR_NO_MEMORY,
|
||
|
|
XML_ERROR_SYNTAX,
|
||
|
|
XML_ERROR_NO_ELEMENTS,
|
||
|
|
XML_ERROR_INVALID_TOKEN,
|
||
|
|
XML_ERROR_UNCLOSED_TOKEN,
|
||
|
|
XML_ERROR_PARTIAL_CHAR,
|
||
|
|
XML_ERROR_TAG_MISMATCH,
|
||
|
|
XML_ERROR_DUPLICATE_ATTRIBUTE,
|
||
|
|
XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
|
||
|
|
XML_ERROR_PARAM_ENTITY_REF,
|
||
|
|
XML_ERROR_UNDEFINED_ENTITY,
|
||
|
|
XML_ERROR_RECURSIVE_ENTITY_REF,
|
||
|
|
XML_ERROR_ASYNC_ENTITY,
|
||
|
|
XML_ERROR_BAD_CHAR_REF,
|
||
|
|
XML_ERROR_BINARY_ENTITY_REF,
|
||
|
|
XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
|
||
|
|
XML_ERROR_MISPLACED_XML_PI,
|
||
|
|
XML_ERROR_UNKNOWN_ENCODING,
|
||
|
|
XML_ERROR_INCORRECT_ENCODING,
|
||
|
|
XML_ERROR_UNCLOSED_CDATA_SECTION,
|
||
|
|
XML_ERROR_EXTERNAL_ENTITY_HANDLING,
|
||
|
|
XML_ERROR_NOT_STANDALONE,
|
||
|
|
XML_ERROR_UNEXPECTED_STATE,
|
||
|
|
XML_ERROR_ENTITY_DECLARED_IN_PE,
|
||
|
|
XML_ERROR_FEATURE_REQUIRES_XML_DTD,
|
||
|
|
XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
|
||
|
|
XML_ERROR_UNBOUND_PREFIX,
|
||
|
|
XML_ERROR_UNDECLARING_PREFIX,
|
||
|
|
XML_ERROR_INCOMPLETE_PE,
|
||
|
|
XML_ERROR_XML_DECL,
|
||
|
|
XML_ERROR_TEXT_DECL,
|
||
|
|
XML_ERROR_PUBLICID,
|
||
|
|
XML_ERROR_SUSPENDED,
|
||
|
|
XML_ERROR_NOT_SUSPENDED,
|
||
|
|
XML_ERROR_ABORTED,
|
||
|
|
XML_ERROR_FINISHED,
|
||
|
|
XML_ERROR_SUSPEND_PE
|
||
|
|
"""
|
||
|
|
error_names = [name.strip() for name in error_names.split(',')]
|
||
|
|
for i, name in enumerate(error_names[1:]):
|
||
|
|
setattr(errors, name, ErrorString(i+1))
|
||
|
|
|
||
|
|
_init_errors()
|
||
|
|
del _init_errors
|