Current File : //opt/cloudlinux/venv/lib/python3.11/site-packages/lxml/apihelpers.pxi
# Private/public helper functions for API functions
from lxml.includes cimport uri
cdef void displayNode(xmlNode* c_node, indent):
# to help with debugging
cdef xmlNode* c_child
try:
print indent * u' ', <long>c_node
c_child = c_node.children
while c_child is not NULL:
displayNode(c_child, indent + 1)
c_child = c_child.next
finally:
return # swallow any exceptions
cdef inline int _assertValidNode(_Element element) except -1:
assert element._c_node is not NULL, u"invalid Element proxy at %s" % id(element)
cdef inline int _assertValidDoc(_Document doc) except -1:
assert doc._c_doc is not NULL, u"invalid Document proxy at %s" % id(doc)
cdef _Document _documentOrRaise(object input):
u"""Call this to get the document of a _Document, _ElementTree or _Element
object, or to raise an exception if it can't be determined.
Should be used in all API functions for consistency.
"""
cdef _Document doc
if isinstance(input, _ElementTree):
if (<_ElementTree>input)._context_node is not None:
doc = (<_ElementTree>input)._context_node._doc
else:
doc = None
elif isinstance(input, _Element):
doc = (<_Element>input)._doc
elif isinstance(input, _Document):
doc = <_Document>input
else:
raise TypeError, f"Invalid input object: {python._fqtypename(input).decode('utf8')}"
if doc is None:
raise ValueError, f"Input object has no document: {python._fqtypename(input).decode('utf8')}"
_assertValidDoc(doc)
return doc
cdef _Element _rootNodeOrRaise(object input):
u"""Call this to get the root node of a _Document, _ElementTree or
_Element object, or to raise an exception if it can't be determined.
Should be used in all API functions for consistency.
"""
cdef _Element node
if isinstance(input, _ElementTree):
node = (<_ElementTree>input)._context_node
elif isinstance(input, _Element):
node = <_Element>input
elif isinstance(input, _Document):
node = (<_Document>input).getroot()
else:
raise TypeError, f"Invalid input object: {python._fqtypename(input).decode('utf8')}"
if (node is None or not node._c_node or
node._c_node.type != tree.XML_ELEMENT_NODE):
raise ValueError, f"Input object is not an XML element: {python._fqtypename(input).decode('utf8')}"
_assertValidNode(node)
return node
cdef bint _isAncestorOrSame(xmlNode* c_ancestor, xmlNode* c_node):
while c_node:
if c_node is c_ancestor:
return True
c_node = c_node.parent
return False
cdef _Element _makeElement(tag, xmlDoc* c_doc, _Document doc,
_BaseParser parser, text, tail, attrib, nsmap,
dict extra_attrs):
u"""Create a new element and initialize text content, namespaces and
attributes.
This helper function will reuse as much of the existing document as
possible:
If 'parser' is None, the parser will be inherited from 'doc' or the
default parser will be used.
If 'doc' is None, 'c_doc' is used to create a new _Document and the new
element is made its root node.
If 'c_doc' is also NULL, a new xmlDoc will be created.
"""
cdef xmlNode* c_node
if doc is not None:
c_doc = doc._c_doc
ns_utf, name_utf = _getNsTag(tag)
if parser is not None and parser._for_html:
_htmlTagValidOrRaise(name_utf)
if c_doc is NULL:
c_doc = _newHTMLDoc()
else:
_tagValidOrRaise(name_utf)
if c_doc is NULL:
c_doc = _newXMLDoc()
c_node = _createElement(c_doc, name_utf)
if c_node is NULL:
if doc is None and c_doc is not NULL:
tree.xmlFreeDoc(c_doc)
raise MemoryError()
try:
if doc is None:
tree.xmlDocSetRootElement(c_doc, c_node)
doc = _documentFactory(c_doc, parser)
if text is not None:
_setNodeText(c_node, text)
if tail is not None:
_setTailText(c_node, tail)
# add namespaces to node if necessary
_setNodeNamespaces(c_node, doc, ns_utf, nsmap)
_initNodeAttributes(c_node, doc, attrib, extra_attrs)
return _elementFactory(doc, c_node)
except:
# free allocated c_node/c_doc unless Python does it for us
if c_node.doc is not c_doc:
# node not yet in document => will not be freed by document
if tail is not None:
_removeText(c_node.next) # tail
tree.xmlFreeNode(c_node)
if doc is None:
# c_doc will not be freed by doc
tree.xmlFreeDoc(c_doc)
raise
cdef int _initNewElement(_Element element, bint is_html, name_utf, ns_utf,
_BaseParser parser, attrib, nsmap, dict extra_attrs) except -1:
u"""Initialise a new Element object.
This is used when users instantiate a Python Element subclass
directly, without it being mapped to an existing XML node.
"""
cdef xmlDoc* c_doc
cdef xmlNode* c_node
cdef _Document doc
if is_html:
_htmlTagValidOrRaise(name_utf)
c_doc = _newHTMLDoc()
else:
_tagValidOrRaise(name_utf)
c_doc = _newXMLDoc()
c_node = _createElement(c_doc, name_utf)
if c_node is NULL:
if c_doc is not NULL:
tree.xmlFreeDoc(c_doc)
raise MemoryError()
tree.xmlDocSetRootElement(c_doc, c_node)
doc = _documentFactory(c_doc, parser)
# add namespaces to node if necessary
_setNodeNamespaces(c_node, doc, ns_utf, nsmap)
_initNodeAttributes(c_node, doc, attrib, extra_attrs)
_registerProxy(element, doc, c_node)
element._init()
return 0
cdef _Element _makeSubElement(_Element parent, tag, text, tail,
attrib, nsmap, dict extra_attrs):
u"""Create a new child element and initialize text content, namespaces and
attributes.
"""
cdef xmlNode* c_node
cdef xmlDoc* c_doc
if parent is None or parent._doc is None:
return None
_assertValidNode(parent)
ns_utf, name_utf = _getNsTag(tag)
c_doc = parent._doc._c_doc
if parent._doc._parser is not None and parent._doc._parser._for_html:
_htmlTagValidOrRaise(name_utf)
else:
_tagValidOrRaise(name_utf)
c_node = _createElement(c_doc, name_utf)
if c_node is NULL:
raise MemoryError()
tree.xmlAddChild(parent._c_node, c_node)
try:
if text is not None:
_setNodeText(c_node, text)
if tail is not None:
_setTailText(c_node, tail)
# add namespaces to node if necessary
_setNodeNamespaces(c_node, parent._doc, ns_utf, nsmap)
_initNodeAttributes(c_node, parent._doc, attrib, extra_attrs)
return _elementFactory(parent._doc, c_node)
except:
# make sure we clean up in case of an error
_removeNode(parent._doc, c_node)
raise
cdef int _setNodeNamespaces(xmlNode* c_node, _Document doc,
object node_ns_utf, object nsmap) except -1:
u"""Lookup current namespace prefixes, then set namespace structure for
node (if 'node_ns_utf' was provided) and register new ns-prefix mappings.
'node_ns_utf' should only be passed for a newly created node.
"""
cdef xmlNs* c_ns
cdef list nsdefs
if nsmap:
for prefix, href in _iter_nsmap(nsmap):
href_utf = _utf8(href)
_uriValidOrRaise(href_utf)
c_href = _xcstr(href_utf)
if prefix is not None:
prefix_utf = _utf8(prefix)
_prefixValidOrRaise(prefix_utf)
c_prefix = _xcstr(prefix_utf)
else:
c_prefix = <const_xmlChar*>NULL
# add namespace with prefix if it is not already known
c_ns = tree.xmlSearchNs(doc._c_doc, c_node, c_prefix)
if c_ns is NULL or \
c_ns.href is NULL or \
tree.xmlStrcmp(c_ns.href, c_href) != 0:
c_ns = tree.xmlNewNs(c_node, c_href, c_prefix)
if href_utf == node_ns_utf:
tree.xmlSetNs(c_node, c_ns)
node_ns_utf = None
if node_ns_utf is not None:
_uriValidOrRaise(node_ns_utf)
doc._setNodeNs(c_node, _xcstr(node_ns_utf))
return 0
cdef dict _build_nsmap(xmlNode* c_node):
"""
Namespace prefix->URI mapping known in the context of this Element.
This includes all namespace declarations of the parents.
"""
cdef xmlNs* c_ns
nsmap = {}
while c_node is not NULL and c_node.type == tree.XML_ELEMENT_NODE:
c_ns = c_node.nsDef
while c_ns is not NULL:
if c_ns.prefix or c_ns.href:
prefix = funicodeOrNone(c_ns.prefix)
if prefix not in nsmap:
nsmap[prefix] = funicodeOrNone(c_ns.href)
c_ns = c_ns.next
c_node = c_node.parent
return nsmap
cdef _iter_nsmap(nsmap):
"""
Create a reproducibly ordered iterable from an nsmap mapping.
Tries to preserve an existing order and sorts if it assumes no order.
The difference to _iter_attrib() is that None doesn't sort with strings
in Py3.x.
"""
if python.PY_VERSION_HEX >= 0x03060000:
# dicts are insertion-ordered in Py3.6+ => keep the user provided order.
if isinstance(nsmap, dict):
return nsmap.items()
if len(nsmap) <= 1:
return nsmap.items()
# nsmap will usually be a plain unordered dict => avoid type checking overhead
if type(nsmap) is not dict and isinstance(nsmap, OrderedDict):
return nsmap.items() # keep existing order
if None not in nsmap:
return sorted(nsmap.items())
# Move the default namespace to the end. This makes sure libxml2
# prefers a prefix if the ns is defined redundantly on the same
# element. That way, users can work around a problem themselves
# where default namespace attributes on non-default namespaced
# elements serialise without prefix (i.e. into the non-default
# namespace).
default_ns = nsmap[None]
nsdefs = [(k, v) for k, v in nsmap.items() if k is not None]
nsdefs.sort()
nsdefs.append((None, default_ns))
return nsdefs
cdef _iter_attrib(attrib):
"""
Create a reproducibly ordered iterable from an attrib mapping.
Tries to preserve an existing order and sorts if it assumes no order.
"""
# dicts are insertion-ordered in Py3.6+ => keep the user provided order.
if python.PY_VERSION_HEX >= 0x03060000 and isinstance(attrib, dict) or (
isinstance(attrib, (_Attrib, OrderedDict))):
return attrib.items()
# assume it's an unordered mapping of some kind
return sorted(attrib.items())
cdef _initNodeAttributes(xmlNode* c_node, _Document doc, attrib, dict extra):
u"""Initialise the attributes of an element node.
"""
cdef bint is_html
cdef xmlNs* c_ns
if attrib is not None and not hasattr(attrib, u'items'):
raise TypeError, f"Invalid attribute dictionary: {python._fqtypename(attrib).decode('utf8')}"
if not attrib and not extra:
return # nothing to do
is_html = doc._parser._for_html
seen = set()
if extra:
if python.PY_VERSION_HEX >= 0x03060000:
for name, value in extra.items():
_addAttributeToNode(c_node, doc, is_html, name, value, seen)
else:
for name, value in sorted(extra.items()):
_addAttributeToNode(c_node, doc, is_html, name, value, seen)
if attrib:
for name, value in _iter_attrib(attrib):
_addAttributeToNode(c_node, doc, is_html, name, value, seen)
cdef int _addAttributeToNode(xmlNode* c_node, _Document doc, bint is_html,
name, value, set seen_tags) except -1:
ns_utf, name_utf = tag = _getNsTag(name)
if tag in seen_tags:
return 0
seen_tags.add(tag)
if not is_html:
_attributeValidOrRaise(name_utf)
value_utf = _utf8(value)
if ns_utf is None:
tree.xmlNewProp(c_node, _xcstr(name_utf), _xcstr(value_utf))
else:
_uriValidOrRaise(ns_utf)
c_ns = doc._findOrBuildNodeNs(c_node, _xcstr(ns_utf), NULL, 1)
tree.xmlNewNsProp(c_node, c_ns,
_xcstr(name_utf), _xcstr(value_utf))
return 0
ctypedef struct _ns_node_ref:
xmlNs* ns
xmlNode* node
cdef int _collectNsDefs(xmlNode* c_element, _ns_node_ref **_c_ns_list,
size_t *_c_ns_list_len, size_t *_c_ns_list_size) except -1:
c_ns_list = _c_ns_list[0]
cdef size_t c_ns_list_len = _c_ns_list_len[0]
cdef size_t c_ns_list_size = _c_ns_list_size[0]
c_nsdef = c_element.nsDef
while c_nsdef is not NULL:
if c_ns_list_len >= c_ns_list_size:
if c_ns_list is NULL:
c_ns_list_size = 20
else:
c_ns_list_size *= 2
c_nsref_ptr = <_ns_node_ref*> python.lxml_realloc(
c_ns_list, c_ns_list_size, sizeof(_ns_node_ref))
if c_nsref_ptr is NULL:
if c_ns_list is not NULL:
python.lxml_free(c_ns_list)
_c_ns_list[0] = NULL
raise MemoryError()
c_ns_list = c_nsref_ptr
c_ns_list[c_ns_list_len] = _ns_node_ref(c_nsdef, c_element)
c_ns_list_len += 1
c_nsdef = c_nsdef.next
_c_ns_list_size[0] = c_ns_list_size
_c_ns_list_len[0] = c_ns_list_len
_c_ns_list[0] = c_ns_list
cdef int _removeUnusedNamespaceDeclarations(xmlNode* c_element, set prefixes_to_keep) except -1:
u"""Remove any namespace declarations from a subtree that are not used by
any of its elements (or attributes).
If a 'prefixes_to_keep' is provided, it must be a set of prefixes.
Any corresponding namespace mappings will not be removed as part of the cleanup.
"""
cdef xmlNode* c_node
cdef _ns_node_ref* c_ns_list = NULL
cdef size_t c_ns_list_size = 0
cdef size_t c_ns_list_len = 0
cdef size_t i
if c_element.parent and c_element.parent.type == tree.XML_DOCUMENT_NODE:
# include declarations on the document node
_collectNsDefs(c_element.parent, &c_ns_list, &c_ns_list_len, &c_ns_list_size)
tree.BEGIN_FOR_EACH_ELEMENT_FROM(c_element, c_element, 1)
# collect all new namespace declarations into the ns list
if c_element.nsDef:
_collectNsDefs(c_element, &c_ns_list, &c_ns_list_len, &c_ns_list_size)
# remove all namespace declarations from the list that are referenced
if c_ns_list_len and c_element.type == tree.XML_ELEMENT_NODE:
c_node = c_element
while c_node and c_ns_list_len:
if c_node.ns:
for i in range(c_ns_list_len):
if c_node.ns is c_ns_list[i].ns:
c_ns_list_len -= 1
c_ns_list[i] = c_ns_list[c_ns_list_len]
#c_ns_list[c_ns_list_len] = _ns_node_ref(NULL, NULL)
break
if c_node is c_element:
# continue with attributes
c_node = <xmlNode*>c_element.properties
else:
c_node = c_node.next
tree.END_FOR_EACH_ELEMENT_FROM(c_element)
if c_ns_list is NULL:
return 0
# free all namespace declarations that remained in the list,
# except for those we should keep explicitly
cdef xmlNs* c_nsdef
for i in range(c_ns_list_len):
if prefixes_to_keep is not None:
if c_ns_list[i].ns.prefix and c_ns_list[i].ns.prefix in prefixes_to_keep:
continue
c_node = c_ns_list[i].node
c_nsdef = c_node.nsDef
if c_nsdef is c_ns_list[i].ns:
c_node.nsDef = c_node.nsDef.next
else:
while c_nsdef.next is not c_ns_list[i].ns:
c_nsdef = c_nsdef.next
c_nsdef.next = c_nsdef.next.next
tree.xmlFreeNs(c_ns_list[i].ns)
if c_ns_list is not NULL:
python.lxml_free(c_ns_list)
return 0
cdef xmlNs* _searchNsByHref(xmlNode* c_node, const_xmlChar* c_href, bint is_attribute):
u"""Search a namespace declaration that covers a node (element or
attribute).
For attributes, try to find a prefixed namespace declaration
instead of the default namespaces. This helps in supporting
round-trips for attributes on elements with a different namespace.
"""
cdef xmlNs* c_ns
cdef xmlNs* c_default_ns = NULL
cdef xmlNode* c_element
if c_href is NULL or c_node is NULL or c_node.type == tree.XML_ENTITY_REF_NODE:
return NULL
if tree.xmlStrcmp(c_href, tree.XML_XML_NAMESPACE) == 0:
# no special cases here, let libxml2 handle this
return tree.xmlSearchNsByHref(c_node.doc, c_node, c_href)
if c_node.type == tree.XML_ATTRIBUTE_NODE:
is_attribute = 1
while c_node is not NULL and c_node.type != tree.XML_ELEMENT_NODE:
c_node = c_node.parent
c_element = c_node
while c_node is not NULL:
if c_node.type == tree.XML_ELEMENT_NODE:
c_ns = c_node.nsDef
while c_ns is not NULL:
if c_ns.href is not NULL and tree.xmlStrcmp(c_href, c_ns.href) == 0:
if c_ns.prefix is NULL and is_attribute:
# for attributes, continue searching a named
# prefix, but keep the first default namespace
# declaration that we found
if c_default_ns is NULL:
c_default_ns = c_ns
elif tree.xmlSearchNs(
c_element.doc, c_element, c_ns.prefix) is c_ns:
# start node is in namespace scope => found!
return c_ns
c_ns = c_ns.next
if c_node is not c_element and c_node.ns is not NULL:
# optimise: the node may have the namespace itself
c_ns = c_node.ns
if c_ns.href is not NULL and tree.xmlStrcmp(c_href, c_ns.href) == 0:
if c_ns.prefix is NULL and is_attribute:
# for attributes, continue searching a named
# prefix, but keep the first default namespace
# declaration that we found
if c_default_ns is NULL:
c_default_ns = c_ns
elif tree.xmlSearchNs(
c_element.doc, c_element, c_ns.prefix) is c_ns:
# start node is in namespace scope => found!
return c_ns
c_node = c_node.parent
# nothing found => use a matching default namespace or fail
if c_default_ns is not NULL:
if tree.xmlSearchNs(c_element.doc, c_element, NULL) is c_default_ns:
return c_default_ns
return NULL
cdef int _replaceNodeByChildren(_Document doc, xmlNode* c_node) except -1:
# NOTE: this does not deallocate the node, just unlink it!
cdef xmlNode* c_parent
cdef xmlNode* c_child
if c_node.children is NULL:
tree.xmlUnlinkNode(c_node)
return 0
c_parent = c_node.parent
# fix parent links of children
c_child = c_node.children
while c_child is not NULL:
c_child.parent = c_parent
c_child = c_child.next
# fix namespace references of children if their parent's namespace
# declarations get lost
if c_node.nsDef is not NULL:
c_child = c_node.children
while c_child is not NULL:
moveNodeToDocument(doc, doc._c_doc, c_child)
c_child = c_child.next
# fix sibling links to/from child slice
if c_node.prev is NULL:
c_parent.children = c_node.children
else:
c_node.prev.next = c_node.children
c_node.children.prev = c_node.prev
if c_node.next is NULL:
c_parent.last = c_node.last
else:
c_node.next.prev = c_node.last
c_node.last.next = c_node.next
# unlink c_node
c_node.children = c_node.last = NULL
c_node.parent = c_node.next = c_node.prev = NULL
return 0
cdef object _attributeValue(xmlNode* c_element, xmlAttr* c_attrib_node):
c_href = _getNs(<xmlNode*>c_attrib_node)
value = tree.xmlGetNsProp(c_element, c_attrib_node.name, c_href)
try:
result = funicode(value)
finally:
tree.xmlFree(value)
return result
cdef object _attributeValueFromNsName(xmlNode* c_element,
const_xmlChar* c_href, const_xmlChar* c_name):
c_result = tree.xmlGetNsProp(c_element, c_name, c_href)
if c_result is NULL:
return None
try:
result = funicode(c_result)
finally:
tree.xmlFree(c_result)
return result
cdef object _getNodeAttributeValue(xmlNode* c_node, key, default):
ns, tag = _getNsTag(key)
c_href = <const_xmlChar*>NULL if ns is None else _xcstr(ns)
c_result = tree.xmlGetNsProp(c_node, _xcstr(tag), c_href)
if c_result is NULL:
# XXX free namespace that is not in use..?
return default
try:
result = funicode(c_result)
finally:
tree.xmlFree(c_result)
return result
cdef inline object _getAttributeValue(_Element element, key, default):
return _getNodeAttributeValue(element._c_node, key, default)
cdef int _setAttributeValue(_Element element, key, value) except -1:
cdef const_xmlChar* c_value
cdef xmlNs* c_ns
ns, tag = _getNsTag(key)
is_html = element._doc._parser._for_html
if not is_html:
_attributeValidOrRaise(tag)
c_tag = _xcstr(tag)
if value is None and is_html:
c_value = NULL
else:
if isinstance(value, QName):
value = _resolveQNameText(element, value)
else:
value = _utf8(value)
c_value = _xcstr(value)
if ns is None:
c_ns = NULL
else:
c_ns = element._doc._findOrBuildNodeNs(element._c_node, _xcstr(ns), NULL, 1)
tree.xmlSetNsProp(element._c_node, c_ns, c_tag, c_value)
return 0
cdef int _delAttribute(_Element element, key) except -1:
ns, tag = _getNsTag(key)
c_href = <const_xmlChar*>NULL if ns is None else _xcstr(ns)
if _delAttributeFromNsName(element._c_node, c_href, _xcstr(tag)):
raise KeyError, key
return 0
cdef int _delAttributeFromNsName(xmlNode* c_node, const_xmlChar* c_href, const_xmlChar* c_name):
c_attr = tree.xmlHasNsProp(c_node, c_name, c_href)
if c_attr is NULL:
# XXX free namespace that is not in use..?
return -1
tree.xmlRemoveProp(c_attr)
return 0
cdef list _collectAttributes(xmlNode* c_node, int collecttype):
u"""Collect all attributes of a node in a list. Depending on collecttype,
it collects either the name (1), the value (2) or the name-value tuples.
"""
cdef Py_ssize_t count
c_attr = c_node.properties
count = 0
while c_attr is not NULL:
if c_attr.type == tree.XML_ATTRIBUTE_NODE:
count += 1
c_attr = c_attr.next
if not count:
return []
attributes = [None] * count
c_attr = c_node.properties
count = 0
while c_attr is not NULL:
if c_attr.type == tree.XML_ATTRIBUTE_NODE:
if collecttype == 1:
item = _namespacedName(<xmlNode*>c_attr)
elif collecttype == 2:
item = _attributeValue(c_node, c_attr)
else:
item = (_namespacedName(<xmlNode*>c_attr),
_attributeValue(c_node, c_attr))
attributes[count] = item
count += 1
c_attr = c_attr.next
return attributes
cdef object __RE_XML_ENCODING = re.compile(
ur'^(<\?xml[^>]+)\s+encoding\s*=\s*["\'][^"\']*["\'](\s*\?>|)', re.U)
cdef object __REPLACE_XML_ENCODING = __RE_XML_ENCODING.sub
cdef object __HAS_XML_ENCODING = __RE_XML_ENCODING.match
cdef object _stripEncodingDeclaration(object xml_string):
# this is a hack to remove the XML encoding declaration from unicode
return __REPLACE_XML_ENCODING(ur'\g<1>\g<2>', xml_string)
cdef bint _hasEncodingDeclaration(object xml_string) except -1:
# check if a (unicode) string has an XML encoding declaration
return __HAS_XML_ENCODING(xml_string) is not None
cdef inline bint _hasText(xmlNode* c_node):
return c_node is not NULL and _textNodeOrSkip(c_node.children) is not NULL
cdef inline bint _hasTail(xmlNode* c_node):
return c_node is not NULL and _textNodeOrSkip(c_node.next) is not NULL
cdef inline bint _hasNonWhitespaceTail(xmlNode* c_node):
return _hasNonWhitespaceText(c_node, tail=True)
cdef bint _hasNonWhitespaceText(xmlNode* c_node, bint tail=False):
c_text_node = c_node and _textNodeOrSkip(c_node.next if tail else c_node.children)
if c_text_node is NULL:
return False
while c_text_node is not NULL:
if c_text_node.content[0] != c'\0' and not _collectText(c_text_node).isspace():
return True
c_text_node = _textNodeOrSkip(c_text_node.next)
return False
cdef _collectText(xmlNode* c_node):
u"""Collect all text nodes and return them as a unicode string.
Start collecting at c_node.
If there was no text to collect, return None
"""
cdef Py_ssize_t scount
cdef xmlChar* c_text
cdef xmlNode* c_node_cur
# check for multiple text nodes
scount = 0
c_text = NULL
c_node_cur = c_node = _textNodeOrSkip(c_node)
while c_node_cur is not NULL:
if c_node_cur.content[0] != c'\0':
c_text = c_node_cur.content
scount += 1
c_node_cur = _textNodeOrSkip(c_node_cur.next)
# handle two most common cases first
if c_text is NULL:
return '' if scount > 0 else None
if scount == 1:
return funicode(c_text)
# the rest is not performance critical anymore
result = b''
while c_node is not NULL:
result += <unsigned char*>c_node.content
c_node = _textNodeOrSkip(c_node.next)
return funicode(<const_xmlChar*><unsigned char*>result)
cdef void _removeText(xmlNode* c_node):
u"""Remove all text nodes.
Start removing at c_node.
"""
cdef xmlNode* c_next
c_node = _textNodeOrSkip(c_node)
while c_node is not NULL:
c_next = _textNodeOrSkip(c_node.next)
tree.xmlUnlinkNode(c_node)
tree.xmlFreeNode(c_node)
c_node = c_next
cdef xmlNode* _createTextNode(xmlDoc* doc, value) except NULL:
cdef xmlNode* c_text_node
if isinstance(value, CDATA):
c_text_node = tree.xmlNewCDataBlock(
doc, _xcstr((<CDATA>value)._utf8_data),
python.PyBytes_GET_SIZE((<CDATA>value)._utf8_data))
else:
text = _utf8(value)
c_text_node = tree.xmlNewDocText(doc, _xcstr(text))
if not c_text_node:
raise MemoryError()
return c_text_node
cdef int _setNodeText(xmlNode* c_node, value) except -1:
# remove all text nodes at the start first
_removeText(c_node.children)
if value is None:
return 0
# now add new text node with value at start
c_text_node = _createTextNode(c_node.doc, value)
if c_node.children is NULL:
tree.xmlAddChild(c_node, c_text_node)
else:
tree.xmlAddPrevSibling(c_node.children, c_text_node)
return 0
cdef int _setTailText(xmlNode* c_node, value) except -1:
# remove all text nodes at the start first
_removeText(c_node.next)
if value is None:
return 0
# now append new text node with value
c_text_node = _createTextNode(c_node.doc, value)
tree.xmlAddNextSibling(c_node, c_text_node)
return 0
cdef bytes _resolveQNameText(_Element element, value):
cdef xmlNs* c_ns
ns, tag = _getNsTag(value)
if ns is None:
return tag
else:
c_ns = element._doc._findOrBuildNodeNs(
element._c_node, _xcstr(ns), NULL, 0)
return python.PyBytes_FromFormat('%s:%s', c_ns.prefix, _cstr(tag))
cdef inline bint _hasChild(xmlNode* c_node):
return c_node is not NULL and _findChildForwards(c_node, 0) is not NULL
cdef inline Py_ssize_t _countElements(xmlNode* c_node):
u"Counts the elements within the following siblings and the node itself."
cdef Py_ssize_t count
count = 0
while c_node is not NULL:
if _isElement(c_node):
count += 1
c_node = c_node.next
return count
cdef int _findChildSlice(
slice sliceobject, xmlNode* c_parent,
xmlNode** c_start_node, Py_ssize_t* c_step, Py_ssize_t* c_length) except -1:
u"""Resolve a children slice.
Returns the start node, step size and the slice length in the
pointer arguments.
"""
cdef Py_ssize_t start = 0, stop = 0, childcount
childcount = _countElements(c_parent.children)
if childcount == 0:
c_start_node[0] = NULL
c_length[0] = 0
if sliceobject.step is None:
c_step[0] = 1
else:
python._PyEval_SliceIndex(sliceobject.step, c_step)
return 0
python.PySlice_GetIndicesEx(
sliceobject, childcount, &start, &stop, c_step, c_length)
if start > childcount / 2:
c_start_node[0] = _findChildBackwards(c_parent, childcount - start - 1)
else:
c_start_node[0] = _findChild(c_parent, start)
return 0
cdef bint _isFullSlice(slice sliceobject) except -1:
u"""Conservative guess if this slice is a full slice as in ``s[:]``.
"""
cdef Py_ssize_t step = 0
if sliceobject is None:
return 0
if sliceobject.start is None and \
sliceobject.stop is None:
if sliceobject.step is None:
return 1
python._PyEval_SliceIndex(sliceobject.step, &step)
if step == 1:
return 1
return 0
return 0
cdef _collectChildren(_Element element):
cdef xmlNode* c_node
cdef list result = []
c_node = element._c_node.children
if c_node is not NULL:
if not _isElement(c_node):
c_node = _nextElement(c_node)
while c_node is not NULL:
result.append(_elementFactory(element._doc, c_node))
c_node = _nextElement(c_node)
return result
cdef inline xmlNode* _findChild(xmlNode* c_node, Py_ssize_t index):
if index < 0:
return _findChildBackwards(c_node, -index - 1)
else:
return _findChildForwards(c_node, index)
cdef inline xmlNode* _findChildForwards(xmlNode* c_node, Py_ssize_t index):
u"""Return child element of c_node with index, or return NULL if not found.
"""
cdef xmlNode* c_child
cdef Py_ssize_t c
c_child = c_node.children
c = 0
while c_child is not NULL:
if _isElement(c_child):
if c == index:
return c_child
c += 1
c_child = c_child.next
return NULL
cdef inline xmlNode* _findChildBackwards(xmlNode* c_node, Py_ssize_t index):
u"""Return child element of c_node with index, or return NULL if not found.
Search from the end.
"""
cdef xmlNode* c_child
cdef Py_ssize_t c
c_child = c_node.last
c = 0
while c_child is not NULL:
if _isElement(c_child):
if c == index:
return c_child
c += 1
c_child = c_child.prev
return NULL
cdef inline xmlNode* _textNodeOrSkip(xmlNode* c_node) nogil:
u"""Return the node if it's a text node. Skip over ignorable nodes in a
series of text nodes. Return NULL if a non-ignorable node is found.
This is used to skip over XInclude nodes when collecting adjacent text
nodes.
"""
while c_node is not NULL:
if c_node.type == tree.XML_TEXT_NODE or \
c_node.type == tree.XML_CDATA_SECTION_NODE:
return c_node
elif c_node.type == tree.XML_XINCLUDE_START or \
c_node.type == tree.XML_XINCLUDE_END:
c_node = c_node.next
else:
return NULL
return NULL
cdef inline xmlNode* _nextElement(xmlNode* c_node):
u"""Given a node, find the next sibling that is an element.
"""
if c_node is NULL:
return NULL
c_node = c_node.next
while c_node is not NULL:
if _isElement(c_node):
return c_node
c_node = c_node.next
return NULL
cdef inline xmlNode* _previousElement(xmlNode* c_node):
u"""Given a node, find the next sibling that is an element.
"""
if c_node is NULL:
return NULL
c_node = c_node.prev
while c_node is not NULL:
if _isElement(c_node):
return c_node
c_node = c_node.prev
return NULL
cdef inline xmlNode* _parentElement(xmlNode* c_node):
u"Given a node, find the parent element."
if c_node is NULL or not _isElement(c_node):
return NULL
c_node = c_node.parent
if c_node is NULL or not _isElement(c_node):
return NULL
return c_node
cdef inline bint _tagMatches(xmlNode* c_node, const_xmlChar* c_href, const_xmlChar* c_name):
u"""Tests if the node matches namespace URI and tag name.
A node matches if it matches both c_href and c_name.
A node matches c_href if any of the following is true:
* c_href is NULL
* its namespace is NULL and c_href is the empty string
* its namespace string equals the c_href string
A node matches c_name if any of the following is true:
* c_name is NULL
* its name string equals the c_name string
"""
if c_node is NULL:
return 0
if c_node.type != tree.XML_ELEMENT_NODE:
# not an element, only succeed if we match everything
return c_name is NULL and c_href is NULL
if c_name is NULL:
if c_href is NULL:
# always match
return 1
else:
c_node_href = _getNs(c_node)
if c_node_href is NULL:
return c_href[0] == c'\0'
else:
return tree.xmlStrcmp(c_node_href, c_href) == 0
elif c_href is NULL:
if _getNs(c_node) is not NULL:
return 0
return c_node.name == c_name or tree.xmlStrcmp(c_node.name, c_name) == 0
elif c_node.name == c_name or tree.xmlStrcmp(c_node.name, c_name) == 0:
c_node_href = _getNs(c_node)
if c_node_href is NULL:
return c_href[0] == c'\0'
else:
return tree.xmlStrcmp(c_node_href, c_href) == 0
else:
return 0
cdef inline bint _tagMatchesExactly(xmlNode* c_node, qname* c_qname):
u"""Tests if the node matches namespace URI and tag name.
This differs from _tagMatches() in that it does not consider a
NULL value in qname.href a wildcard, and that it expects the c_name
to be taken from the doc dict, i.e. it only compares the names by
address.
A node matches if it matches both href and c_name of the qname.
A node matches c_href if any of the following is true:
* its namespace is NULL and c_href is the empty string
* its namespace string equals the c_href string
A node matches c_name if any of the following is true:
* c_name is NULL
* its name string points to the same address (!) as c_name
"""
return _nsTagMatchesExactly(_getNs(c_node), c_node.name, c_qname)
cdef inline bint _nsTagMatchesExactly(const_xmlChar* c_node_href,
const_xmlChar* c_node_name,
qname* c_qname):
u"""Tests if name and namespace URI match those of c_qname.
This differs from _tagMatches() in that it does not consider a
NULL value in qname.href a wildcard, and that it expects the c_name
to be taken from the doc dict, i.e. it only compares the names by
address.
A node matches if it matches both href and c_name of the qname.
A node matches c_href if any of the following is true:
* its namespace is NULL and c_href is the empty string
* its namespace string equals the c_href string
A node matches c_name if any of the following is true:
* c_name is NULL
* its name string points to the same address (!) as c_name
"""
cdef char* c_href
if c_qname.c_name is not NULL and c_qname.c_name is not c_node_name:
return 0
if c_qname.href is NULL:
return 1
c_href = python.__cstr(c_qname.href)
if c_href[0] == '\0':
return c_node_href is NULL or c_node_href[0] == '\0'
elif c_node_href is NULL:
return 0
else:
return tree.xmlStrcmp(<const_xmlChar*>c_href, c_node_href) == 0
cdef Py_ssize_t _mapTagsToQnameMatchArray(xmlDoc* c_doc, list ns_tags,
qname* c_ns_tags, bint force_into_dict) except -1:
u"""Map a sequence of (name, namespace) pairs to a qname array for efficient
matching with _tagMatchesExactly() above.
Note that each qname struct in the array owns its href byte string object
if it is not NULL.
"""
cdef Py_ssize_t count = 0, i
cdef bytes ns, tag
for ns, tag in ns_tags:
if tag is None:
c_tag = <const_xmlChar*>NULL
elif force_into_dict:
c_tag = tree.xmlDictLookup(c_doc.dict, _xcstr(tag), len(tag))
if c_tag is NULL:
# clean up before raising the error
for i in xrange(count):
cpython.ref.Py_XDECREF(c_ns_tags[i].href)
raise MemoryError()
else:
c_tag = tree.xmlDictExists(c_doc.dict, _xcstr(tag), len(tag))
if c_tag is NULL:
# not in the dict => not in the document
continue
c_ns_tags[count].c_name = c_tag
if ns is None:
c_ns_tags[count].href = NULL
else:
cpython.ref.Py_INCREF(ns) # keep an owned reference!
c_ns_tags[count].href = <python.PyObject*>ns
count += 1
return count
cdef int _removeNode(_Document doc, xmlNode* c_node) except -1:
u"""Unlink and free a node and subnodes if possible. Otherwise, make sure
it's self-contained.
"""
cdef xmlNode* c_next
c_next = c_node.next
tree.xmlUnlinkNode(c_node)
_moveTail(c_next, c_node)
if not attemptDeallocation(c_node):
# make namespaces absolute
moveNodeToDocument(doc, c_node.doc, c_node)
return 0
cdef int _removeSiblings(xmlNode* c_element, tree.xmlElementType node_type, bint with_tail) except -1:
cdef xmlNode* c_node
cdef xmlNode* c_next
c_node = c_element.next
while c_node is not NULL:
c_next = _nextElement(c_node)
if c_node.type == node_type:
if with_tail:
_removeText(c_node.next)
tree.xmlUnlinkNode(c_node)
attemptDeallocation(c_node)
c_node = c_next
c_node = c_element.prev
while c_node is not NULL:
c_next = _previousElement(c_node)
if c_node.type == node_type:
if with_tail:
_removeText(c_node.next)
tree.xmlUnlinkNode(c_node)
attemptDeallocation(c_node)
c_node = c_next
return 0
cdef void _moveTail(xmlNode* c_tail, xmlNode* c_target):
cdef xmlNode* c_next
# tail support: look for any text nodes trailing this node and
# move them too
c_tail = _textNodeOrSkip(c_tail)
while c_tail is not NULL:
c_next = _textNodeOrSkip(c_tail.next)
c_target = tree.xmlAddNextSibling(c_target, c_tail)
c_tail = c_next
cdef int _copyTail(xmlNode* c_tail, xmlNode* c_target) except -1:
cdef xmlNode* c_new_tail
# tail copying support: look for any text nodes trailing this node and
# copy it to the target node
c_tail = _textNodeOrSkip(c_tail)
while c_tail is not NULL:
if c_target.doc is not c_tail.doc:
c_new_tail = tree.xmlDocCopyNode(c_tail, c_target.doc, 0)
else:
c_new_tail = tree.xmlCopyNode(c_tail, 0)
if c_new_tail is NULL:
raise MemoryError()
c_target = tree.xmlAddNextSibling(c_target, c_new_tail)
c_tail = _textNodeOrSkip(c_tail.next)
return 0
cdef int _copyNonElementSiblings(xmlNode* c_node, xmlNode* c_target) except -1:
cdef xmlNode* c_copy
cdef xmlNode* c_sibling = c_node
while c_sibling.prev != NULL and \
(c_sibling.prev.type == tree.XML_PI_NODE or
c_sibling.prev.type == tree.XML_COMMENT_NODE or
c_sibling.prev.type == tree.XML_DTD_NODE):
c_sibling = c_sibling.prev
while c_sibling != c_node:
if c_sibling.type == tree.XML_DTD_NODE:
c_copy = <xmlNode*>_copyDtd(<tree.xmlDtd*>c_sibling)
if c_sibling == <xmlNode*>c_node.doc.intSubset:
c_target.doc.intSubset = <tree.xmlDtd*>c_copy
else: # c_sibling == c_node.doc.extSubset
c_target.doc.extSubset = <tree.xmlDtd*>c_copy
else:
c_copy = tree.xmlDocCopyNode(c_sibling, c_target.doc, 1)
if c_copy is NULL:
raise MemoryError()
tree.xmlAddPrevSibling(c_target, c_copy)
c_sibling = c_sibling.next
while c_sibling.next != NULL and \
(c_sibling.next.type == tree.XML_PI_NODE or
c_sibling.next.type == tree.XML_COMMENT_NODE):
c_sibling = c_sibling.next
c_copy = tree.xmlDocCopyNode(c_sibling, c_target.doc, 1)
if c_copy is NULL:
raise MemoryError()
tree.xmlAddNextSibling(c_target, c_copy)
cdef int _deleteSlice(_Document doc, xmlNode* c_node,
Py_ssize_t count, Py_ssize_t step) except -1:
u"""Delete slice, ``count`` items starting with ``c_node`` with a step
width of ``step``.
"""
cdef xmlNode* c_next
cdef Py_ssize_t c, i
cdef _node_to_node_function next_element
if c_node is NULL:
return 0
if step > 0:
next_element = _nextElement
else:
step = -step
next_element = _previousElement
# now start deleting nodes
c = 0
c_next = c_node
while c_node is not NULL and c < count:
for i in range(step):
c_next = next_element(c_next)
if c_next is NULL:
break
_removeNode(doc, c_node)
c += 1
c_node = c_next
return 0
cdef int _replaceSlice(_Element parent, xmlNode* c_node,
Py_ssize_t slicelength, Py_ssize_t step,
bint left_to_right, elements) except -1:
u"""Replace the slice of ``count`` elements starting at ``c_node`` with
positive step width ``step`` by the Elements in ``elements``. The
direction is given by the boolean argument ``left_to_right``.
``c_node`` may be NULL to indicate the end of the children list.
"""
cdef xmlNode* c_orig_neighbour
cdef xmlNode* c_next
cdef xmlDoc* c_source_doc
cdef _Element element
cdef Py_ssize_t seqlength, i, c
cdef _node_to_node_function next_element
assert step > 0
if left_to_right:
next_element = _nextElement
else:
next_element = _previousElement
if not isinstance(elements, (list, tuple)):
elements = list(elements)
if step != 1 or not left_to_right:
# *replacing* children stepwise with list => check size!
seqlength = len(elements)
if seqlength != slicelength:
raise ValueError, f"attempt to assign sequence of size {seqlength} " \
f"to extended slice of size {slicelength}"
if c_node is NULL:
# no children yet => add all elements straight away
if left_to_right:
for element in elements:
assert element is not None, u"Node must not be None"
_appendChild(parent, element)
else:
for element in elements:
assert element is not None, u"Node must not be None"
_prependChild(parent, element)
return 0
# remove the elements first as some might be re-added
if left_to_right:
# L->R, remember left neighbour
c_orig_neighbour = _previousElement(c_node)
else:
# R->L, remember right neighbour
c_orig_neighbour = _nextElement(c_node)
# We remove the original slice elements one by one. Since we hold
# a Python reference to all elements that we will insert, it is
# safe to let _removeNode() try (and fail) to free them even if
# the element itself or one of its descendents will be reinserted.
c = 0
c_next = c_node
while c_node is not NULL and c < slicelength:
for i in range(step):
c_next = next_element(c_next)
if c_next is NULL:
break
_removeNode(parent._doc, c_node)
c += 1
c_node = c_next
# make sure each element is inserted only once
elements = iter(elements)
# find the first node right of the new insertion point
if left_to_right:
if c_orig_neighbour is not NULL:
c_node = next_element(c_orig_neighbour)
else:
# before the first element
c_node = _findChildForwards(parent._c_node, 0)
elif c_orig_neighbour is NULL:
# at the end, but reversed stepping
# append one element and go to the next insertion point
for element in elements:
assert element is not None, u"Node must not be None"
_appendChild(parent, element)
c_node = element._c_node
if slicelength > 0:
slicelength -= 1
for i in range(1, step):
c_node = next_element(c_node)
if c_node is NULL:
break
break
else:
c_node = c_orig_neighbour
if left_to_right:
# adjust step size after removing slice as we are not stepping
# over the newly inserted elements
step -= 1
# now insert elements where we removed them
if c_node is not NULL:
for element in elements:
assert element is not None, u"Node must not be None"
_assertValidNode(element)
# move element and tail over
c_source_doc = element._c_node.doc
c_next = element._c_node.next
tree.xmlAddPrevSibling(c_node, element._c_node)
_moveTail(c_next, element._c_node)
# integrate element into new document
moveNodeToDocument(parent._doc, c_source_doc, element._c_node)
# stop at the end of the slice
if slicelength > 0:
slicelength -= 1
for i in range(step):
c_node = next_element(c_node)
if c_node is NULL:
break
if c_node is NULL:
break
else:
# everything inserted
return 0
# append the remaining elements at the respective end
if left_to_right:
for element in elements:
assert element is not None, u"Node must not be None"
_assertValidNode(element)
_appendChild(parent, element)
else:
for element in elements:
assert element is not None, u"Node must not be None"
_assertValidNode(element)
_prependChild(parent, element)
return 0
cdef int _linkChild(xmlNode* c_parent, xmlNode* c_node) except -1:
"""Adaptation of 'xmlAddChild()' that deep-fix the document links iteratively.
"""
assert _isElement(c_node)
c_node.parent = c_parent
if c_parent.children is NULL:
c_parent.children = c_parent.last = c_node
else:
c_node.prev = c_parent.last
c_parent.last.next = c_node
c_parent.last = c_node
_setTreeDoc(c_node, c_parent.doc)
return 0
cdef int _appendChild(_Element parent, _Element child) except -1:
u"""Append a new child to a parent element.
"""
c_node = child._c_node
c_source_doc = c_node.doc
# prevent cycles
if _isAncestorOrSame(c_node, parent._c_node):
raise ValueError("cannot append parent to itself")
# store possible text node
c_next = c_node.next
# move node itself
tree.xmlUnlinkNode(c_node)
# do not call xmlAddChild() here since it would deep-traverse the tree
_linkChild(parent._c_node, c_node)
_moveTail(c_next, c_node)
# uh oh, elements may be pointing to different doc when
# parent element has moved; change them too..
moveNodeToDocument(parent._doc, c_source_doc, c_node)
return 0
cdef int _prependChild(_Element parent, _Element child) except -1:
u"""Prepend a new child to a parent element.
"""
c_node = child._c_node
c_source_doc = c_node.doc
# prevent cycles
if _isAncestorOrSame(c_node, parent._c_node):
raise ValueError("cannot append parent to itself")
# store possible text node
c_next = c_node.next
# move node itself
c_child = _findChildForwards(parent._c_node, 0)
if c_child is NULL:
tree.xmlUnlinkNode(c_node)
# do not call xmlAddChild() here since it would deep-traverse the tree
_linkChild(parent._c_node, c_node)
else:
tree.xmlAddPrevSibling(c_child, c_node)
_moveTail(c_next, c_node)
# uh oh, elements may be pointing to different doc when
# parent element has moved; change them too..
moveNodeToDocument(parent._doc, c_source_doc, c_node)
return 0
cdef int _appendSibling(_Element element, _Element sibling) except -1:
u"""Add a new sibling behind an element.
"""
return _addSibling(element, sibling, as_next=True)
cdef int _prependSibling(_Element element, _Element sibling) except -1:
u"""Add a new sibling before an element.
"""
return _addSibling(element, sibling, as_next=False)
cdef int _addSibling(_Element element, _Element sibling, bint as_next) except -1:
c_node = sibling._c_node
c_source_doc = c_node.doc
# prevent cycles
if _isAncestorOrSame(c_node, element._c_node):
if element._c_node is c_node:
return 0 # nothing to do
raise ValueError("cannot add ancestor as sibling, please break cycle first")
# store possible text node
c_next = c_node.next
# move node itself
if as_next:
tree.xmlAddNextSibling(element._c_node, c_node)
else:
tree.xmlAddPrevSibling(element._c_node, c_node)
_moveTail(c_next, c_node)
# uh oh, elements may be pointing to different doc when
# parent element has moved; change them too..
moveNodeToDocument(element._doc, c_source_doc, c_node)
return 0
cdef inline bint isutf8(const_xmlChar* s):
cdef xmlChar c = s[0]
while c != c'\0':
if c & 0x80:
return True
s += 1
c = s[0]
return False
cdef bint isutf8l(const_xmlChar* s, size_t length):
"""
Search for non-ASCII characters in the string, knowing its length in advance.
"""
cdef unsigned int i
cdef unsigned long non_ascii_mask
cdef const unsigned long *lptr = <const unsigned long*> s
cdef const unsigned long *end = lptr + length // sizeof(unsigned long)
if length >= sizeof(non_ascii_mask):
# Build constant 0x80808080... mask (and let the C compiler fold it).
non_ascii_mask = 0
for i in range(sizeof(non_ascii_mask) // 2):
non_ascii_mask = (non_ascii_mask << 16) | 0x8080
# Advance to long-aligned character before we start reading longs.
while (<size_t>s) % sizeof(unsigned long) and s < <const_xmlChar *>end:
if s[0] & 0x80:
return True
s += 1
# Read one long at a time
lptr = <const unsigned long*> s
while lptr < end:
if lptr[0] & non_ascii_mask:
return True
lptr += 1
s = <const_xmlChar *>lptr
while s < (<const_xmlChar *>end + length % sizeof(unsigned long)):
if s[0] & 0x80:
return True
s += 1
return False
cdef int _is_valid_xml_ascii(bytes pystring):
"""Check if a string is XML ascii content."""
cdef signed char ch
# When ch is a *signed* char, non-ascii characters are negative integers
# and xmlIsChar_ch does not accept them.
for ch in pystring:
if not tree.xmlIsChar_ch(ch):
return 0
return 1
cdef bint _is_valid_xml_utf8(bytes pystring):
u"""Check if a string is like valid UTF-8 XML content."""
cdef const_xmlChar* s = _xcstr(pystring)
cdef const_xmlChar* c_end = s + len(pystring)
cdef unsigned long next3 = 0
if s < c_end - 2:
next3 = (s[0] << 8) | (s[1])
while s < c_end - 2:
next3 = 0x00ffffff & ((next3 << 8) | s[2])
if s[0] & 0x80:
# 0xefbfbe and 0xefbfbf are utf-8 encodings of
# forbidden characters \ufffe and \uffff
if next3 == 0x00efbfbe or next3 == 0x00efbfbf:
return 0
# 0xeda080 and 0xedbfbf are utf-8 encodings of
# \ud800 and \udfff. Anything between them (inclusive)
# is forbidden, because they are surrogate blocks in utf-16.
if 0x00eda080 <= next3 <= 0x00edbfbf:
return 0
elif not tree.xmlIsChar_ch(s[0]):
return 0 # invalid ascii char
s += 1
while s < c_end:
if not s[0] & 0x80 and not tree.xmlIsChar_ch(s[0]):
return 0 # invalid ascii char
s += 1
return 1
cdef inline object funicodeOrNone(const_xmlChar* s):
return funicode(s) if s is not NULL else None
cdef inline object funicodeOrEmpty(const_xmlChar* s):
return funicode(s) if s is not NULL else ''
cdef object funicode(const_xmlChar* s):
cdef Py_ssize_t slen
cdef const_xmlChar* spos
cdef bint is_non_ascii
if python.LXML_UNICODE_STRINGS:
return s.decode('UTF-8')
spos = s
is_non_ascii = 0
while spos[0] != c'\0':
if spos[0] & 0x80:
is_non_ascii = 1
break
spos += 1
slen = spos - s
if spos[0] != c'\0':
slen += cstring_h.strlen(<const char*> spos)
if is_non_ascii:
return s[:slen].decode('UTF-8')
return <bytes>s[:slen]
cdef bytes _utf8(object s):
"""Test if a string is valid user input and encode it to UTF-8.
Reject all bytes/unicode input that contains non-XML characters.
Reject all bytes input that contains non-ASCII characters.
"""
cdef int valid
cdef bytes utf8_string
if python.IS_PYTHON2 and type(s) is bytes:
utf8_string = <bytes>s
valid = _is_valid_xml_ascii(utf8_string)
elif isinstance(s, unicode):
utf8_string = (<unicode>s).encode('utf8')
valid = _is_valid_xml_utf8(utf8_string)
elif isinstance(s, (bytes, bytearray)):
utf8_string = bytes(s)
valid = _is_valid_xml_ascii(utf8_string)
else:
raise TypeError("Argument must be bytes or unicode, got '%.200s'" % type(s).__name__)
if not valid:
raise ValueError(
"All strings must be XML compatible: Unicode or ASCII, no NULL bytes or control characters")
return utf8_string
cdef bytes _utf8orNone(object s):
return _utf8(s) if s is not None else None
cdef strrepr(s):
"""Build a representation of strings which we can use in __repr__
methods, e.g. _Element.__repr__().
"""
return s.encode('unicode-escape') if python.IS_PYTHON2 else s
cdef enum:
NO_FILE_PATH = 0
ABS_UNIX_FILE_PATH = 1
ABS_WIN_FILE_PATH = 2
REL_FILE_PATH = 3
cdef bint _isFilePath(const_xmlChar* c_path):
u"simple heuristic to see if a path is a filename"
cdef xmlChar c
# test if it looks like an absolute Unix path or a Windows network path
if c_path[0] == c'/':
return ABS_UNIX_FILE_PATH
# test if it looks like an absolute Windows path or URL
if c'a' <= c_path[0] <= c'z' or c'A' <= c_path[0] <= c'Z':
c_path += 1
if c_path[0] == c':' and c_path[1] in b'\0\\':
return ABS_WIN_FILE_PATH # C: or C:\...
# test if it looks like a URL with scheme://
while c'a' <= c_path[0] <= c'z' or c'A' <= c_path[0] <= c'Z':
c_path += 1
if c_path[0] == c':' and c_path[1] == c'/' and c_path[2] == c'/':
return NO_FILE_PATH
# assume it's a relative path
return REL_FILE_PATH
cdef object _NO_FSPATH = object()
cdef object _getFSPathOrObject(object obj):
"""
Get the __fspath__ attribute of an object if it exists.
Otherwise, the original object is returned.
"""
if _isString(obj):
return obj
if python.PY_VERSION_HEX >= 0x03060000:
try:
return python.PY_FSPath(obj)
except TypeError:
return obj
fspath = getattr(obj, '__fspath__', _NO_FSPATH)
if fspath is not _NO_FSPATH and callable(fspath):
return fspath()
return obj
cdef object _encodeFilename(object filename):
u"""Make sure a filename is 8-bit encoded (or None).
"""
if filename is None:
return None
elif isinstance(filename, bytes):
return filename
elif isinstance(filename, unicode):
filename8 = (<unicode>filename).encode('utf8')
if _isFilePath(<unsigned char*>filename8):
try:
return python.PyUnicode_AsEncodedString(
filename, _C_FILENAME_ENCODING, NULL)
except UnicodeEncodeError:
pass
return filename8
else:
raise TypeError("Argument must be string or unicode.")
cdef object _decodeFilename(const_xmlChar* c_path):
u"""Make the filename a unicode string if we are in Py3.
"""
return _decodeFilenameWithLength(c_path, tree.xmlStrlen(c_path))
cdef object _decodeFilenameWithLength(const_xmlChar* c_path, size_t c_len):
u"""Make the filename a unicode string if we are in Py3.
"""
if _isFilePath(c_path):
try:
return python.PyUnicode_Decode(
<const_char*>c_path, c_len, _C_FILENAME_ENCODING, NULL)
except UnicodeDecodeError:
pass
try:
return (<unsigned char*>c_path)[:c_len].decode('UTF-8')
except UnicodeDecodeError:
# this is a stupid fallback, but it might still work...
return (<unsigned char*>c_path)[:c_len].decode('latin-1', 'replace')
cdef object _encodeFilenameUTF8(object filename):
u"""Recode filename as UTF-8. Tries ASCII, local filesystem encoding and
UTF-8 as source encoding.
"""
cdef char* c_filename
if filename is None:
return None
elif isinstance(filename, bytes):
if not isutf8l(<bytes>filename, len(<bytes>filename)):
# plain ASCII!
return filename
c_filename = _cstr(<bytes>filename)
try:
# try to decode with default encoding
filename = python.PyUnicode_Decode(
c_filename, len(<bytes>filename),
_C_FILENAME_ENCODING, NULL)
except UnicodeDecodeError as decode_exc:
try:
# try if it's proper UTF-8
(<bytes>filename).decode('utf8')
return filename
except UnicodeDecodeError:
raise decode_exc # otherwise re-raise original exception
if isinstance(filename, unicode):
return (<unicode>filename).encode('utf8')
else:
raise TypeError("Argument must be string or unicode.")
cdef tuple _getNsTag(tag):
u"""Given a tag, find namespace URI and tag name.
Return None for NS uri if no namespace URI provided.
"""
return __getNsTag(tag, 0)
cdef tuple _getNsTagWithEmptyNs(tag):
u"""Given a tag, find namespace URI and tag name. Return None for NS uri
if no namespace URI provided, or the empty string if namespace
part is '{}'.
"""
return __getNsTag(tag, 1)
cdef tuple __getNsTag(tag, bint empty_ns):
cdef char* c_tag
cdef char* c_ns_end
cdef Py_ssize_t taglen
cdef Py_ssize_t nslen
cdef bytes ns = None
# _isString() is much faster than isinstance()
if not _isString(tag) and isinstance(tag, QName):
tag = (<QName>tag).text
tag = _utf8(tag)
c_tag = _cstr(tag)
if c_tag[0] == c'{':
c_tag += 1
c_ns_end = cstring_h.strchr(c_tag, c'}')
if c_ns_end is NULL:
raise ValueError, u"Invalid tag name"
nslen = c_ns_end - c_tag
taglen = python.PyBytes_GET_SIZE(tag) - nslen - 2
if taglen == 0:
raise ValueError, u"Empty tag name"
if nslen > 0:
ns = <bytes>c_tag[:nslen]
elif empty_ns:
ns = b''
tag = <bytes>c_ns_end[1:taglen+1]
elif python.PyBytes_GET_SIZE(tag) == 0:
raise ValueError, u"Empty tag name"
return ns, tag
cdef inline int _pyXmlNameIsValid(name_utf8):
return _xmlNameIsValid(_xcstr(name_utf8)) and b':' not in name_utf8
cdef inline int _pyHtmlNameIsValid(name_utf8):
return _htmlNameIsValid(_xcstr(name_utf8))
cdef inline int _xmlNameIsValid(const_xmlChar* c_name):
return tree.xmlValidateNameValue(c_name)
cdef int _htmlNameIsValid(const_xmlChar* c_name):
if c_name is NULL or c_name[0] == c'\0':
return 0
while c_name[0] != c'\0':
if c_name[0] in b'&<>/"\'\t\n\x0B\x0C\r ':
return 0
c_name += 1
return 1
cdef bint _characterReferenceIsValid(const_xmlChar* c_name):
cdef bint is_hex
if c_name[0] == c'x':
c_name += 1
is_hex = 1
else:
is_hex = 0
if c_name[0] == c'\0':
return 0
while c_name[0] != c'\0':
if c_name[0] < c'0' or c_name[0] > c'9':
if not is_hex:
return 0
if not (c'a' <= c_name[0] <= c'f'):
if not (c'A' <= c_name[0] <= c'F'):
return 0
c_name += 1
return 1
cdef int _tagValidOrRaise(tag_utf) except -1:
if not _pyXmlNameIsValid(tag_utf):
raise ValueError(f"Invalid tag name {(<bytes>tag_utf).decode('utf8')!r}")
return 0
cdef int _htmlTagValidOrRaise(tag_utf) except -1:
if not _pyHtmlNameIsValid(tag_utf):
raise ValueError(f"Invalid HTML tag name {(<bytes>tag_utf).decode('utf8')!r}")
return 0
cdef int _attributeValidOrRaise(name_utf) except -1:
if not _pyXmlNameIsValid(name_utf):
raise ValueError(f"Invalid attribute name {(<bytes>name_utf).decode('utf8')!r}")
return 0
cdef int _prefixValidOrRaise(tag_utf) except -1:
if not _pyXmlNameIsValid(tag_utf):
raise ValueError(f"Invalid namespace prefix {(<bytes>tag_utf).decode('utf8')!r}")
return 0
cdef int _uriValidOrRaise(uri_utf) except -1:
cdef uri.xmlURI* c_uri = uri.xmlParseURI(_cstr(uri_utf))
if c_uri is NULL:
raise ValueError(f"Invalid namespace URI {(<bytes>uri_utf).decode('utf8')!r}")
uri.xmlFreeURI(c_uri)
return 0
cdef inline object _namespacedName(xmlNode* c_node):
return _namespacedNameFromNsName(_getNs(c_node), c_node.name)
cdef object _namespacedNameFromNsName(const_xmlChar* href, const_xmlChar* name):
if href is NULL:
return funicode(name)
elif not python.IS_PYPY and (python.LXML_UNICODE_STRINGS or isutf8(name) or isutf8(href)):
return python.PyUnicode_FromFormat("{%s}%s", href, name)
else:
s = python.PyBytes_FromFormat("{%s}%s", href, name)
if python.IS_PYPY and (python.LXML_UNICODE_STRINGS or isutf8l(s, len(s))):
return (<bytes>s).decode('utf8')
else:
return s
cdef _getFilenameForFile(source):
u"""Given a Python File or Gzip object, give filename back.
Returns None if not a file object.
"""
# urllib2 provides a geturl() method
try:
return source.geturl()
except:
pass
# file instances have a name attribute
try:
filename = source.name
if _isString(filename):
return os_path_abspath(filename)
except:
pass
# gzip file instances have a filename attribute (before Py3k)
try:
filename = source.filename
if _isString(filename):
return os_path_abspath(filename)
except:
pass
# can't determine filename
return None
Mini Shell