File size: 6,326 Bytes
4ba564c |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 |
# Parser target context (ET target interface)
cdef object inspect_getargspec
try:
from inspect import getfullargspec as inspect_getargspec
except ImportError:
from inspect import getargspec as inspect_getargspec
class _TargetParserResult(Exception):
# Admittedly, this is somewhat ugly, but it's the easiest way
# to push the Python level parser result through the parser
# machinery towards the API level functions
def __init__(self, result):
self.result = result
@cython.final
@cython.internal
cdef class _PythonSaxParserTarget(_SaxParserTarget):
cdef object _target_start
cdef object _target_end
cdef object _target_data
cdef object _target_start_ns
cdef object _target_end_ns
cdef object _target_doctype
cdef object _target_pi
cdef object _target_comment
cdef bint _start_takes_nsmap
def __cinit__(self, target):
cdef int event_filter
event_filter = 0
self._start_takes_nsmap = 0
try:
self._target_start = target.start
if self._target_start is not None:
event_filter |= SAX_EVENT_START
except AttributeError:
pass
else:
try:
arguments = inspect_getargspec(self._target_start)
if len(arguments[0]) > 3 or arguments[1] is not None:
self._start_takes_nsmap = 1
except TypeError:
pass
try:
self._target_end = target.end
if self._target_end is not None:
event_filter |= SAX_EVENT_END
except AttributeError:
pass
try:
self._target_start_ns = target.start_ns
if self._target_start_ns is not None:
event_filter |= SAX_EVENT_START_NS
except AttributeError:
pass
try:
self._target_end_ns = target.end_ns
if self._target_end_ns is not None:
event_filter |= SAX_EVENT_END_NS
except AttributeError:
pass
try:
self._target_data = target.data
if self._target_data is not None:
event_filter |= SAX_EVENT_DATA
except AttributeError:
pass
try:
self._target_doctype = target.doctype
if self._target_doctype is not None:
event_filter |= SAX_EVENT_DOCTYPE
except AttributeError:
pass
try:
self._target_pi = target.pi
if self._target_pi is not None:
event_filter |= SAX_EVENT_PI
except AttributeError:
pass
try:
self._target_comment = target.comment
if self._target_comment is not None:
event_filter |= SAX_EVENT_COMMENT
except AttributeError:
pass
self._sax_event_filter = event_filter
cdef _handleSaxStart(self, tag, attrib, nsmap):
if self._start_takes_nsmap:
return self._target_start(tag, attrib, nsmap)
else:
return self._target_start(tag, attrib)
cdef _handleSaxEnd(self, tag):
return self._target_end(tag)
cdef _handleSaxStartNs(self, prefix, uri):
return self._target_start_ns(prefix, uri)
cdef _handleSaxEndNs(self, prefix):
return self._target_end_ns(prefix)
cdef int _handleSaxData(self, data) except -1:
self._target_data(data)
cdef int _handleSaxDoctype(self, root_tag, public_id, system_id) except -1:
self._target_doctype(root_tag, public_id, system_id)
cdef _handleSaxPi(self, target, data):
return self._target_pi(target, data)
cdef _handleSaxComment(self, comment):
return self._target_comment(comment)
@cython.final
@cython.internal
@cython.no_gc_clear # Required because parent class uses it - Cython bug.
cdef class _TargetParserContext(_SaxParserContext):
"""This class maps SAX2 events to the ET parser target interface.
"""
cdef object _python_target
cdef int _setTarget(self, target) except -1:
self._python_target = target
if not isinstance(target, _SaxParserTarget) or \
hasattr(target, '__dict__'):
target = _PythonSaxParserTarget(target)
self._setSaxParserTarget(target)
return 0
cdef _ParserContext _copy(self):
cdef _TargetParserContext context
context = _ParserContext._copy(self)
context._setTarget(self._python_target)
return context
cdef void _cleanupTargetParserContext(self, xmlDoc* result) noexcept:
if self._c_ctxt.myDoc is not NULL:
if self._c_ctxt.myDoc is not result and \
self._c_ctxt.myDoc._private is NULL:
# no _Document proxy => orphen
tree.xmlFreeDoc(self._c_ctxt.myDoc)
self._c_ctxt.myDoc = NULL
cdef object _handleParseResult(self, _BaseParser parser, xmlDoc* result,
filename):
cdef bint recover
recover = parser._parse_options & xmlparser.XML_PARSE_RECOVER
try:
if self._has_raised():
self._cleanupTargetParserContext(result)
self._raise_if_stored()
if not self._c_ctxt.wellFormed and not recover:
_raiseParseError(self._c_ctxt, filename, self._error_log)
except:
self._python_target.close()
raise
return self._python_target.close()
cdef xmlDoc* _handleParseResultDoc(self, _BaseParser parser,
xmlDoc* result, filename) except NULL:
cdef bint recover
recover = parser._parse_options & xmlparser.XML_PARSE_RECOVER
if result is not NULL and result._private is NULL:
# no _Document proxy => orphen
tree.xmlFreeDoc(result)
try:
self._cleanupTargetParserContext(result)
self._raise_if_stored()
if not self._c_ctxt.wellFormed and not recover:
_raiseParseError(self._c_ctxt, filename, self._error_log)
except:
self._python_target.close()
raise
parse_result = self._python_target.close()
raise _TargetParserResult(parse_result)
|