rorapp/fotobox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added completly new version for haslach 2025

Browse Source
This commit is contained in:
fotobox
2025-03-17 03:47:13 +01:00
parent 152832515c
commit 769ab91da8
2333 changed files with 409208 additions and 341 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
.venv/lib/python3.7/site-packages/lxml/includes/__init__.pxd Normal file
View File

0
.venv/lib/python3.7/site-packages/lxml/includes/__init__.py Normal file
View File

BIN
.venv/lib/python3.7/site-packages/lxml/includes/__pycache__/__init__.cpython-37.pyc Normal file
View File

Binary file not shown.

26
.venv/lib/python3.7/site-packages/lxml/includes/c14n.pxd Normal file
View File

@@ -0,0 +1,26 @@
from lxml.includes.tree cimport xmlDoc, xmlOutputBuffer, xmlChar
from lxml.includes.xpath cimport xmlNodeSet
cdef extern from "libxml/c14n.h":
cdef int xmlC14NDocDumpMemory(xmlDoc* doc,
xmlNodeSet* nodes,
int exclusive,
xmlChar** inclusive_ns_prefixes,
int with_comments,
xmlChar** doc_txt_ptr) nogil
cdef int xmlC14NDocSave(xmlDoc* doc,
xmlNodeSet* nodes,
int exclusive,
xmlChar** inclusive_ns_prefixes,
int with_comments,
char* filename,
int compression) nogil
cdef int xmlC14NDocSaveTo(xmlDoc* doc,
xmlNodeSet* nodes,
int exclusive,
xmlChar** inclusive_ns_prefixes,
int with_comments,
xmlOutputBuffer* buffer) nogil

3
.venv/lib/python3.7/site-packages/lxml/includes/config.pxd Normal file
View File

@@ -0,0 +1,3 @@
cdef extern from "etree_defs.h":
cdef bint ENABLE_THREADING
cdef bint ENABLE_SCHEMATRON

18
.venv/lib/python3.7/site-packages/lxml/includes/dtdvalid.pxd Normal file
View File

@@ -0,0 +1,18 @@
from lxml.includes cimport tree
from lxml.includes.tree cimport xmlDoc, xmlDtd
cdef extern from "libxml/valid.h" nogil:
ctypedef void (*xmlValidityErrorFunc)(void * ctx, const char * msg, ...)
ctypedef void (*xmlValidityWarningFunc)(void * ctx, const char * msg, ...)
ctypedef struct xmlValidCtxt:
void *userData
xmlValidityErrorFunc error
xmlValidityWarningFunc warning
cdef xmlValidCtxt* xmlNewValidCtxt()
cdef void xmlFreeValidCtxt(xmlValidCtxt* cur)
cdef int xmlValidateDtd(xmlValidCtxt* ctxt, xmlDoc* doc, xmlDtd* dtd)
cdef tree.xmlElement* xmlGetDtdElementDesc(
xmlDtd* dtd, tree.const_xmlChar* name)

427
.venv/lib/python3.7/site-packages/lxml/includes/etree_defs.h Normal file
View File

@@ -0,0 +1,427 @@
#ifndef HAS_ETREE_DEFS_H
#define HAS_ETREE_DEFS_H
/* quick check for Python/libxml2/libxslt devel setup */
#include "Python.h"
#ifndef PY_VERSION_HEX
# error the development package of Python (header files etc.) is not installed correctly
#else
# if PY_VERSION_HEX < 0x02070000 || PY_MAJOR_VERSION >= 3 && PY_VERSION_HEX < 0x03050000
# error this version of lxml requires Python 2.7, 3.5 or later
# endif
#endif
#include "libxml/xmlversion.h"
#ifndef LIBXML_VERSION
# error the development package of libxml2 (header files etc.) is not installed correctly
#else
#if LIBXML_VERSION < 20700
# error minimum required version of libxml2 is 2.7.0
#endif
#endif
#include "libxslt/xsltconfig.h"
#ifndef LIBXSLT_VERSION
# error the development package of libxslt (header files etc.) is not installed correctly
#else
#if LIBXSLT_VERSION < 10123
# error minimum required version of libxslt is 1.1.23
#endif
#endif
/* v_arg functions */
#define va_int(ap) va_arg(ap, int)
#define va_charptr(ap) va_arg(ap, char *)
#ifdef PYPY_VERSION
# define IS_PYPY 1
#else
# define IS_PYPY 0
#endif
#if PY_MAJOR_VERSION >= 3
# define IS_PYTHON2 0 /* prefer for special casing Python 2.x */
# define IS_PYTHON3 1 /* avoid */
#else
# define IS_PYTHON2 1
# define IS_PYTHON3 0
#endif
#if IS_PYTHON2
#ifndef LXML_UNICODE_STRINGS
#define LXML_UNICODE_STRINGS 0
#endif
#else
#undef LXML_UNICODE_STRINGS
#define LXML_UNICODE_STRINGS 1
#endif
#if !IS_PYPY
# define PyWeakref_LockObject(obj) (NULL)
#endif
/* Threading is not currently supported by PyPy */
#if IS_PYPY
# ifndef WITHOUT_THREADING
# define WITHOUT_THREADING
# endif
#endif
#if IS_PYPY
# undef PyFile_AsFile
# define PyFile_AsFile(o) (NULL)
# undef PyByteArray_Check
# define PyByteArray_Check(o) (0)
#elif !IS_PYTHON2
/* Python 3+ doesn't have PyFile_*() anymore */
# define PyFile_AsFile(o) (NULL)
#endif
#if IS_PYPY
# ifndef PyUnicode_FromFormat
# define PyUnicode_FromFormat PyString_FromFormat
# endif
# if !IS_PYTHON2 && !defined(PyBytes_FromFormat)
# ifdef PyString_FromFormat
# define PyBytes_FromFormat PyString_FromFormat
# else
#include <stdarg.h>
static PyObject* PyBytes_FromFormat(const char* format, ...) {
PyObject *string;
va_list vargs;
#ifdef HAVE_STDARG_PROTOTYPES
va_start(vargs, format);
#else
va_start(vargs);
#endif
string = PyUnicode_FromFormatV(format, vargs);
va_end(vargs);
if (string && PyUnicode_Check(string)) {
PyObject *bstring = PyUnicode_AsUTF8String(string);
Py_DECREF(string);
string = bstring;
}
if (string && !PyBytes_CheckExact(string)) {
Py_DECREF(string);
string = NULL;
PyErr_SetString(PyExc_TypeError, "String formatting and encoding failed to return bytes object");
}
return string;
}
# endif
# endif
#endif
/* PySlice_GetIndicesEx() has wrong signature in Py<=3.1 */
#if PY_VERSION_HEX >= 0x03020000
# define _lx_PySlice_GetIndicesEx(o, l, b, e, s, sl) PySlice_GetIndicesEx(o, l, b, e, s, sl)
#else
# define _lx_PySlice_GetIndicesEx(o, l, b, e, s, sl) PySlice_GetIndicesEx(((PySliceObject*)o), l, b, e, s, sl)
#endif
#if PY_VERSION_HEX >= 0x030B00A1
/* Python 3.12 doesn't have wstr Unicode strings any more. */
#undef PyUnicode_GET_DATA_SIZE
#define PyUnicode_GET_DATA_SIZE(ustr) (0)
#undef PyUnicode_AS_DATA
#define PyUnicode_AS_DATA(ustr) (NULL)
#undef PyUnicode_IS_READY
#define PyUnicode_IS_READY(ustr) (1)
#endif
#ifdef WITHOUT_THREADING
# undef PyEval_SaveThread
# define PyEval_SaveThread() (NULL)
# undef PyEval_RestoreThread
# define PyEval_RestoreThread(state) if (state); else {}
# undef PyGILState_Ensure
# define PyGILState_Ensure() (PyGILState_UNLOCKED)
# undef PyGILState_Release
# define PyGILState_Release(state) if (state); else {}
# undef Py_UNBLOCK_THREADS
# define Py_UNBLOCK_THREADS _save = NULL;
# undef Py_BLOCK_THREADS
# define Py_BLOCK_THREADS if (_save); else {}
#endif
#ifdef WITHOUT_THREADING
# define ENABLE_THREADING 0
#else
# define ENABLE_THREADING 1
#endif
#if LIBXML_VERSION < 20704
/* FIXME: hack to make new error reporting compile in old libxml2 versions */
# define xmlStructuredErrorContext NULL
# define xmlXIncludeProcessTreeFlagsData(n,o,d) xmlXIncludeProcessTreeFlags(n,o)
#endif
/* schematron was added in libxml2 2.6.21 */
#ifdef LIBXML_SCHEMATRON_ENABLED
# define ENABLE_SCHEMATRON 1
#else
# define ENABLE_SCHEMATRON 0
# define XML_SCHEMATRON_OUT_QUIET 0
# define XML_SCHEMATRON_OUT_XML 0
# define XML_SCHEMATRON_OUT_ERROR 0
typedef void xmlSchematron;
typedef void xmlSchematronParserCtxt;
typedef void xmlSchematronValidCtxt;
# define xmlSchematronNewDocParserCtxt(doc) NULL
# define xmlSchematronNewParserCtxt(file) NULL
# define xmlSchematronParse(ctxt) NULL
# define xmlSchematronFreeParserCtxt(ctxt)
# define xmlSchematronFree(schema)
# define xmlSchematronNewValidCtxt(schema, options) NULL
# define xmlSchematronValidateDoc(ctxt, doc) 0
# define xmlSchematronFreeValidCtxt(ctxt)
# define xmlSchematronSetValidStructuredErrors(ctxt, errorfunc, data)
#endif
#if LIBXML_VERSION < 20708
# define HTML_PARSE_NODEFDTD 4
#endif
#if LIBXML_VERSION < 20900
# define XML_PARSE_BIG_LINES 4194304
#endif
#include "libxml/tree.h"
#ifndef LIBXML2_NEW_BUFFER
typedef xmlBuffer xmlBuf;
# define xmlBufContent(buf) xmlBufferContent(buf)
# define xmlBufUse(buf) xmlBufferLength(buf)
#endif
/* libexslt 1.1.25+ support EXSLT functions in XPath */
#if LIBXSLT_VERSION < 10125
#define exsltDateXpathCtxtRegister(ctxt, prefix)
#define exsltSetsXpathCtxtRegister(ctxt, prefix)
#define exsltMathXpathCtxtRegister(ctxt, prefix)
#define exsltStrXpathCtxtRegister(ctxt, prefix)
#endif
#define LXML_GET_XSLT_ENCODING(result_var, style) XSLT_GET_IMPORT_PTR(result_var, style, encoding)
/* work around MSDEV 6.0 */
#if (_MSC_VER == 1200) && (WINVER < 0x0500)
long _ftol( double ); //defined by VC6 C libs
long _ftol2( double dblSource ) { return _ftol( dblSource ); }
#endif
#ifdef __GNUC__
/* Test for GCC > 2.95 */
#if __GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))
#define unlikely_condition(x) __builtin_expect((x), 0)
#else /* __GNUC__ > 2 ... */
#define unlikely_condition(x) (x)
#endif /* __GNUC__ > 2 ... */
#else /* __GNUC__ */
#define unlikely_condition(x) (x)
#endif /* __GNUC__ */
#ifndef Py_TYPE
#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
#endif
#define PY_NEW(T) \
(((PyTypeObject*)(T))->tp_new( \
(PyTypeObject*)(T), __pyx_empty_tuple, NULL))
#define _fqtypename(o) ((Py_TYPE(o))->tp_name)
#define lxml_malloc(count, item_size) \
(unlikely_condition((size_t)(count) > (size_t) (PY_SSIZE_T_MAX / item_size)) ? NULL : \
(PyMem_Malloc((count) * item_size)))
#define lxml_realloc(mem, count, item_size) \
(unlikely_condition((size_t)(count) > (size_t) (PY_SSIZE_T_MAX / item_size)) ? NULL : \
(PyMem_Realloc(mem, (count) * item_size)))
#define lxml_free(mem) PyMem_Free(mem)
#if PY_MAJOR_VERSION < 3
#define _isString(obj) (PyString_CheckExact(obj) || \
PyUnicode_CheckExact(obj) || \
PyType_IsSubtype(Py_TYPE(obj), &PyBaseString_Type))
#else
/* builtin subtype type checks are almost as fast as exact checks in Py2.7+
* and Unicode is more common in Py3 */
#define _isString(obj) (PyUnicode_Check(obj) || PyBytes_Check(obj))
#endif
#if PY_VERSION_HEX >= 0x03060000
#define lxml_PyOS_FSPath(obj) (PyOS_FSPath(obj))
#else
#define lxml_PyOS_FSPath(obj) (NULL)
#endif
#define _isElement(c_node) \
(((c_node)->type == XML_ELEMENT_NODE) || \
((c_node)->type == XML_COMMENT_NODE) || \
((c_node)->type == XML_ENTITY_REF_NODE) || \
((c_node)->type == XML_PI_NODE))
#define _isElementOrXInclude(c_node) \
(_isElement(c_node) || \
((c_node)->type == XML_XINCLUDE_START) || \
((c_node)->type == XML_XINCLUDE_END))
#define _getNs(c_node) \
(((c_node)->ns == 0) ? 0 : ((c_node)->ns->href))
#include "string.h"
static void* lxml_unpack_xmldoc_capsule(PyObject* capsule, int* is_owned) {
xmlDoc *c_doc;
void *context;
*is_owned = 0;
if (unlikely_condition(!PyCapsule_IsValid(capsule, (const char*)"libxml2:xmlDoc"))) {
PyErr_SetString(
PyExc_TypeError,
"Not a valid capsule. The capsule argument must be a capsule object with name libxml2:xmlDoc");
return NULL;
}
c_doc = (xmlDoc*) PyCapsule_GetPointer(capsule, (const char*)"libxml2:xmlDoc");
if (unlikely_condition(!c_doc)) return NULL;
if (unlikely_condition(c_doc->type != XML_DOCUMENT_NODE && c_doc->type != XML_HTML_DOCUMENT_NODE)) {
PyErr_Format(
PyExc_ValueError,
"Illegal document provided: expected XML or HTML, found %d", (int)c_doc->type);
return NULL;
}
context = PyCapsule_GetContext(capsule);
if (unlikely_condition(!context && PyErr_Occurred())) return NULL;
if (context && strcmp((const char*) context, "destructor:xmlFreeDoc") == 0) {
/* take ownership by setting destructor to NULL */
if (PyCapsule_SetDestructor(capsule, NULL) == 0) {
/* ownership transferred => invalidate capsule by clearing its name */
if (unlikely_condition(PyCapsule_SetName(capsule, NULL))) {
/* this should never happen since everything above succeeded */
xmlFreeDoc(c_doc);
return NULL;
}
*is_owned = 1;
}
}
return c_doc;
}
/* Macro pair implementation of a depth first tree walker
*
* Calls the code block between the BEGIN and END macros for all elements
* below c_tree_top (exclusively), starting at c_node (inclusively iff
* 'inclusive' is 1). The _ELEMENT_ variants will only stop on nodes
* that match _isElement(), the normal variant will stop on every node
* except text nodes.
*
* To traverse the node and all of its children and siblings in Pyrex, call
* cdef xmlNode* some_node
* BEGIN_FOR_EACH_ELEMENT_FROM(some_node.parent, some_node, 1)
* # do something with some_node
* END_FOR_EACH_ELEMENT_FROM(some_node)
*
* To traverse only the children and siblings of a node, call
* cdef xmlNode* some_node
* BEGIN_FOR_EACH_ELEMENT_FROM(some_node.parent, some_node, 0)
* # do something with some_node
* END_FOR_EACH_ELEMENT_FROM(some_node)
*
* To traverse only the children, do:
* cdef xmlNode* some_node
* some_node = parent_node.children
* BEGIN_FOR_EACH_ELEMENT_FROM(parent_node, some_node, 1)
* # do something with some_node
* END_FOR_EACH_ELEMENT_FROM(some_node)
*
* NOTE: 'some_node' MUST be a plain 'xmlNode*' !
*
* NOTE: parent modification during the walk can divert the iterator, but
* should not segfault !
*/
#define _LX__ELEMENT_MATCH(c_node, only_elements) \
((only_elements) ? (_isElement(c_node)) : 1)
#define _LX__ADVANCE_TO_NEXT(c_node, only_elements) \
while ((c_node != 0) && (!_LX__ELEMENT_MATCH(c_node, only_elements))) \
c_node = c_node->next;
#define _LX__TRAVERSE_TO_NEXT(c_stop_node, c_node, only_elements) \
{ \
/* walk through children first */ \
xmlNode* _lx__next = c_node->children; \
if (_lx__next != 0) { \
if (c_node->type == XML_ENTITY_REF_NODE || c_node->type == XML_DTD_NODE) { \
_lx__next = 0; \
} else { \
_LX__ADVANCE_TO_NEXT(_lx__next, only_elements) \
} \
} \
if ((_lx__next == 0) && (c_node != c_stop_node)) { \
/* try siblings */ \
_lx__next = c_node->next; \
_LX__ADVANCE_TO_NEXT(_lx__next, only_elements) \
/* back off through parents */ \
while (_lx__next == 0) { \
c_node = c_node->parent; \
if (c_node == 0) \
break; \
if (c_node == c_stop_node) \
break; \
if ((only_elements) && !_isElement(c_node)) \
break; \
/* we already traversed the parents -> siblings */ \
_lx__next = c_node->next; \
_LX__ADVANCE_TO_NEXT(_lx__next, only_elements) \
} \
} \
c_node = _lx__next; \
}
#define _LX__BEGIN_FOR_EACH_FROM(c_tree_top, c_node, inclusive, only_elements) \
{ \
if (c_node != 0) { \
const xmlNode* _lx__tree_top = (c_tree_top); \
const int _lx__only_elements = (only_elements); \
/* make sure we start at an element */ \
if (!_LX__ELEMENT_MATCH(c_node, _lx__only_elements)) { \
/* we skip the node, so 'inclusive' is irrelevant */ \
if (c_node == _lx__tree_top) \
c_node = 0; /* nothing to traverse */ \
else { \
c_node = c_node->next; \
_LX__ADVANCE_TO_NEXT(c_node, _lx__only_elements) \
} \
} else if (! (inclusive)) { \
/* skip the first node */ \
_LX__TRAVERSE_TO_NEXT(_lx__tree_top, c_node, _lx__only_elements) \
} \
\
/* now run the user code on the elements we find */ \
while (c_node != 0) { \
/* here goes the code to be run for each element */
#define _LX__END_FOR_EACH_FROM(c_node) \
_LX__TRAVERSE_TO_NEXT(_lx__tree_top, c_node, _lx__only_elements) \
} \
} \
}
#define BEGIN_FOR_EACH_ELEMENT_FROM(c_tree_top, c_node, inclusive) \
_LX__BEGIN_FOR_EACH_FROM(c_tree_top, c_node, inclusive, 1)
#define END_FOR_EACH_ELEMENT_FROM(c_node) \
_LX__END_FOR_EACH_FROM(c_node)
#define BEGIN_FOR_EACH_FROM(c_tree_top, c_node, inclusive) \
_LX__BEGIN_FOR_EACH_FROM(c_tree_top, c_node, inclusive, 0)
#define END_FOR_EACH_FROM(c_node) \
_LX__END_FOR_EACH_FROM(c_node)
#endif /* HAS_ETREE_DEFS_H */

237
.venv/lib/python3.7/site-packages/lxml/includes/etreepublic.pxd Normal file
View File

@@ -0,0 +1,237 @@
# public Cython/C interface to lxml.etree
from lxml.includes cimport tree
from lxml.includes.tree cimport const_xmlChar
cdef extern from "lxml-version.h":
cdef char* LXML_VERSION_STRING
cdef extern from "etree_defs.h":
# test if c_node is considered an Element (i.e. Element, Comment, etc.)
cdef bint _isElement(tree.xmlNode* c_node) nogil
# return the namespace URI of the node or NULL
cdef const_xmlChar* _getNs(tree.xmlNode* node) nogil
# pair of macros for tree traversal
cdef void BEGIN_FOR_EACH_ELEMENT_FROM(tree.xmlNode* tree_top,
tree.xmlNode* start_node,
int start_node_inclusive) nogil
cdef void END_FOR_EACH_ELEMENT_FROM(tree.xmlNode* start_node) nogil
cdef extern from "etree_api.h":
# first function to call!
cdef int import_lxml__etree() except -1
##########################################################################
# public ElementTree API classes
cdef class lxml.etree._Document [ object LxmlDocument ]:
cdef tree.xmlDoc* _c_doc
cdef class lxml.etree._Element [ object LxmlElement ]:
cdef _Document _doc
cdef tree.xmlNode* _c_node
cdef class lxml.etree.ElementBase(_Element) [ object LxmlElementBase ]:
pass
cdef class lxml.etree._ElementTree [ object LxmlElementTree ]:
cdef _Document _doc
cdef _Element _context_node
cdef class lxml.etree.ElementClassLookup [ object LxmlElementClassLookup ]:
cdef object (*_lookup_function)(object, _Document, tree.xmlNode*)
cdef class lxml.etree.FallbackElementClassLookup(ElementClassLookup) \
[ object LxmlFallbackElementClassLookup ]:
cdef ElementClassLookup fallback
cdef object (*_fallback_function)(object, _Document, tree.xmlNode*)
##########################################################################
# creating Element objects
# create an Element for a C-node in the Document
cdef _Element elementFactory(_Document doc, tree.xmlNode* c_node)
# create an ElementTree for an Element
cdef _ElementTree elementTreeFactory(_Element context_node)
# create an ElementTree subclass for an Element
cdef _ElementTree newElementTree(_Element context_node, object subclass)
# create an ElementTree from an external document
cdef _ElementTree adoptExternalDocument(tree.xmlDoc* c_doc, parser, bint is_owned)
# create a new Element for an existing or new document (doc = None)
# builds Python object after setting text, tail, namespaces and attributes
cdef _Element makeElement(tag, _Document doc, parser,
text, tail, attrib, nsmap)
# create a new SubElement for an existing parent
# builds Python object after setting text, tail, namespaces and attributes
cdef _Element makeSubElement(_Element parent, tag, text, tail,
attrib, nsmap)
# deep copy a node to include it in the Document
cdef _Element deepcopyNodeToDocument(_Document doc, tree.xmlNode* c_root)
# set the internal lookup function for Element/Comment/PI classes
# use setElementClassLookupFunction(NULL, None) to reset it
# note that the lookup function *must always* return an _Element subclass!
cdef void setElementClassLookupFunction(
object (*function)(object, _Document, tree.xmlNode*), object state)
# lookup function that always returns the default Element class
# note that the first argument is expected to be None!
cdef object lookupDefaultElementClass(_1, _Document _2,
tree.xmlNode* c_node)
# lookup function for namespace/tag specific Element classes
# note that the first argument is expected to be None!
cdef object lookupNamespaceElementClass(_1, _Document _2,
tree.xmlNode* c_node)
# call the fallback lookup function of a FallbackElementClassLookup
cdef object callLookupFallback(FallbackElementClassLookup lookup,
_Document doc, tree.xmlNode* c_node)
##########################################################################
# XML attribute access
# return an attribute value for a C attribute on a C element node
cdef object attributeValue(tree.xmlNode* c_element,
tree.xmlAttr* c_attrib_node)
# return the value of the attribute with 'ns' and 'name' (or None)
cdef object attributeValueFromNsName(tree.xmlNode* c_element,
const_xmlChar* c_ns, const_xmlChar* c_name)
# return the value of attribute "{ns}name", or the default value
cdef object getAttributeValue(_Element element, key, default)
# return an iterator over attribute names (1), values (2) or items (3)
# attributes must not be removed during iteration!
cdef object iterattributes(_Element element, int keysvalues)
# return the list of all attribute names (1), values (2) or items (3)
cdef list collectAttributes(tree.xmlNode* c_element, int keysvalues)
# set an attribute value on an element
# on failure, sets an exception and returns -1
cdef int setAttributeValue(_Element element, key, value) except -1
# delete an attribute
# on failure, sets an exception and returns -1
cdef int delAttribute(_Element element, key) except -1
# delete an attribute based on name and namespace URI
# returns -1 if the attribute was not found (no exception)
cdef int delAttributeFromNsName(tree.xmlNode* c_element,
const_xmlChar* c_href, const_xmlChar* c_name)
##########################################################################
# XML node helper functions
# check if the element has at least one child
cdef bint hasChild(tree.xmlNode* c_node) nogil
# find child element number 'index' (supports negative indexes)
cdef tree.xmlNode* findChild(tree.xmlNode* c_node,
Py_ssize_t index) nogil
# find child element number 'index' starting at first one
cdef tree.xmlNode* findChildForwards(tree.xmlNode* c_node,
Py_ssize_t index) nogil
# find child element number 'index' starting at last one
cdef tree.xmlNode* findChildBackwards(tree.xmlNode* c_node,
Py_ssize_t index) nogil
# return next/previous sibling element of the node
cdef tree.xmlNode* nextElement(tree.xmlNode* c_node) nogil
cdef tree.xmlNode* previousElement(tree.xmlNode* c_node) nogil
##########################################################################
# iterators (DEPRECATED API, don't use in new code!)
cdef class lxml.etree._ElementTagMatcher [ object LxmlElementTagMatcher ]:
cdef char* _href
cdef char* _name
# store "{ns}tag" (or None) filter for this matcher or element iterator
# ** unless _href *and* _name are set up 'by hand', this function *must*
# ** be called when subclassing the iterator below!
cdef void initTagMatch(_ElementTagMatcher matcher, tag)
cdef class lxml.etree._ElementIterator(_ElementTagMatcher) [
object LxmlElementIterator ]:
cdef _Element _node
cdef tree.xmlNode* (*_next_element)(tree.xmlNode*)
# store the initial node of the iterator if it matches the required tag
# or its next matching sibling if not
cdef void iteratorStoreNext(_ElementIterator iterator, _Element node)
##########################################################################
# other helper functions
# check if a C node matches a tag name and namespace
# (NULL allowed for each => always matches)
cdef int tagMatches(tree.xmlNode* c_node, const_xmlChar* c_href, const_xmlChar* c_name)
# convert a UTF-8 char* to a Python string or unicode string
cdef object pyunicode(const_xmlChar* s)
# convert the string to UTF-8 using the normal lxml.etree semantics
cdef bytes utf8(object s)
# split a tag into a (URI, name) tuple, return None as URI for '{}tag'
cdef tuple getNsTag(object tag)
# split a tag into a (URI, name) tuple, return b'' as URI for '{}tag'
cdef tuple getNsTagWithEmptyNs(object tag)
# get the "{ns}tag" string for a C node
cdef object namespacedName(tree.xmlNode* c_node)
# get the "{ns}tag" string for a href/tagname pair (c_ns may be NULL)
cdef object namespacedNameFromNsName(const_xmlChar* c_ns, const_xmlChar* c_tag)
# check if the node has a text value (which may be '')
cdef bint hasText(tree.xmlNode* c_node) nogil
# check if the node has a tail value (which may be '')
cdef bint hasTail(tree.xmlNode* c_node) nogil
# get the text content of an element (or None)
cdef object textOf(tree.xmlNode* c_node)
# get the tail content of an element (or None)
cdef object tailOf(tree.xmlNode* c_node)
# set the text value of an element
cdef int setNodeText(tree.xmlNode* c_node, text) except -1
# set the tail text value of an element
cdef int setTailText(tree.xmlNode* c_node, text) except -1
# append an element to the children of a parent element
# deprecated: don't use, does not propagate exceptions!
# use appendChildToElement() instead
cdef void appendChild(_Element parent, _Element child)
# added in lxml 3.3 as a safe replacement for appendChild()
# return -1 for exception, 0 for ok
cdef int appendChildToElement(_Element parent, _Element child) except -1
# recursively lookup a namespace in element or ancestors, or create it
cdef tree.xmlNs* findOrBuildNodeNsPrefix(
_Document doc, tree.xmlNode* c_node, const_xmlChar* href, const_xmlChar* prefix)
# find the Document of an Element, ElementTree or Document (itself!)
cdef _Document documentOrRaise(object input)
# find the root Element of an Element (itself!), ElementTree or Document
cdef _Element rootNodeOrRaise(object input)

56
.venv/lib/python3.7/site-packages/lxml/includes/htmlparser.pxd Normal file
View File

@@ -0,0 +1,56 @@
from libc.string cimport const_char
from lxml.includes.tree cimport xmlDoc
from lxml.includes.tree cimport xmlInputReadCallback, xmlInputCloseCallback
from lxml.includes.xmlparser cimport xmlParserCtxt, xmlSAXHandler, xmlSAXHandlerV1
cdef extern from "libxml/HTMLparser.h":
ctypedef enum htmlParserOption:
HTML_PARSE_NOERROR # suppress error reports
HTML_PARSE_NOWARNING # suppress warning reports
HTML_PARSE_PEDANTIC # pedantic error reporting
HTML_PARSE_NOBLANKS # remove blank nodes
HTML_PARSE_NONET # Forbid network access
# libxml2 2.6.21+ only:
HTML_PARSE_RECOVER # Relaxed parsing
HTML_PARSE_COMPACT # compact small text nodes
# libxml2 2.7.7+ only:
HTML_PARSE_NOIMPLIED # Do not add implied html/body... elements
# libxml2 2.7.8+ only:
HTML_PARSE_NODEFDTD # do not default a doctype if not found
# libxml2 2.8.0+ only:
XML_PARSE_IGNORE_ENC # ignore internal document encoding hint
xmlSAXHandlerV1 htmlDefaultSAXHandler
cdef xmlParserCtxt* htmlCreateMemoryParserCtxt(
char* buffer, int size) nogil
cdef xmlParserCtxt* htmlCreateFileParserCtxt(
char* filename, char* encoding) nogil
cdef xmlParserCtxt* htmlCreatePushParserCtxt(xmlSAXHandler* sax,
void* user_data,
char* chunk, int size,
char* filename, int enc) nogil
cdef void htmlFreeParserCtxt(xmlParserCtxt* ctxt) nogil
cdef void htmlCtxtReset(xmlParserCtxt* ctxt) nogil
cdef int htmlCtxtUseOptions(xmlParserCtxt* ctxt, int options) nogil
cdef int htmlParseDocument(xmlParserCtxt* ctxt) nogil
cdef int htmlParseChunk(xmlParserCtxt* ctxt,
char* chunk, int size, int terminate) nogil
cdef xmlDoc* htmlCtxtReadFile(xmlParserCtxt* ctxt,
char* filename, const_char* encoding,
int options) nogil
cdef xmlDoc* htmlCtxtReadDoc(xmlParserCtxt* ctxt,
char* buffer, char* URL, const_char* encoding,
int options) nogil
cdef xmlDoc* htmlCtxtReadIO(xmlParserCtxt* ctxt,
xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void* ioctx,
char* URL, const_char* encoding,
int options) nogil
cdef xmlDoc* htmlCtxtReadMemory(xmlParserCtxt* ctxt,
char* buffer, int size,
char* filename, const_char* encoding,
int options) nogil

3
.venv/lib/python3.7/site-packages/lxml/includes/lxml-version.h Normal file
View File

@@ -0,0 +1,3 @@
#ifndef LXML_VERSION_STRING
#define LXML_VERSION_STRING "4.9.3"
#endif

64
.venv/lib/python3.7/site-packages/lxml/includes/relaxng.pxd Normal file
View File

@@ -0,0 +1,64 @@
from lxml.includes.tree cimport xmlDoc
from lxml.includes.xmlerror cimport xmlStructuredErrorFunc
cdef extern from "libxml/relaxng.h":
ctypedef struct xmlRelaxNG
ctypedef struct xmlRelaxNGParserCtxt
ctypedef struct xmlRelaxNGValidCtxt
ctypedef enum xmlRelaxNGValidErr:
XML_RELAXNG_OK = 0
XML_RELAXNG_ERR_MEMORY = 1
XML_RELAXNG_ERR_TYPE = 2
XML_RELAXNG_ERR_TYPEVAL = 3
XML_RELAXNG_ERR_DUPID = 4
XML_RELAXNG_ERR_TYPECMP = 5
XML_RELAXNG_ERR_NOSTATE = 6
XML_RELAXNG_ERR_NODEFINE = 7
XML_RELAXNG_ERR_LISTEXTRA = 8
XML_RELAXNG_ERR_LISTEMPTY = 9
XML_RELAXNG_ERR_INTERNODATA = 10
XML_RELAXNG_ERR_INTERSEQ = 11
XML_RELAXNG_ERR_INTEREXTRA = 12
XML_RELAXNG_ERR_ELEMNAME = 13
XML_RELAXNG_ERR_ATTRNAME = 14
XML_RELAXNG_ERR_ELEMNONS = 15
XML_RELAXNG_ERR_ATTRNONS = 16
XML_RELAXNG_ERR_ELEMWRONGNS = 17
XML_RELAXNG_ERR_ATTRWRONGNS = 18
XML_RELAXNG_ERR_ELEMEXTRANS = 19
XML_RELAXNG_ERR_ATTREXTRANS = 20
XML_RELAXNG_ERR_ELEMNOTEMPTY = 21
XML_RELAXNG_ERR_NOELEM = 22
XML_RELAXNG_ERR_NOTELEM = 23
XML_RELAXNG_ERR_ATTRVALID = 24
XML_RELAXNG_ERR_CONTENTVALID = 25
XML_RELAXNG_ERR_EXTRACONTENT = 26
XML_RELAXNG_ERR_INVALIDATTR = 27
XML_RELAXNG_ERR_DATAELEM = 28
XML_RELAXNG_ERR_VALELEM = 29
XML_RELAXNG_ERR_LISTELEM = 30
XML_RELAXNG_ERR_DATATYPE = 31
XML_RELAXNG_ERR_VALUE = 32
XML_RELAXNG_ERR_LIST = 33
XML_RELAXNG_ERR_NOGRAMMAR = 34
XML_RELAXNG_ERR_EXTRADATA = 35
XML_RELAXNG_ERR_LACKDATA = 36
XML_RELAXNG_ERR_INTERNAL = 37
XML_RELAXNG_ERR_ELEMWRONG = 38
XML_RELAXNG_ERR_TEXTWRONG = 39
cdef xmlRelaxNGValidCtxt* xmlRelaxNGNewValidCtxt(xmlRelaxNG* schema) nogil
cdef int xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxt* ctxt, xmlDoc* doc) nogil
cdef xmlRelaxNG* xmlRelaxNGParse(xmlRelaxNGParserCtxt* ctxt) nogil
cdef xmlRelaxNGParserCtxt* xmlRelaxNGNewParserCtxt(char* URL) nogil
cdef xmlRelaxNGParserCtxt* xmlRelaxNGNewDocParserCtxt(xmlDoc* doc) nogil
cdef void xmlRelaxNGFree(xmlRelaxNG* schema) nogil
cdef void xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxt* ctxt) nogil
cdef void xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxt* ctxt) nogil
cdef void xmlRelaxNGSetValidStructuredErrors(
xmlRelaxNGValidCtxt* ctxt, xmlStructuredErrorFunc serror, void *ctx) nogil
cdef void xmlRelaxNGSetParserStructuredErrors(
xmlRelaxNGParserCtxt* ctxt, xmlStructuredErrorFunc serror, void *ctx) nogil

34
.venv/lib/python3.7/site-packages/lxml/includes/schematron.pxd Normal file
View File

@@ -0,0 +1,34 @@
from lxml.includes cimport xmlerror
from lxml.includes.tree cimport xmlDoc
cdef extern from "libxml/schematron.h":
ctypedef struct xmlSchematron
ctypedef struct xmlSchematronParserCtxt
ctypedef struct xmlSchematronValidCtxt
ctypedef enum xmlSchematronValidOptions:
XML_SCHEMATRON_OUT_QUIET = 1 # quiet no report
XML_SCHEMATRON_OUT_TEXT = 2 # build a textual report
XML_SCHEMATRON_OUT_XML = 4 # output SVRL
XML_SCHEMATRON_OUT_ERROR = 8 # output via xmlStructuredErrorFunc
XML_SCHEMATRON_OUT_FILE = 256 # output to a file descriptor
XML_SCHEMATRON_OUT_BUFFER = 512 # output to a buffer
XML_SCHEMATRON_OUT_IO = 1024 # output to I/O mechanism
cdef xmlSchematronParserCtxt* xmlSchematronNewDocParserCtxt(
xmlDoc* doc) nogil
cdef xmlSchematronParserCtxt* xmlSchematronNewParserCtxt(
char* filename) nogil
cdef xmlSchematronValidCtxt* xmlSchematronNewValidCtxt(
xmlSchematron* schema, int options) nogil
cdef xmlSchematron* xmlSchematronParse(xmlSchematronParserCtxt* ctxt) nogil
cdef int xmlSchematronValidateDoc(xmlSchematronValidCtxt* ctxt,
xmlDoc* instance) nogil
cdef void xmlSchematronFreeParserCtxt(xmlSchematronParserCtxt* ctxt) nogil
cdef void xmlSchematronFreeValidCtxt(xmlSchematronValidCtxt* ctxt) nogil
cdef void xmlSchematronFree(xmlSchematron* schema) nogil
cdef void xmlSchematronSetValidStructuredErrors(
xmlSchematronValidCtxt* ctxt,
xmlerror.xmlStructuredErrorFunc error_func, void *data)

480
.venv/lib/python3.7/site-packages/lxml/includes/tree.pxd Normal file
View File

@@ -0,0 +1,480 @@
from libc cimport stdio
from libc.string cimport const_char, const_uchar
cdef extern from "lxml-version.h":
# deprecated declaration, use etreepublic.pxd instead
cdef char* LXML_VERSION_STRING
cdef extern from "libxml/xmlversion.h":
cdef const_char* xmlParserVersion
cdef int LIBXML_VERSION
cdef extern from "libxml/xmlstring.h":
ctypedef unsigned char xmlChar
ctypedef const xmlChar const_xmlChar "const xmlChar"
cdef int xmlStrlen(const_xmlChar* str) nogil
cdef xmlChar* xmlStrdup(const_xmlChar* cur) nogil
cdef int xmlStrncmp(const_xmlChar* str1, const_xmlChar* str2, int length) nogil
cdef int xmlStrcmp(const_xmlChar* str1, const_xmlChar* str2) nogil
cdef int xmlStrcasecmp(const xmlChar *str1, const xmlChar *str2) nogil
cdef const_xmlChar* xmlStrstr(const_xmlChar* str1, const_xmlChar* str2) nogil
cdef const_xmlChar* xmlStrchr(const_xmlChar* str1, xmlChar ch) nogil
cdef const_xmlChar* _xcstr "(const xmlChar*)PyBytes_AS_STRING" (object s)
cdef extern from "libxml/encoding.h":
ctypedef enum xmlCharEncoding:
XML_CHAR_ENCODING_ERROR = -1 # No char encoding detected
XML_CHAR_ENCODING_NONE = 0 # No char encoding detected
XML_CHAR_ENCODING_UTF8 = 1 # UTF-8
XML_CHAR_ENCODING_UTF16LE = 2 # UTF-16 little endian
XML_CHAR_ENCODING_UTF16BE = 3 # UTF-16 big endian
XML_CHAR_ENCODING_UCS4LE = 4 # UCS-4 little endian
XML_CHAR_ENCODING_UCS4BE = 5 # UCS-4 big endian
XML_CHAR_ENCODING_EBCDIC = 6 # EBCDIC uh!
XML_CHAR_ENCODING_UCS4_2143 = 7 # UCS-4 unusual ordering
XML_CHAR_ENCODING_UCS4_3412 = 8 # UCS-4 unusual ordering
XML_CHAR_ENCODING_UCS2 = 9 # UCS-2
XML_CHAR_ENCODING_8859_1 = 10 # ISO-8859-1 ISO Latin 1
XML_CHAR_ENCODING_8859_2 = 11 # ISO-8859-2 ISO Latin 2
XML_CHAR_ENCODING_8859_3 = 12 # ISO-8859-3
XML_CHAR_ENCODING_8859_4 = 13 # ISO-8859-4
XML_CHAR_ENCODING_8859_5 = 14 # ISO-8859-5
XML_CHAR_ENCODING_8859_6 = 15 # ISO-8859-6
XML_CHAR_ENCODING_8859_7 = 16 # ISO-8859-7
XML_CHAR_ENCODING_8859_8 = 17 # ISO-8859-8
XML_CHAR_ENCODING_8859_9 = 18 # ISO-8859-9
XML_CHAR_ENCODING_2022_JP = 19 # ISO-2022-JP
XML_CHAR_ENCODING_SHIFT_JIS = 20 # Shift_JIS
XML_CHAR_ENCODING_EUC_JP = 21 # EUC-JP
XML_CHAR_ENCODING_ASCII = 22 # pure ASCII
ctypedef struct xmlCharEncodingHandler
cdef xmlCharEncodingHandler* xmlFindCharEncodingHandler(char* name) nogil
cdef xmlCharEncodingHandler* xmlGetCharEncodingHandler(
xmlCharEncoding enc) nogil
cdef int xmlCharEncCloseFunc(xmlCharEncodingHandler* handler) nogil
cdef xmlCharEncoding xmlDetectCharEncoding(const_xmlChar* text, int len) nogil
cdef const_char* xmlGetCharEncodingName(xmlCharEncoding enc) nogil
cdef xmlCharEncoding xmlParseCharEncoding(char* name) nogil
ctypedef int (*xmlCharEncodingOutputFunc)(
unsigned char *out_buf, int *outlen, const_uchar *in_buf, int *inlen)
cdef extern from "libxml/chvalid.h":
cdef int xmlIsChar_ch(char c) nogil
cdef int xmlIsCharQ(int ch) nogil
cdef extern from "libxml/hash.h":
ctypedef struct xmlHashTable
ctypedef void (*xmlHashScanner)(void* payload, void* data, const_xmlChar* name) # may require GIL!
void xmlHashScan(xmlHashTable* table, xmlHashScanner f, void* data) nogil
void* xmlHashLookup(xmlHashTable* table, const_xmlChar* name) nogil
ctypedef void (*xmlHashDeallocator)(void *payload, xmlChar *name)
cdef xmlHashTable* xmlHashCreate(int size)
cdef xmlHashTable* xmlHashCreateDict(int size, xmlDict *dict)
cdef int xmlHashSize(xmlHashTable* table)
cdef void xmlHashFree(xmlHashTable* table, xmlHashDeallocator f)
cdef extern from *: # actually "libxml/dict.h"
# libxml/dict.h appears to be broken to include in C
ctypedef struct xmlDict
cdef const_xmlChar* xmlDictLookup(xmlDict* dict, const_xmlChar* name, int len) nogil
cdef const_xmlChar* xmlDictExists(xmlDict* dict, const_xmlChar* name, int len) nogil
cdef int xmlDictOwns(xmlDict* dict, const_xmlChar* name) nogil
cdef size_t xmlDictSize(xmlDict* dict) nogil
cdef extern from "libxml/tree.h":
ctypedef struct xmlDoc
ctypedef struct xmlAttr
ctypedef struct xmlNotationTable
ctypedef enum xmlElementType:
XML_ELEMENT_NODE= 1
XML_ATTRIBUTE_NODE= 2
XML_TEXT_NODE= 3
XML_CDATA_SECTION_NODE= 4
XML_ENTITY_REF_NODE= 5
XML_ENTITY_NODE= 6
XML_PI_NODE= 7
XML_COMMENT_NODE= 8
XML_DOCUMENT_NODE= 9
XML_DOCUMENT_TYPE_NODE= 10
XML_DOCUMENT_FRAG_NODE= 11
XML_NOTATION_NODE= 12
XML_HTML_DOCUMENT_NODE= 13
XML_DTD_NODE= 14
XML_ELEMENT_DECL= 15
XML_ATTRIBUTE_DECL= 16
XML_ENTITY_DECL= 17
XML_NAMESPACE_DECL= 18
XML_XINCLUDE_START= 19
XML_XINCLUDE_END= 20
ctypedef enum xmlElementTypeVal:
XML_ELEMENT_TYPE_UNDEFINED= 0
XML_ELEMENT_TYPE_EMPTY= 1
XML_ELEMENT_TYPE_ANY= 2
XML_ELEMENT_TYPE_MIXED= 3
XML_ELEMENT_TYPE_ELEMENT= 4
ctypedef enum xmlElementContentType:
XML_ELEMENT_CONTENT_PCDATA= 1
XML_ELEMENT_CONTENT_ELEMENT= 2
XML_ELEMENT_CONTENT_SEQ= 3
XML_ELEMENT_CONTENT_OR= 4
ctypedef enum xmlElementContentOccur:
XML_ELEMENT_CONTENT_ONCE= 1
XML_ELEMENT_CONTENT_OPT= 2
XML_ELEMENT_CONTENT_MULT= 3
XML_ELEMENT_CONTENT_PLUS= 4
ctypedef enum xmlAttributeType:
XML_ATTRIBUTE_CDATA = 1
XML_ATTRIBUTE_ID= 2
XML_ATTRIBUTE_IDREF= 3
XML_ATTRIBUTE_IDREFS= 4
XML_ATTRIBUTE_ENTITY= 5
XML_ATTRIBUTE_ENTITIES= 6
XML_ATTRIBUTE_NMTOKEN= 7
XML_ATTRIBUTE_NMTOKENS= 8
XML_ATTRIBUTE_ENUMERATION= 9
XML_ATTRIBUTE_NOTATION= 10
ctypedef enum xmlAttributeDefault:
XML_ATTRIBUTE_NONE= 1
XML_ATTRIBUTE_REQUIRED= 2
XML_ATTRIBUTE_IMPLIED= 3
XML_ATTRIBUTE_FIXED= 4
ctypedef enum xmlEntityType:
XML_INTERNAL_GENERAL_ENTITY= 1
XML_EXTERNAL_GENERAL_PARSED_ENTITY= 2
XML_EXTERNAL_GENERAL_UNPARSED_ENTITY= 3
XML_INTERNAL_PARAMETER_ENTITY= 4
XML_EXTERNAL_PARAMETER_ENTITY= 5
XML_INTERNAL_PREDEFINED_ENTITY= 6
ctypedef struct xmlNs:
const_xmlChar* href
const_xmlChar* prefix
xmlNs* next
ctypedef struct xmlNode:
void* _private
xmlElementType type
const_xmlChar* name
xmlNode* children
xmlNode* last
xmlNode* parent
xmlNode* next
xmlNode* prev
xmlDoc* doc
xmlChar* content
xmlAttr* properties
xmlNs* ns
xmlNs* nsDef
unsigned short line
ctypedef struct xmlElementContent:
xmlElementContentType type
xmlElementContentOccur ocur
const_xmlChar *name
xmlElementContent *c1
xmlElementContent *c2
xmlElementContent *parent
const_xmlChar *prefix
ctypedef struct xmlEnumeration:
xmlEnumeration *next
const_xmlChar *name
ctypedef struct xmlAttribute:
void* _private
xmlElementType type
const_xmlChar* name
xmlNode* children
xmlNode* last
xmlDtd* parent
xmlNode* next
xmlNode* prev
xmlDoc* doc
xmlAttribute* nexth
xmlAttributeType atype
xmlAttributeDefault def_ "def"
const_xmlChar* defaultValue
xmlEnumeration* tree
const_xmlChar* prefix
const_xmlChar* elem
ctypedef struct xmlElement:
void* _private
xmlElementType type
const_xmlChar* name
xmlNode* children
xmlNode* last
xmlNode* parent
xmlNode* next
xmlNode* prev
xmlDoc* doc
xmlElementTypeVal etype
xmlElementContent* content
xmlAttribute* attributes
const_xmlChar* prefix
void *contModel
ctypedef struct xmlEntity:
void* _private
xmlElementType type
const_xmlChar* name
xmlNode* children
xmlNode* last
xmlDtd* parent
xmlNode* next
xmlNode* prev
xmlDoc* doc
xmlChar* orig
xmlChar* content
int length
xmlEntityType etype
const_xmlChar* ExternalID
const_xmlChar* SystemID
xmlEntity* nexte
const_xmlChar* URI
int owner
int checked
ctypedef struct xmlDtd:
const_xmlChar* name
const_xmlChar* ExternalID
const_xmlChar* SystemID
void* notations
void* entities
void* pentities
void* attributes
void* elements
xmlNode* children
xmlNode* last
xmlDoc* doc
ctypedef struct xmlDoc:
xmlElementType type
char* name
xmlNode* children
xmlNode* last
xmlNode* parent
xmlNode* next
xmlNode* prev
xmlDoc* doc
xmlDict* dict
xmlHashTable* ids
int standalone
const_xmlChar* version
const_xmlChar* encoding
const_xmlChar* URL
void* _private
xmlDtd* intSubset
xmlDtd* extSubset
ctypedef struct xmlAttr:
void* _private
xmlElementType type
const_xmlChar* name
xmlNode* children
xmlNode* last
xmlNode* parent
xmlAttr* next
xmlAttr* prev
xmlDoc* doc
xmlNs* ns
xmlAttributeType atype
ctypedef struct xmlID:
const_xmlChar* value
const_xmlChar* name
xmlAttr* attr
xmlDoc* doc
ctypedef struct xmlBuffer
ctypedef struct xmlBuf # new in libxml2 2.9
ctypedef struct xmlOutputBuffer:
xmlBuf* buffer
xmlBuf* conv
int error
const_xmlChar* XML_XML_NAMESPACE
cdef void xmlFreeDoc(xmlDoc* cur) nogil
cdef void xmlFreeDtd(xmlDtd* cur) nogil
cdef void xmlFreeNode(xmlNode* cur) nogil
cdef void xmlFreeNsList(xmlNs* ns) nogil
cdef void xmlFreeNs(xmlNs* ns) nogil
cdef void xmlFree(void* buf) nogil
cdef xmlNode* xmlNewNode(xmlNs* ns, const_xmlChar* name) nogil
cdef xmlNode* xmlNewDocText(xmlDoc* doc, const_xmlChar* content) nogil
cdef xmlNode* xmlNewDocComment(xmlDoc* doc, const_xmlChar* content) nogil
cdef xmlNode* xmlNewDocPI(xmlDoc* doc, const_xmlChar* name, const_xmlChar* content) nogil
cdef xmlNode* xmlNewReference(xmlDoc* doc, const_xmlChar* name) nogil
cdef xmlNode* xmlNewCDataBlock(xmlDoc* doc, const_xmlChar* text, int len) nogil
cdef xmlNs* xmlNewNs(xmlNode* node, const_xmlChar* href, const_xmlChar* prefix) nogil
cdef xmlNode* xmlAddChild(xmlNode* parent, xmlNode* cur) nogil
cdef xmlNode* xmlReplaceNode(xmlNode* old, xmlNode* cur) nogil
cdef xmlNode* xmlAddPrevSibling(xmlNode* cur, xmlNode* elem) nogil
cdef xmlNode* xmlAddNextSibling(xmlNode* cur, xmlNode* elem) nogil
cdef xmlNode* xmlNewDocNode(xmlDoc* doc, xmlNs* ns,
const_xmlChar* name, const_xmlChar* content) nogil
cdef xmlDoc* xmlNewDoc(const_xmlChar* version) nogil
cdef xmlAttr* xmlNewProp(xmlNode* node, const_xmlChar* name, const_xmlChar* value) nogil
cdef xmlAttr* xmlNewNsProp(xmlNode* node, xmlNs* ns,
const_xmlChar* name, const_xmlChar* value) nogil
cdef xmlChar* xmlGetNoNsProp(xmlNode* node, const_xmlChar* name) nogil
cdef xmlChar* xmlGetNsProp(xmlNode* node, const_xmlChar* name, const_xmlChar* nameSpace) nogil
cdef void xmlSetNs(xmlNode* node, xmlNs* ns) nogil
cdef xmlAttr* xmlSetProp(xmlNode* node, const_xmlChar* name, const_xmlChar* value) nogil
cdef xmlAttr* xmlSetNsProp(xmlNode* node, xmlNs* ns,
const_xmlChar* name, const_xmlChar* value) nogil
cdef int xmlRemoveID(xmlDoc* doc, xmlAttr* cur) nogil
cdef int xmlRemoveProp(xmlAttr* cur) nogil
cdef void xmlFreePropList(xmlAttr* cur) nogil
cdef xmlChar* xmlGetNodePath(xmlNode* node) nogil
cdef void xmlDocDumpMemory(xmlDoc* cur, char** mem, int* size) nogil
cdef void xmlDocDumpMemoryEnc(xmlDoc* cur, char** mem, int* size,
char* encoding) nogil
cdef int xmlSaveFileTo(xmlOutputBuffer* out, xmlDoc* cur,
char* encoding) nogil
cdef void xmlUnlinkNode(xmlNode* cur) nogil
cdef xmlNode* xmlDocSetRootElement(xmlDoc* doc, xmlNode* root) nogil
cdef xmlNode* xmlDocGetRootElement(xmlDoc* doc) nogil
cdef void xmlSetTreeDoc(xmlNode* tree, xmlDoc* doc) nogil
cdef xmlAttr* xmlHasProp(xmlNode* node, const_xmlChar* name) nogil
cdef xmlAttr* xmlHasNsProp(xmlNode* node, const_xmlChar* name, const_xmlChar* nameSpace) nogil
cdef xmlChar* xmlNodeGetContent(xmlNode* cur) nogil
cdef int xmlNodeBufGetContent(xmlBuffer* buffer, xmlNode* cur) nogil
cdef xmlNs* xmlSearchNs(xmlDoc* doc, xmlNode* node, const_xmlChar* prefix) nogil
cdef xmlNs* xmlSearchNsByHref(xmlDoc* doc, xmlNode* node, const_xmlChar* href) nogil
cdef int xmlIsBlankNode(xmlNode* node) nogil
cdef long xmlGetLineNo(xmlNode* node) nogil
cdef void xmlElemDump(stdio.FILE* f, xmlDoc* doc, xmlNode* cur) nogil
cdef void xmlNodeDumpOutput(xmlOutputBuffer* buf,
xmlDoc* doc, xmlNode* cur, int level,
int format, const_char* encoding) nogil
cdef void xmlBufAttrSerializeTxtContent(xmlOutputBuffer *buf, xmlDoc *doc,
xmlAttr *attr, const_xmlChar *string) nogil
cdef void xmlNodeSetName(xmlNode* cur, const_xmlChar* name) nogil
cdef void xmlNodeSetContent(xmlNode* cur, const_xmlChar* content) nogil
cdef xmlDtd* xmlCopyDtd(xmlDtd* dtd) nogil
cdef xmlDoc* xmlCopyDoc(xmlDoc* doc, int recursive) nogil
cdef xmlNode* xmlCopyNode(xmlNode* node, int extended) nogil
cdef xmlNode* xmlDocCopyNode(xmlNode* node, xmlDoc* doc, int extended) nogil
cdef int xmlReconciliateNs(xmlDoc* doc, xmlNode* tree) nogil
cdef xmlNs* xmlNewReconciliedNs(xmlDoc* doc, xmlNode* tree, xmlNs* ns) nogil
cdef xmlBuffer* xmlBufferCreate() nogil
cdef void xmlBufferWriteChar(xmlBuffer* buf, char* string) nogil
cdef void xmlBufferFree(xmlBuffer* buf) nogil
cdef const_xmlChar* xmlBufferContent(xmlBuffer* buf) nogil
cdef int xmlBufferLength(xmlBuffer* buf) nogil
cdef const_xmlChar* xmlBufContent(xmlBuf* buf) nogil # new in libxml2 2.9
cdef size_t xmlBufUse(xmlBuf* buf) nogil # new in libxml2 2.9
cdef int xmlKeepBlanksDefault(int val) nogil
cdef xmlChar* xmlNodeGetBase(xmlDoc* doc, xmlNode* node) nogil
cdef xmlDtd* xmlCreateIntSubset(xmlDoc* doc, const_xmlChar* name,
const_xmlChar* ExternalID, const_xmlChar* SystemID) nogil
cdef void xmlNodeSetBase(xmlNode* node, const_xmlChar* uri) nogil
cdef int xmlValidateNCName(const_xmlChar* value, int space) nogil
cdef extern from "libxml/uri.h":
cdef const_xmlChar* xmlBuildURI(const_xmlChar* href, const_xmlChar* base) nogil
cdef extern from "libxml/HTMLtree.h":
cdef void htmlNodeDumpFormatOutput(xmlOutputBuffer* buf,
xmlDoc* doc, xmlNode* cur,
char* encoding, int format) nogil
cdef xmlDoc* htmlNewDoc(const_xmlChar* uri, const_xmlChar* externalID) nogil
cdef extern from "libxml/valid.h":
cdef xmlAttr* xmlGetID(xmlDoc* doc, const_xmlChar* ID) nogil
cdef void xmlDumpNotationTable(xmlBuffer* buffer,
xmlNotationTable* table) nogil
cdef int xmlValidateNameValue(const_xmlChar* value) nogil
cdef extern from "libxml/xmlIO.h":
cdef int xmlOutputBufferWrite(xmlOutputBuffer* out,
int len, const_char* str) nogil
cdef int xmlOutputBufferWriteString(xmlOutputBuffer* out, const_char* str) nogil
cdef int xmlOutputBufferWriteEscape(xmlOutputBuffer* out,
const_xmlChar* str,
xmlCharEncodingOutputFunc escapefunc) nogil
cdef int xmlOutputBufferFlush(xmlOutputBuffer* out) nogil
cdef int xmlOutputBufferClose(xmlOutputBuffer* out) nogil
ctypedef int (*xmlInputReadCallback)(void* context,
char* buffer, int len)
ctypedef int (*xmlInputCloseCallback)(void* context)
ctypedef int (*xmlOutputWriteCallback)(void* context,
char* buffer, int len)
ctypedef int (*xmlOutputCloseCallback)(void* context)
cdef xmlOutputBuffer* xmlAllocOutputBuffer(
xmlCharEncodingHandler* encoder) nogil
cdef xmlOutputBuffer* xmlOutputBufferCreateIO(
xmlOutputWriteCallback iowrite,
xmlOutputCloseCallback ioclose,
void * ioctx,
xmlCharEncodingHandler* encoder) nogil
cdef xmlOutputBuffer* xmlOutputBufferCreateFile(
stdio.FILE* file, xmlCharEncodingHandler* encoder) nogil
cdef xmlOutputBuffer* xmlOutputBufferCreateFilename(
char* URI, xmlCharEncodingHandler* encoder, int compression) nogil
cdef extern from "libxml/xmlsave.h":
ctypedef struct xmlSaveCtxt
ctypedef enum xmlSaveOption:
XML_SAVE_FORMAT = 1 # format save output (2.6.17)
XML_SAVE_NO_DECL = 2 # drop the xml declaration (2.6.21)
XML_SAVE_NO_EMPTY = 4 # no empty tags (2.6.22)
XML_SAVE_NO_XHTML = 8 # disable XHTML1 specific rules (2.6.22)
XML_SAVE_XHTML = 16 # force XHTML1 specific rules (2.7.2)
XML_SAVE_AS_XML = 32 # force XML serialization on HTML doc (2.7.2)
XML_SAVE_AS_HTML = 64 # force HTML serialization on XML doc (2.7.2)
cdef xmlSaveCtxt* xmlSaveToFilename(char* filename, char* encoding,
int options) nogil
cdef xmlSaveCtxt* xmlSaveToBuffer(xmlBuffer* buffer, char* encoding,
int options) nogil # libxml2 2.6.23
cdef long xmlSaveDoc(xmlSaveCtxt* ctxt, xmlDoc* doc) nogil
cdef long xmlSaveTree(xmlSaveCtxt* ctxt, xmlNode* node) nogil
cdef int xmlSaveClose(xmlSaveCtxt* ctxt) nogil
cdef int xmlSaveFlush(xmlSaveCtxt* ctxt) nogil
cdef int xmlSaveSetAttrEscape(xmlSaveCtxt* ctxt, void* escape_func) nogil
cdef int xmlSaveSetEscape(xmlSaveCtxt* ctxt, void* escape_func) nogil
cdef extern from "libxml/globals.h":
cdef int xmlThrDefKeepBlanksDefaultValue(int onoff) nogil
cdef int xmlThrDefLineNumbersDefaultValue(int onoff) nogil
cdef int xmlThrDefIndentTreeOutput(int onoff) nogil
cdef extern from "libxml/xmlmemory.h" nogil:
cdef void* xmlMalloc(size_t size)
cdef int xmlMemBlocks()
cdef int xmlMemUsed()
cdef void xmlMemDisplay(stdio.FILE* file)
cdef void xmlMemDisplayLast(stdio.FILE* file, long num_bytes)
cdef void xmlMemShow(stdio.FILE* file, int count)
cdef extern from "etree_defs.h":
cdef bint _isElement(xmlNode* node) nogil
cdef bint _isElementOrXInclude(xmlNode* node) nogil
cdef const_xmlChar* _getNs(xmlNode* node) nogil
cdef void BEGIN_FOR_EACH_ELEMENT_FROM(xmlNode* tree_top,
xmlNode* start_node,
bint inclusive) nogil
cdef void END_FOR_EACH_ELEMENT_FROM(xmlNode* start_node) nogil
cdef void BEGIN_FOR_EACH_FROM(xmlNode* tree_top,
xmlNode* start_node,
bint inclusive) nogil
cdef void END_FOR_EACH_FROM(xmlNode* start_node) nogil

5
.venv/lib/python3.7/site-packages/lxml/includes/uri.pxd Normal file
View File

@@ -0,0 +1,5 @@
cdef extern from "libxml/uri.h":
ctypedef struct xmlURI
cdef xmlURI* xmlParseURI(char* str)
cdef void xmlFreeURI(xmlURI* uri)

22
.venv/lib/python3.7/site-packages/lxml/includes/xinclude.pxd Normal file
View File

@@ -0,0 +1,22 @@
from lxml.includes.tree cimport xmlDoc, xmlNode
cdef extern from "libxml/xinclude.h":
ctypedef struct xmlXIncludeCtxt
cdef int xmlXIncludeProcess(xmlDoc* doc) nogil
cdef int xmlXIncludeProcessFlags(xmlDoc* doc, int parser_opts) nogil
cdef int xmlXIncludeProcessTree(xmlNode* doc) nogil
cdef int xmlXIncludeProcessTreeFlags(xmlNode* doc, int parser_opts) nogil
# libxml2 >= 2.7.4
cdef int xmlXIncludeProcessTreeFlagsData(
xmlNode* doc, int parser_opts, void* data) nogil
cdef xmlXIncludeCtxt* xmlXIncludeNewContext(xmlDoc* doc) nogil
cdef int xmlXIncludeProcessNode(xmlXIncludeCtxt* ctxt, xmlNode* node) nogil
cdef int xmlXIncludeSetFlags(xmlXIncludeCtxt* ctxt, int flags) nogil
# libxml2 >= 2.6.27
cdef int xmlXIncludeProcessFlagsData(
xmlDoc* doc, int flags, void* data) nogil

852
.venv/lib/python3.7/site-packages/lxml/includes/xmlerror.pxd Normal file
View File

@@ -0,0 +1,852 @@
# --- BEGIN: GENERATED CONSTANTS ---
# This section is generated by the script 'update-error-constants.py'.
cdef extern from "libxml/xmlerror.h":
ctypedef enum xmlErrorLevel:
XML_ERR_NONE = 0
XML_ERR_WARNING = 1 # A simple warning
XML_ERR_ERROR = 2 # A recoverable error
XML_ERR_FATAL = 3 # A fatal error
ctypedef enum xmlErrorDomain:
XML_FROM_NONE = 0
XML_FROM_PARSER = 1 # The XML parser
XML_FROM_TREE = 2 # The tree module
XML_FROM_NAMESPACE = 3 # The XML Namespace module
XML_FROM_DTD = 4 # The XML DTD validation with parser contex
XML_FROM_HTML = 5 # The HTML parser
XML_FROM_MEMORY = 6 # The memory allocator
XML_FROM_OUTPUT = 7 # The serialization code
XML_FROM_IO = 8 # The Input/Output stack
XML_FROM_FTP = 9 # The FTP module
XML_FROM_HTTP = 10 # The HTTP module
XML_FROM_XINCLUDE = 11 # The XInclude processing
XML_FROM_XPATH = 12 # The XPath module
XML_FROM_XPOINTER = 13 # The XPointer module
XML_FROM_REGEXP = 14 # The regular expressions module
XML_FROM_DATATYPE = 15 # The W3C XML Schemas Datatype module
XML_FROM_SCHEMASP = 16 # The W3C XML Schemas parser module
XML_FROM_SCHEMASV = 17 # The W3C XML Schemas validation module
XML_FROM_RELAXNGP = 18 # The Relax-NG parser module
XML_FROM_RELAXNGV = 19 # The Relax-NG validator module
XML_FROM_CATALOG = 20 # The Catalog module
XML_FROM_C14N = 21 # The Canonicalization module
XML_FROM_XSLT = 22 # The XSLT engine from libxslt
XML_FROM_VALID = 23 # The XML DTD validation with valid context
XML_FROM_CHECK = 24 # The error checking module
XML_FROM_WRITER = 25 # The xmlwriter module
XML_FROM_MODULE = 26 # The dynamically loaded module modul
XML_FROM_I18N = 27 # The module handling character conversion
XML_FROM_SCHEMATRONV = 28 # The Schematron validator module
XML_FROM_BUFFER = 29 # The buffers module
XML_FROM_URI = 30 # The URI module
ctypedef enum xmlParserErrors:
XML_ERR_OK = 0
XML_ERR_INTERNAL_ERROR = 1
XML_ERR_NO_MEMORY = 2
XML_ERR_DOCUMENT_START = 3
XML_ERR_DOCUMENT_EMPTY = 4
XML_ERR_DOCUMENT_END = 5
XML_ERR_INVALID_HEX_CHARREF = 6
XML_ERR_INVALID_DEC_CHARREF = 7
XML_ERR_INVALID_CHARREF = 8
XML_ERR_INVALID_CHAR = 9
XML_ERR_CHARREF_AT_EOF = 10
XML_ERR_CHARREF_IN_PROLOG = 11
XML_ERR_CHARREF_IN_EPILOG = 12
XML_ERR_CHARREF_IN_DTD = 13
XML_ERR_ENTITYREF_AT_EOF = 14
XML_ERR_ENTITYREF_IN_PROLOG = 15
XML_ERR_ENTITYREF_IN_EPILOG = 16
XML_ERR_ENTITYREF_IN_DTD = 17
XML_ERR_PEREF_AT_EOF = 18
XML_ERR_PEREF_IN_PROLOG = 19
XML_ERR_PEREF_IN_EPILOG = 20
XML_ERR_PEREF_IN_INT_SUBSET = 21
XML_ERR_ENTITYREF_NO_NAME = 22
XML_ERR_ENTITYREF_SEMICOL_MISSING = 23
XML_ERR_PEREF_NO_NAME = 24
XML_ERR_PEREF_SEMICOL_MISSING = 25
XML_ERR_UNDECLARED_ENTITY = 26
XML_WAR_UNDECLARED_ENTITY = 27
XML_ERR_UNPARSED_ENTITY = 28
XML_ERR_ENTITY_IS_EXTERNAL = 29
XML_ERR_ENTITY_IS_PARAMETER = 30
XML_ERR_UNKNOWN_ENCODING = 31
XML_ERR_UNSUPPORTED_ENCODING = 32
XML_ERR_STRING_NOT_STARTED = 33
XML_ERR_STRING_NOT_CLOSED = 34
XML_ERR_NS_DECL_ERROR = 35
XML_ERR_ENTITY_NOT_STARTED = 36
XML_ERR_ENTITY_NOT_FINISHED = 37
XML_ERR_LT_IN_ATTRIBUTE = 38
XML_ERR_ATTRIBUTE_NOT_STARTED = 39
XML_ERR_ATTRIBUTE_NOT_FINISHED = 40
XML_ERR_ATTRIBUTE_WITHOUT_VALUE = 41
XML_ERR_ATTRIBUTE_REDEFINED = 42
XML_ERR_LITERAL_NOT_STARTED = 43
XML_ERR_LITERAL_NOT_FINISHED = 44
XML_ERR_COMMENT_NOT_FINISHED = 45
XML_ERR_PI_NOT_STARTED = 46
XML_ERR_PI_NOT_FINISHED = 47
XML_ERR_NOTATION_NOT_STARTED = 48
XML_ERR_NOTATION_NOT_FINISHED = 49
XML_ERR_ATTLIST_NOT_STARTED = 50
XML_ERR_ATTLIST_NOT_FINISHED = 51
XML_ERR_MIXED_NOT_STARTED = 52
XML_ERR_MIXED_NOT_FINISHED = 53
XML_ERR_ELEMCONTENT_NOT_STARTED = 54
XML_ERR_ELEMCONTENT_NOT_FINISHED = 55
XML_ERR_XMLDECL_NOT_STARTED = 56
XML_ERR_XMLDECL_NOT_FINISHED = 57
XML_ERR_CONDSEC_NOT_STARTED = 58
XML_ERR_CONDSEC_NOT_FINISHED = 59
XML_ERR_EXT_SUBSET_NOT_FINISHED = 60
XML_ERR_DOCTYPE_NOT_FINISHED = 61
XML_ERR_MISPLACED_CDATA_END = 62
XML_ERR_CDATA_NOT_FINISHED = 63
XML_ERR_RESERVED_XML_NAME = 64
XML_ERR_SPACE_REQUIRED = 65
XML_ERR_SEPARATOR_REQUIRED = 66
XML_ERR_NMTOKEN_REQUIRED = 67
XML_ERR_NAME_REQUIRED = 68
XML_ERR_PCDATA_REQUIRED = 69
XML_ERR_URI_REQUIRED = 70
XML_ERR_PUBID_REQUIRED = 71
XML_ERR_LT_REQUIRED = 72
XML_ERR_GT_REQUIRED = 73
XML_ERR_LTSLASH_REQUIRED = 74
XML_ERR_EQUAL_REQUIRED = 75
XML_ERR_TAG_NAME_MISMATCH = 76
XML_ERR_TAG_NOT_FINISHED = 77
XML_ERR_STANDALONE_VALUE = 78
XML_ERR_ENCODING_NAME = 79
XML_ERR_HYPHEN_IN_COMMENT = 80
XML_ERR_INVALID_ENCODING = 81
XML_ERR_EXT_ENTITY_STANDALONE = 82
XML_ERR_CONDSEC_INVALID = 83
XML_ERR_VALUE_REQUIRED = 84
XML_ERR_NOT_WELL_BALANCED = 85
XML_ERR_EXTRA_CONTENT = 86
XML_ERR_ENTITY_CHAR_ERROR = 87
XML_ERR_ENTITY_PE_INTERNAL = 88
XML_ERR_ENTITY_LOOP = 89
XML_ERR_ENTITY_BOUNDARY = 90
XML_ERR_INVALID_URI = 91
XML_ERR_URI_FRAGMENT = 92
XML_WAR_CATALOG_PI = 93
XML_ERR_NO_DTD = 94
XML_ERR_CONDSEC_INVALID_KEYWORD = 95
XML_ERR_VERSION_MISSING = 96
XML_WAR_UNKNOWN_VERSION = 97
XML_WAR_LANG_VALUE = 98
XML_WAR_NS_URI = 99
XML_WAR_NS_URI_RELATIVE = 100
XML_ERR_MISSING_ENCODING = 101
XML_WAR_SPACE_VALUE = 102
XML_ERR_NOT_STANDALONE = 103
XML_ERR_ENTITY_PROCESSING = 104
XML_ERR_NOTATION_PROCESSING = 105
XML_WAR_NS_COLUMN = 106
XML_WAR_ENTITY_REDEFINED = 107
XML_ERR_UNKNOWN_VERSION = 108
XML_ERR_VERSION_MISMATCH = 109
XML_ERR_NAME_TOO_LONG = 110
XML_ERR_USER_STOP = 111
XML_ERR_COMMENT_ABRUPTLY_ENDED = 112
XML_NS_ERR_XML_NAMESPACE = 200
XML_NS_ERR_UNDEFINED_NAMESPACE = 201
XML_NS_ERR_QNAME = 202
XML_NS_ERR_ATTRIBUTE_REDEFINED = 203
XML_NS_ERR_EMPTY = 204
XML_NS_ERR_COLON = 205
XML_DTD_ATTRIBUTE_DEFAULT = 500
XML_DTD_ATTRIBUTE_REDEFINED = 501
XML_DTD_ATTRIBUTE_VALUE = 502
XML_DTD_CONTENT_ERROR = 503
XML_DTD_CONTENT_MODEL = 504
XML_DTD_CONTENT_NOT_DETERMINIST = 505
XML_DTD_DIFFERENT_PREFIX = 506
XML_DTD_ELEM_DEFAULT_NAMESPACE = 507
XML_DTD_ELEM_NAMESPACE = 508
XML_DTD_ELEM_REDEFINED = 509
XML_DTD_EMPTY_NOTATION = 510
XML_DTD_ENTITY_TYPE = 511
XML_DTD_ID_FIXED = 512
XML_DTD_ID_REDEFINED = 513
XML_DTD_ID_SUBSET = 514
XML_DTD_INVALID_CHILD = 515
XML_DTD_INVALID_DEFAULT = 516
XML_DTD_LOAD_ERROR = 517
XML_DTD_MISSING_ATTRIBUTE = 518
XML_DTD_MIXED_CORRUPT = 519
XML_DTD_MULTIPLE_ID = 520
XML_DTD_NO_DOC = 521
XML_DTD_NO_DTD = 522
XML_DTD_NO_ELEM_NAME = 523
XML_DTD_NO_PREFIX = 524
XML_DTD_NO_ROOT = 525
XML_DTD_NOTATION_REDEFINED = 526
XML_DTD_NOTATION_VALUE = 527
XML_DTD_NOT_EMPTY = 528
XML_DTD_NOT_PCDATA = 529
XML_DTD_NOT_STANDALONE = 530
XML_DTD_ROOT_NAME = 531
XML_DTD_STANDALONE_WHITE_SPACE = 532
XML_DTD_UNKNOWN_ATTRIBUTE = 533
XML_DTD_UNKNOWN_ELEM = 534
XML_DTD_UNKNOWN_ENTITY = 535
XML_DTD_UNKNOWN_ID = 536
XML_DTD_UNKNOWN_NOTATION = 537
XML_DTD_STANDALONE_DEFAULTED = 538
XML_DTD_XMLID_VALUE = 539
XML_DTD_XMLID_TYPE = 540
XML_DTD_DUP_TOKEN = 541
XML_HTML_STRUCURE_ERROR = 800
XML_HTML_UNKNOWN_TAG = 801
XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000
XML_RNGP_ATTR_CONFLICT = 1001
XML_RNGP_ATTRIBUTE_CHILDREN = 1002
XML_RNGP_ATTRIBUTE_CONTENT = 1003
XML_RNGP_ATTRIBUTE_EMPTY = 1004
XML_RNGP_ATTRIBUTE_NOOP = 1005
XML_RNGP_CHOICE_CONTENT = 1006
XML_RNGP_CHOICE_EMPTY = 1007
XML_RNGP_CREATE_FAILURE = 1008
XML_RNGP_DATA_CONTENT = 1009
XML_RNGP_DEF_CHOICE_AND_INTERLEAVE = 1010
XML_RNGP_DEFINE_CREATE_FAILED = 1011
XML_RNGP_DEFINE_EMPTY = 1012
XML_RNGP_DEFINE_MISSING = 1013
XML_RNGP_DEFINE_NAME_MISSING = 1014
XML_RNGP_ELEM_CONTENT_EMPTY = 1015
XML_RNGP_ELEM_CONTENT_ERROR = 1016
XML_RNGP_ELEMENT_EMPTY = 1017
XML_RNGP_ELEMENT_CONTENT = 1018
XML_RNGP_ELEMENT_NAME = 1019
XML_RNGP_ELEMENT_NO_CONTENT = 1020
XML_RNGP_ELEM_TEXT_CONFLICT = 1021
XML_RNGP_EMPTY = 1022
XML_RNGP_EMPTY_CONSTRUCT = 1023
XML_RNGP_EMPTY_CONTENT = 1024
XML_RNGP_EMPTY_NOT_EMPTY = 1025
XML_RNGP_ERROR_TYPE_LIB = 1026
XML_RNGP_EXCEPT_EMPTY = 1027
XML_RNGP_EXCEPT_MISSING = 1028
XML_RNGP_EXCEPT_MULTIPLE = 1029
XML_RNGP_EXCEPT_NO_CONTENT = 1030
XML_RNGP_EXTERNALREF_EMTPY = 1031
XML_RNGP_EXTERNAL_REF_FAILURE = 1032
XML_RNGP_EXTERNALREF_RECURSE = 1033
XML_RNGP_FORBIDDEN_ATTRIBUTE = 1034
XML_RNGP_FOREIGN_ELEMENT = 1035
XML_RNGP_GRAMMAR_CONTENT = 1036
XML_RNGP_GRAMMAR_EMPTY = 1037
XML_RNGP_GRAMMAR_MISSING = 1038
XML_RNGP_GRAMMAR_NO_START = 1039
XML_RNGP_GROUP_ATTR_CONFLICT = 1040
XML_RNGP_HREF_ERROR = 1041
XML_RNGP_INCLUDE_EMPTY = 1042
XML_RNGP_INCLUDE_FAILURE = 1043
XML_RNGP_INCLUDE_RECURSE = 1044
XML_RNGP_INTERLEAVE_ADD = 1045
XML_RNGP_INTERLEAVE_CREATE_FAILED = 1046
XML_RNGP_INTERLEAVE_EMPTY = 1047
XML_RNGP_INTERLEAVE_NO_CONTENT = 1048
XML_RNGP_INVALID_DEFINE_NAME = 1049
XML_RNGP_INVALID_URI = 1050
XML_RNGP_INVALID_VALUE = 1051
XML_RNGP_MISSING_HREF = 1052
XML_RNGP_NAME_MISSING = 1053
XML_RNGP_NEED_COMBINE = 1054
XML_RNGP_NOTALLOWED_NOT_EMPTY = 1055
XML_RNGP_NSNAME_ATTR_ANCESTOR = 1056
XML_RNGP_NSNAME_NO_NS = 1057
XML_RNGP_PARAM_FORBIDDEN = 1058
XML_RNGP_PARAM_NAME_MISSING = 1059
XML_RNGP_PARENTREF_CREATE_FAILED = 1060
XML_RNGP_PARENTREF_NAME_INVALID = 1061
XML_RNGP_PARENTREF_NO_NAME = 1062
XML_RNGP_PARENTREF_NO_PARENT = 1063
XML_RNGP_PARENTREF_NOT_EMPTY = 1064
XML_RNGP_PARSE_ERROR = 1065
XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME = 1066
XML_RNGP_PAT_ATTR_ATTR = 1067
XML_RNGP_PAT_ATTR_ELEM = 1068
XML_RNGP_PAT_DATA_EXCEPT_ATTR = 1069
XML_RNGP_PAT_DATA_EXCEPT_ELEM = 1070
XML_RNGP_PAT_DATA_EXCEPT_EMPTY = 1071
XML_RNGP_PAT_DATA_EXCEPT_GROUP = 1072
XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE = 1073
XML_RNGP_PAT_DATA_EXCEPT_LIST = 1074
XML_RNGP_PAT_DATA_EXCEPT_ONEMORE = 1075
XML_RNGP_PAT_DATA_EXCEPT_REF = 1076
XML_RNGP_PAT_DATA_EXCEPT_TEXT = 1077
XML_RNGP_PAT_LIST_ATTR = 1078
XML_RNGP_PAT_LIST_ELEM = 1079
XML_RNGP_PAT_LIST_INTERLEAVE = 1080
XML_RNGP_PAT_LIST_LIST = 1081
XML_RNGP_PAT_LIST_REF = 1082
XML_RNGP_PAT_LIST_TEXT = 1083
XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME = 1084
XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME = 1085
XML_RNGP_PAT_ONEMORE_GROUP_ATTR = 1086
XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR = 1087
XML_RNGP_PAT_START_ATTR = 1088
XML_RNGP_PAT_START_DATA = 1089
XML_RNGP_PAT_START_EMPTY = 1090
XML_RNGP_PAT_START_GROUP = 1091
XML_RNGP_PAT_START_INTERLEAVE = 1092
XML_RNGP_PAT_START_LIST = 1093
XML_RNGP_PAT_START_ONEMORE = 1094
XML_RNGP_PAT_START_TEXT = 1095
XML_RNGP_PAT_START_VALUE = 1096
XML_RNGP_PREFIX_UNDEFINED = 1097
XML_RNGP_REF_CREATE_FAILED = 1098
XML_RNGP_REF_CYCLE = 1099
XML_RNGP_REF_NAME_INVALID = 1100
XML_RNGP_REF_NO_DEF = 1101
XML_RNGP_REF_NO_NAME = 1102
XML_RNGP_REF_NOT_EMPTY = 1103
XML_RNGP_START_CHOICE_AND_INTERLEAVE = 1104
XML_RNGP_START_CONTENT = 1105
XML_RNGP_START_EMPTY = 1106
XML_RNGP_START_MISSING = 1107
XML_RNGP_TEXT_EXPECTED = 1108
XML_RNGP_TEXT_HAS_CHILD = 1109
XML_RNGP_TYPE_MISSING = 1110
XML_RNGP_TYPE_NOT_FOUND = 1111
XML_RNGP_TYPE_VALUE = 1112
XML_RNGP_UNKNOWN_ATTRIBUTE = 1113
XML_RNGP_UNKNOWN_COMBINE = 1114
XML_RNGP_UNKNOWN_CONSTRUCT = 1115
XML_RNGP_UNKNOWN_TYPE_LIB = 1116
XML_RNGP_URI_FRAGMENT = 1117
XML_RNGP_URI_NOT_ABSOLUTE = 1118
XML_RNGP_VALUE_EMPTY = 1119
XML_RNGP_VALUE_NO_CONTENT = 1120
XML_RNGP_XMLNS_NAME = 1121
XML_RNGP_XML_NS = 1122
XML_XPATH_EXPRESSION_OK = 1200
XML_XPATH_NUMBER_ERROR = 1201
XML_XPATH_UNFINISHED_LITERAL_ERROR = 1202
XML_XPATH_START_LITERAL_ERROR = 1203
XML_XPATH_VARIABLE_REF_ERROR = 1204
XML_XPATH_UNDEF_VARIABLE_ERROR = 1205
XML_XPATH_INVALID_PREDICATE_ERROR = 1206
XML_XPATH_EXPR_ERROR = 1207
XML_XPATH_UNCLOSED_ERROR = 1208
XML_XPATH_UNKNOWN_FUNC_ERROR = 1209
XML_XPATH_INVALID_OPERAND = 1210
XML_XPATH_INVALID_TYPE = 1211
XML_XPATH_INVALID_ARITY = 1212
XML_XPATH_INVALID_CTXT_SIZE = 1213
XML_XPATH_INVALID_CTXT_POSITION = 1214
XML_XPATH_MEMORY_ERROR = 1215
XML_XPTR_SYNTAX_ERROR = 1216
XML_XPTR_RESOURCE_ERROR = 1217
XML_XPTR_SUB_RESOURCE_ERROR = 1218
XML_XPATH_UNDEF_PREFIX_ERROR = 1219
XML_XPATH_ENCODING_ERROR = 1220
XML_XPATH_INVALID_CHAR_ERROR = 1221
XML_TREE_INVALID_HEX = 1300
XML_TREE_INVALID_DEC = 1301
XML_TREE_UNTERMINATED_ENTITY = 1302
XML_TREE_NOT_UTF8 = 1303
XML_SAVE_NOT_UTF8 = 1400
XML_SAVE_CHAR_INVALID = 1401
XML_SAVE_NO_DOCTYPE = 1402
XML_SAVE_UNKNOWN_ENCODING = 1403
XML_REGEXP_COMPILE_ERROR = 1450
XML_IO_UNKNOWN = 1500
XML_IO_EACCES = 1501
XML_IO_EAGAIN = 1502
XML_IO_EBADF = 1503
XML_IO_EBADMSG = 1504
XML_IO_EBUSY = 1505
XML_IO_ECANCELED = 1506
XML_IO_ECHILD = 1507
XML_IO_EDEADLK = 1508
XML_IO_EDOM = 1509
XML_IO_EEXIST = 1510
XML_IO_EFAULT = 1511
XML_IO_EFBIG = 1512
XML_IO_EINPROGRESS = 1513
XML_IO_EINTR = 1514
XML_IO_EINVAL = 1515
XML_IO_EIO = 1516
XML_IO_EISDIR = 1517
XML_IO_EMFILE = 1518
XML_IO_EMLINK = 1519
XML_IO_EMSGSIZE = 1520
XML_IO_ENAMETOOLONG = 1521
XML_IO_ENFILE = 1522
XML_IO_ENODEV = 1523
XML_IO_ENOENT = 1524
XML_IO_ENOEXEC = 1525
XML_IO_ENOLCK = 1526
XML_IO_ENOMEM = 1527
XML_IO_ENOSPC = 1528
XML_IO_ENOSYS = 1529
XML_IO_ENOTDIR = 1530
XML_IO_ENOTEMPTY = 1531
XML_IO_ENOTSUP = 1532
XML_IO_ENOTTY = 1533
XML_IO_ENXIO = 1534
XML_IO_EPERM = 1535
XML_IO_EPIPE = 1536
XML_IO_ERANGE = 1537
XML_IO_EROFS = 1538
XML_IO_ESPIPE = 1539
XML_IO_ESRCH = 1540
XML_IO_ETIMEDOUT = 1541
XML_IO_EXDEV = 1542
XML_IO_NETWORK_ATTEMPT = 1543
XML_IO_ENCODER = 1544
XML_IO_FLUSH = 1545
XML_IO_WRITE = 1546
XML_IO_NO_INPUT = 1547
XML_IO_BUFFER_FULL = 1548
XML_IO_LOAD_ERROR = 1549
XML_IO_ENOTSOCK = 1550
XML_IO_EISCONN = 1551
XML_IO_ECONNREFUSED = 1552
XML_IO_ENETUNREACH = 1553
XML_IO_EADDRINUSE = 1554
XML_IO_EALREADY = 1555
XML_IO_EAFNOSUPPORT = 1556
XML_XINCLUDE_RECURSION = 1600
XML_XINCLUDE_PARSE_VALUE = 1601
XML_XINCLUDE_ENTITY_DEF_MISMATCH = 1602
XML_XINCLUDE_NO_HREF = 1603
XML_XINCLUDE_NO_FALLBACK = 1604
XML_XINCLUDE_HREF_URI = 1605
XML_XINCLUDE_TEXT_FRAGMENT = 1606
XML_XINCLUDE_TEXT_DOCUMENT = 1607
XML_XINCLUDE_INVALID_CHAR = 1608
XML_XINCLUDE_BUILD_FAILED = 1609
XML_XINCLUDE_UNKNOWN_ENCODING = 1610
XML_XINCLUDE_MULTIPLE_ROOT = 1611
XML_XINCLUDE_XPTR_FAILED = 1612
XML_XINCLUDE_XPTR_RESULT = 1613
XML_XINCLUDE_INCLUDE_IN_INCLUDE = 1614
XML_XINCLUDE_FALLBACKS_IN_INCLUDE = 1615
XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE = 1616
XML_XINCLUDE_DEPRECATED_NS = 1617
XML_XINCLUDE_FRAGMENT_ID = 1618
XML_CATALOG_MISSING_ATTR = 1650
XML_CATALOG_ENTRY_BROKEN = 1651
XML_CATALOG_PREFER_VALUE = 1652
XML_CATALOG_NOT_CATALOG = 1653
XML_CATALOG_RECURSION = 1654
XML_SCHEMAP_PREFIX_UNDEFINED = 1700
XML_SCHEMAP_ATTRFORMDEFAULT_VALUE = 1701
XML_SCHEMAP_ATTRGRP_NONAME_NOREF = 1702
XML_SCHEMAP_ATTR_NONAME_NOREF = 1703
XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF = 1704
XML_SCHEMAP_ELEMFORMDEFAULT_VALUE = 1705
XML_SCHEMAP_ELEM_NONAME_NOREF = 1706
XML_SCHEMAP_EXTENSION_NO_BASE = 1707
XML_SCHEMAP_FACET_NO_VALUE = 1708
XML_SCHEMAP_FAILED_BUILD_IMPORT = 1709
XML_SCHEMAP_GROUP_NONAME_NOREF = 1710
XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI = 1711
XML_SCHEMAP_IMPORT_REDEFINE_NSNAME = 1712
XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI = 1713
XML_SCHEMAP_INVALID_BOOLEAN = 1714
XML_SCHEMAP_INVALID_ENUM = 1715
XML_SCHEMAP_INVALID_FACET = 1716
XML_SCHEMAP_INVALID_FACET_VALUE = 1717
XML_SCHEMAP_INVALID_MAXOCCURS = 1718
XML_SCHEMAP_INVALID_MINOCCURS = 1719
XML_SCHEMAP_INVALID_REF_AND_SUBTYPE = 1720
XML_SCHEMAP_INVALID_WHITE_SPACE = 1721
XML_SCHEMAP_NOATTR_NOREF = 1722
XML_SCHEMAP_NOTATION_NO_NAME = 1723
XML_SCHEMAP_NOTYPE_NOREF = 1724
XML_SCHEMAP_REF_AND_SUBTYPE = 1725
XML_SCHEMAP_RESTRICTION_NONAME_NOREF = 1726
XML_SCHEMAP_SIMPLETYPE_NONAME = 1727
XML_SCHEMAP_TYPE_AND_SUBTYPE = 1728
XML_SCHEMAP_UNKNOWN_ALL_CHILD = 1729
XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD = 1730
XML_SCHEMAP_UNKNOWN_ATTR_CHILD = 1731
XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD = 1732
XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP = 1733
XML_SCHEMAP_UNKNOWN_BASE_TYPE = 1734
XML_SCHEMAP_UNKNOWN_CHOICE_CHILD = 1735
XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD = 1736
XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD = 1737
XML_SCHEMAP_UNKNOWN_ELEM_CHILD = 1738
XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD = 1739
XML_SCHEMAP_UNKNOWN_FACET_CHILD = 1740
XML_SCHEMAP_UNKNOWN_FACET_TYPE = 1741
XML_SCHEMAP_UNKNOWN_GROUP_CHILD = 1742
XML_SCHEMAP_UNKNOWN_IMPORT_CHILD = 1743
XML_SCHEMAP_UNKNOWN_LIST_CHILD = 1744
XML_SCHEMAP_UNKNOWN_NOTATION_CHILD = 1745
XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD = 1746
XML_SCHEMAP_UNKNOWN_REF = 1747
XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD = 1748
XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD = 1749
XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD = 1750
XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD = 1751
XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD = 1752
XML_SCHEMAP_UNKNOWN_TYPE = 1753
XML_SCHEMAP_UNKNOWN_UNION_CHILD = 1754
XML_SCHEMAP_ELEM_DEFAULT_FIXED = 1755
XML_SCHEMAP_REGEXP_INVALID = 1756
XML_SCHEMAP_FAILED_LOAD = 1757
XML_SCHEMAP_NOTHING_TO_PARSE = 1758
XML_SCHEMAP_NOROOT = 1759
XML_SCHEMAP_REDEFINED_GROUP = 1760
XML_SCHEMAP_REDEFINED_TYPE = 1761
XML_SCHEMAP_REDEFINED_ELEMENT = 1762
XML_SCHEMAP_REDEFINED_ATTRGROUP = 1763
XML_SCHEMAP_REDEFINED_ATTR = 1764
XML_SCHEMAP_REDEFINED_NOTATION = 1765
XML_SCHEMAP_FAILED_PARSE = 1766
XML_SCHEMAP_UNKNOWN_PREFIX = 1767
XML_SCHEMAP_DEF_AND_PREFIX = 1768
XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD = 1769
XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI = 1770
XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI = 1771
XML_SCHEMAP_NOT_SCHEMA = 1772
XML_SCHEMAP_UNKNOWN_MEMBER_TYPE = 1773
XML_SCHEMAP_INVALID_ATTR_USE = 1774
XML_SCHEMAP_RECURSIVE = 1775
XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE = 1776
XML_SCHEMAP_INVALID_ATTR_COMBINATION = 1777
XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION = 1778
XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD = 1779
XML_SCHEMAP_INVALID_ATTR_NAME = 1780
XML_SCHEMAP_REF_AND_CONTENT = 1781
XML_SCHEMAP_CT_PROPS_CORRECT_1 = 1782
XML_SCHEMAP_CT_PROPS_CORRECT_2 = 1783
XML_SCHEMAP_CT_PROPS_CORRECT_3 = 1784
XML_SCHEMAP_CT_PROPS_CORRECT_4 = 1785
XML_SCHEMAP_CT_PROPS_CORRECT_5 = 1786
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1 = 1787
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1 = 1788
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2 = 1789
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2 = 1790
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3 = 1791
XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER = 1792
XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE = 1793
XML_SCHEMAP_UNION_NOT_EXPRESSIBLE = 1794
XML_SCHEMAP_SRC_IMPORT_3_1 = 1795
XML_SCHEMAP_SRC_IMPORT_3_2 = 1796
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1 = 1797
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2 = 1798
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3 = 1799
XML_SCHEMAP_COS_CT_EXTENDS_1_3 = 1800
XML_SCHEMAV_NOROOT = 1801
XML_SCHEMAV_UNDECLAREDELEM = 1802
XML_SCHEMAV_NOTTOPLEVEL = 1803
XML_SCHEMAV_MISSING = 1804
XML_SCHEMAV_WRONGELEM = 1805
XML_SCHEMAV_NOTYPE = 1806
XML_SCHEMAV_NOROLLBACK = 1807
XML_SCHEMAV_ISABSTRACT = 1808
XML_SCHEMAV_NOTEMPTY = 1809
XML_SCHEMAV_ELEMCONT = 1810
XML_SCHEMAV_HAVEDEFAULT = 1811
XML_SCHEMAV_NOTNILLABLE = 1812
XML_SCHEMAV_EXTRACONTENT = 1813
XML_SCHEMAV_INVALIDATTR = 1814
XML_SCHEMAV_INVALIDELEM = 1815
XML_SCHEMAV_NOTDETERMINIST = 1816
XML_SCHEMAV_CONSTRUCT = 1817
XML_SCHEMAV_INTERNAL = 1818
XML_SCHEMAV_NOTSIMPLE = 1819
XML_SCHEMAV_ATTRUNKNOWN = 1820
XML_SCHEMAV_ATTRINVALID = 1821
XML_SCHEMAV_VALUE = 1822
XML_SCHEMAV_FACET = 1823
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1 = 1824
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2 = 1825
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3 = 1826
XML_SCHEMAV_CVC_TYPE_3_1_1 = 1827
XML_SCHEMAV_CVC_TYPE_3_1_2 = 1828
XML_SCHEMAV_CVC_FACET_VALID = 1829
XML_SCHEMAV_CVC_LENGTH_VALID = 1830
XML_SCHEMAV_CVC_MINLENGTH_VALID = 1831
XML_SCHEMAV_CVC_MAXLENGTH_VALID = 1832
XML_SCHEMAV_CVC_MININCLUSIVE_VALID = 1833
XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID = 1834
XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID = 1835
XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID = 1836
XML_SCHEMAV_CVC_TOTALDIGITS_VALID = 1837
XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID = 1838
XML_SCHEMAV_CVC_PATTERN_VALID = 1839
XML_SCHEMAV_CVC_ENUMERATION_VALID = 1840
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1 = 1841
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2 = 1842
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3 = 1843
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4 = 1844
XML_SCHEMAV_CVC_ELT_1 = 1845
XML_SCHEMAV_CVC_ELT_2 = 1846
XML_SCHEMAV_CVC_ELT_3_1 = 1847
XML_SCHEMAV_CVC_ELT_3_2_1 = 1848
XML_SCHEMAV_CVC_ELT_3_2_2 = 1849
XML_SCHEMAV_CVC_ELT_4_1 = 1850
XML_SCHEMAV_CVC_ELT_4_2 = 1851
XML_SCHEMAV_CVC_ELT_4_3 = 1852
XML_SCHEMAV_CVC_ELT_5_1_1 = 1853
XML_SCHEMAV_CVC_ELT_5_1_2 = 1854
XML_SCHEMAV_CVC_ELT_5_2_1 = 1855
XML_SCHEMAV_CVC_ELT_5_2_2_1 = 1856
XML_SCHEMAV_CVC_ELT_5_2_2_2_1 = 1857
XML_SCHEMAV_CVC_ELT_5_2_2_2_2 = 1858
XML_SCHEMAV_CVC_ELT_6 = 1859
XML_SCHEMAV_CVC_ELT_7 = 1860
XML_SCHEMAV_CVC_ATTRIBUTE_1 = 1861
XML_SCHEMAV_CVC_ATTRIBUTE_2 = 1862
XML_SCHEMAV_CVC_ATTRIBUTE_3 = 1863
XML_SCHEMAV_CVC_ATTRIBUTE_4 = 1864
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1 = 1865
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1 = 1866
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2 = 1867
XML_SCHEMAV_CVC_COMPLEX_TYPE_4 = 1868
XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1 = 1869
XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2 = 1870
XML_SCHEMAV_ELEMENT_CONTENT = 1871
XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING = 1872
XML_SCHEMAV_CVC_COMPLEX_TYPE_1 = 1873
XML_SCHEMAV_CVC_AU = 1874
XML_SCHEMAV_CVC_TYPE_1 = 1875
XML_SCHEMAV_CVC_TYPE_2 = 1876
XML_SCHEMAV_CVC_IDC = 1877
XML_SCHEMAV_CVC_WILDCARD = 1878
XML_SCHEMAV_MISC = 1879
XML_XPTR_UNKNOWN_SCHEME = 1900
XML_XPTR_CHILDSEQ_START = 1901
XML_XPTR_EVAL_FAILED = 1902
XML_XPTR_EXTRA_OBJECTS = 1903
XML_C14N_CREATE_CTXT = 1950
XML_C14N_REQUIRES_UTF8 = 1951
XML_C14N_CREATE_STACK = 1952
XML_C14N_INVALID_NODE = 1953
XML_C14N_UNKNOW_NODE = 1954
XML_C14N_RELATIVE_NAMESPACE = 1955
XML_FTP_PASV_ANSWER = 2000
XML_FTP_EPSV_ANSWER = 2001
XML_FTP_ACCNT = 2002
XML_FTP_URL_SYNTAX = 2003
XML_HTTP_URL_SYNTAX = 2020
XML_HTTP_USE_IP = 2021
XML_HTTP_UNKNOWN_HOST = 2022
XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000
XML_SCHEMAP_SRC_SIMPLE_TYPE_2 = 3001
XML_SCHEMAP_SRC_SIMPLE_TYPE_3 = 3002
XML_SCHEMAP_SRC_SIMPLE_TYPE_4 = 3003
XML_SCHEMAP_SRC_RESOLVE = 3004
XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE = 3005
XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE = 3006
XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES = 3007
XML_SCHEMAP_ST_PROPS_CORRECT_1 = 3008
XML_SCHEMAP_ST_PROPS_CORRECT_2 = 3009
XML_SCHEMAP_ST_PROPS_CORRECT_3 = 3010
XML_SCHEMAP_COS_ST_RESTRICTS_1_1 = 3011
XML_SCHEMAP_COS_ST_RESTRICTS_1_2 = 3012
XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1 = 3013
XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2 = 3014
XML_SCHEMAP_COS_ST_RESTRICTS_2_1 = 3015
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1 = 3016
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2 = 3017
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1 = 3018
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2 = 3019
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3 = 3020
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4 = 3021
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5 = 3022
XML_SCHEMAP_COS_ST_RESTRICTS_3_1 = 3023
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1 = 3024
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2 = 3025
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2 = 3026
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1 = 3027
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3 = 3028
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4 = 3029
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5 = 3030
XML_SCHEMAP_COS_ST_DERIVED_OK_2_1 = 3031
XML_SCHEMAP_COS_ST_DERIVED_OK_2_2 = 3032
XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED = 3033
XML_SCHEMAP_S4S_ELEM_MISSING = 3034
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED = 3035
XML_SCHEMAP_S4S_ATTR_MISSING = 3036
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE = 3037
XML_SCHEMAP_SRC_ELEMENT_1 = 3038
XML_SCHEMAP_SRC_ELEMENT_2_1 = 3039
XML_SCHEMAP_SRC_ELEMENT_2_2 = 3040
XML_SCHEMAP_SRC_ELEMENT_3 = 3041
XML_SCHEMAP_P_PROPS_CORRECT_1 = 3042
XML_SCHEMAP_P_PROPS_CORRECT_2_1 = 3043
XML_SCHEMAP_P_PROPS_CORRECT_2_2 = 3044
XML_SCHEMAP_E_PROPS_CORRECT_2 = 3045
XML_SCHEMAP_E_PROPS_CORRECT_3 = 3046
XML_SCHEMAP_E_PROPS_CORRECT_4 = 3047
XML_SCHEMAP_E_PROPS_CORRECT_5 = 3048
XML_SCHEMAP_E_PROPS_CORRECT_6 = 3049
XML_SCHEMAP_SRC_INCLUDE = 3050
XML_SCHEMAP_SRC_ATTRIBUTE_1 = 3051
XML_SCHEMAP_SRC_ATTRIBUTE_2 = 3052
XML_SCHEMAP_SRC_ATTRIBUTE_3_1 = 3053
XML_SCHEMAP_SRC_ATTRIBUTE_3_2 = 3054
XML_SCHEMAP_SRC_ATTRIBUTE_4 = 3055
XML_SCHEMAP_NO_XMLNS = 3056
XML_SCHEMAP_NO_XSI = 3057
XML_SCHEMAP_COS_VALID_DEFAULT_1 = 3058
XML_SCHEMAP_COS_VALID_DEFAULT_2_1 = 3059
XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1 = 3060
XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2 = 3061
XML_SCHEMAP_CVC_SIMPLE_TYPE = 3062
XML_SCHEMAP_COS_CT_EXTENDS_1_1 = 3063
XML_SCHEMAP_SRC_IMPORT_1_1 = 3064
XML_SCHEMAP_SRC_IMPORT_1_2 = 3065
XML_SCHEMAP_SRC_IMPORT_2 = 3066
XML_SCHEMAP_SRC_IMPORT_2_1 = 3067
XML_SCHEMAP_SRC_IMPORT_2_2 = 3068
XML_SCHEMAP_INTERNAL = 3069 # 3069 non-W3C
XML_SCHEMAP_NOT_DETERMINISTIC = 3070 # 3070 non-W3C
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1 = 3071
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2 = 3072
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3 = 3073
XML_SCHEMAP_MG_PROPS_CORRECT_1 = 3074
XML_SCHEMAP_MG_PROPS_CORRECT_2 = 3075
XML_SCHEMAP_SRC_CT_1 = 3076
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3 = 3077
XML_SCHEMAP_AU_PROPS_CORRECT_2 = 3078
XML_SCHEMAP_A_PROPS_CORRECT_2 = 3079
XML_SCHEMAP_C_PROPS_CORRECT = 3080
XML_SCHEMAP_SRC_REDEFINE = 3081
XML_SCHEMAP_SRC_IMPORT = 3082
XML_SCHEMAP_WARN_SKIP_SCHEMA = 3083
XML_SCHEMAP_WARN_UNLOCATED_SCHEMA = 3084
XML_SCHEMAP_WARN_ATTR_REDECL_PROH = 3085
XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH = 3086 # 3085
XML_SCHEMAP_AG_PROPS_CORRECT = 3087 # 3086
XML_SCHEMAP_COS_CT_EXTENDS_1_2 = 3088 # 3087
XML_SCHEMAP_AU_PROPS_CORRECT = 3089 # 3088
XML_SCHEMAP_A_PROPS_CORRECT_3 = 3090 # 3089
XML_SCHEMAP_COS_ALL_LIMITED = 3091 # 3090
XML_SCHEMATRONV_ASSERT = 4000
XML_SCHEMATRONV_REPORT = 4001
XML_MODULE_OPEN = 4900
XML_MODULE_CLOSE = 4901
XML_CHECK_FOUND_ELEMENT = 5000
XML_CHECK_FOUND_ATTRIBUTE = 5001
XML_CHECK_FOUND_TEXT = 5002
XML_CHECK_FOUND_CDATA = 5003
XML_CHECK_FOUND_ENTITYREF = 5004
XML_CHECK_FOUND_ENTITY = 5005
XML_CHECK_FOUND_PI = 5006
XML_CHECK_FOUND_COMMENT = 5007
XML_CHECK_FOUND_DOCTYPE = 5008
XML_CHECK_FOUND_FRAGMENT = 5009
XML_CHECK_FOUND_NOTATION = 5010
XML_CHECK_UNKNOWN_NODE = 5011
XML_CHECK_ENTITY_TYPE = 5012
XML_CHECK_NO_PARENT = 5013
XML_CHECK_NO_DOC = 5014
XML_CHECK_NO_NAME = 5015
XML_CHECK_NO_ELEM = 5016
XML_CHECK_WRONG_DOC = 5017
XML_CHECK_NO_PREV = 5018
XML_CHECK_WRONG_PREV = 5019
XML_CHECK_NO_NEXT = 5020
XML_CHECK_WRONG_NEXT = 5021
XML_CHECK_NOT_DTD = 5022
XML_CHECK_NOT_ATTR = 5023
XML_CHECK_NOT_ATTR_DECL = 5024
XML_CHECK_NOT_ELEM_DECL = 5025
XML_CHECK_NOT_ENTITY_DECL = 5026
XML_CHECK_NOT_NS_DECL = 5027
XML_CHECK_NO_HREF = 5028
XML_CHECK_WRONG_PARENT = 5029
XML_CHECK_NS_SCOPE = 5030
XML_CHECK_NS_ANCESTOR = 5031
XML_CHECK_NOT_UTF8 = 5032
XML_CHECK_NO_DICT = 5033
XML_CHECK_NOT_NCNAME = 5034
XML_CHECK_OUTSIDE_DICT = 5035
XML_CHECK_WRONG_NAME = 5036
XML_CHECK_NAME_NOT_NULL = 5037
XML_I18N_NO_NAME = 6000
XML_I18N_NO_HANDLER = 6001
XML_I18N_EXCESS_HANDLER = 6002
XML_I18N_CONV_FAILED = 6003
XML_I18N_NO_OUTPUT = 6004
XML_BUF_OVERFLOW = 7000
ctypedef enum xmlRelaxNGValidErr:
XML_RELAXNG_OK = 0
XML_RELAXNG_ERR_MEMORY = 1
XML_RELAXNG_ERR_TYPE = 2
XML_RELAXNG_ERR_TYPEVAL = 3
XML_RELAXNG_ERR_DUPID = 4
XML_RELAXNG_ERR_TYPECMP = 5
XML_RELAXNG_ERR_NOSTATE = 6
XML_RELAXNG_ERR_NODEFINE = 7
XML_RELAXNG_ERR_LISTEXTRA = 8
XML_RELAXNG_ERR_LISTEMPTY = 9
XML_RELAXNG_ERR_INTERNODATA = 10
XML_RELAXNG_ERR_INTERSEQ = 11
XML_RELAXNG_ERR_INTEREXTRA = 12
XML_RELAXNG_ERR_ELEMNAME = 13
XML_RELAXNG_ERR_ATTRNAME = 14
XML_RELAXNG_ERR_ELEMNONS = 15
XML_RELAXNG_ERR_ATTRNONS = 16
XML_RELAXNG_ERR_ELEMWRONGNS = 17
XML_RELAXNG_ERR_ATTRWRONGNS = 18
XML_RELAXNG_ERR_ELEMEXTRANS = 19
XML_RELAXNG_ERR_ATTREXTRANS = 20
XML_RELAXNG_ERR_ELEMNOTEMPTY = 21
XML_RELAXNG_ERR_NOELEM = 22
XML_RELAXNG_ERR_NOTELEM = 23
XML_RELAXNG_ERR_ATTRVALID = 24
XML_RELAXNG_ERR_CONTENTVALID = 25
XML_RELAXNG_ERR_EXTRACONTENT = 26
XML_RELAXNG_ERR_INVALIDATTR = 27
XML_RELAXNG_ERR_DATAELEM = 28
XML_RELAXNG_ERR_VALELEM = 29
XML_RELAXNG_ERR_LISTELEM = 30
XML_RELAXNG_ERR_DATATYPE = 31
XML_RELAXNG_ERR_VALUE = 32
XML_RELAXNG_ERR_LIST = 33
XML_RELAXNG_ERR_NOGRAMMAR = 34
XML_RELAXNG_ERR_EXTRADATA = 35
XML_RELAXNG_ERR_LACKDATA = 36
XML_RELAXNG_ERR_INTERNAL = 37
XML_RELAXNG_ERR_ELEMWRONG = 38
XML_RELAXNG_ERR_TEXTWRONG = 39
# --- END: GENERATED CONSTANTS ---
cdef extern from "libxml/xmlerror.h":
ctypedef struct xmlError:
int domain
int code
char* message
xmlErrorLevel level
char* file
char* str1
char* str2
char* str3
int line
int int1
int int2
void* node
ctypedef void (*xmlGenericErrorFunc)(void* ctxt, char* msg, ...) nogil
ctypedef void (*xmlStructuredErrorFunc)(void* userData,
xmlError* error) nogil
cdef void xmlSetGenericErrorFunc(
void* ctxt, xmlGenericErrorFunc func) nogil
cdef void xmlSetStructuredErrorFunc(
void* ctxt, xmlStructuredErrorFunc func) nogil
cdef extern from "libxml/globals.h":
cdef xmlStructuredErrorFunc xmlStructuredError
cdef void* xmlStructuredErrorContext

250
.venv/lib/python3.7/site-packages/lxml/includes/xmlparser.pxd Normal file
View File

@@ -0,0 +1,250 @@
from libc.string cimport const_char
from lxml.includes.tree cimport (
xmlDoc, xmlNode, xmlDict, xmlDtd, xmlChar, const_xmlChar)
from lxml.includes.tree cimport xmlInputReadCallback, xmlInputCloseCallback
from lxml.includes.xmlerror cimport xmlError, xmlStructuredErrorFunc
cdef extern from "libxml/parser.h":
ctypedef void (*startElementNsSAX2Func)(void* ctx,
const_xmlChar* localname,
const_xmlChar* prefix,
const_xmlChar* URI,
int nb_namespaces,
const_xmlChar** namespaces,
int nb_attributes,
int nb_defaulted,
const_xmlChar** attributes)
ctypedef void (*endElementNsSAX2Func)(void* ctx,
const_xmlChar* localname,
const_xmlChar* prefix,
const_xmlChar* URI)
ctypedef void (*startElementSAXFunc)(void* ctx, const_xmlChar* name, const_xmlChar** atts)
ctypedef void (*endElementSAXFunc)(void* ctx, const_xmlChar* name)
ctypedef void (*charactersSAXFunc)(void* ctx, const_xmlChar* ch, int len)
ctypedef void (*cdataBlockSAXFunc)(void* ctx, const_xmlChar* value, int len)
ctypedef void (*commentSAXFunc)(void* ctx, const_xmlChar* value)
ctypedef void (*processingInstructionSAXFunc)(void* ctx,
const_xmlChar* target,
const_xmlChar* data)
ctypedef void (*internalSubsetSAXFunc)(void* ctx,
const_xmlChar* name,
const_xmlChar* externalID,
const_xmlChar* systemID)
ctypedef void (*endDocumentSAXFunc)(void* ctx)
ctypedef void (*startDocumentSAXFunc)(void* ctx)
ctypedef void (*referenceSAXFunc)(void * ctx, const_xmlChar* name)
cdef int XML_SAX2_MAGIC
cdef extern from "libxml/tree.h":
ctypedef struct xmlParserInput:
int line
int length
const_xmlChar* base
const_xmlChar* cur
const_xmlChar* end
const_char *filename
ctypedef struct xmlParserInputBuffer:
void* context
xmlInputReadCallback readcallback
xmlInputCloseCallback closecallback
ctypedef struct xmlSAXHandlerV1:
# same as xmlSAXHandler, but without namespaces
pass
ctypedef struct xmlSAXHandler:
internalSubsetSAXFunc internalSubset
startElementNsSAX2Func startElementNs
endElementNsSAX2Func endElementNs
startElementSAXFunc startElement
endElementSAXFunc endElement
charactersSAXFunc characters
cdataBlockSAXFunc cdataBlock
referenceSAXFunc reference
commentSAXFunc comment
processingInstructionSAXFunc processingInstruction
startDocumentSAXFunc startDocument
endDocumentSAXFunc endDocument
int initialized
xmlStructuredErrorFunc serror
void* _private
cdef extern from "libxml/SAX2.h" nogil:
cdef void xmlSAX2StartDocument(void* ctxt)
cdef extern from "libxml/xmlIO.h" nogil:
cdef xmlParserInputBuffer* xmlAllocParserInputBuffer(int enc)
cdef extern from "libxml/parser.h":
cdef xmlDict* xmlDictCreate() nogil
cdef xmlDict* xmlDictCreateSub(xmlDict* subdict) nogil
cdef void xmlDictFree(xmlDict* sub) nogil
cdef int xmlDictReference(xmlDict* dict) nogil
cdef int XML_COMPLETE_ATTRS # SAX option for adding DTD default attributes
cdef int XML_SKIP_IDS # SAX option for not building an XML ID dict
ctypedef enum xmlParserInputState:
XML_PARSER_EOF = -1 # nothing is to be parsed
XML_PARSER_START = 0 # nothing has been parsed
XML_PARSER_MISC = 1 # Misc* before int subset
XML_PARSER_PI = 2 # Within a processing instruction
XML_PARSER_DTD = 3 # within some DTD content
XML_PARSER_PROLOG = 4 # Misc* after internal subset
XML_PARSER_COMMENT = 5 # within a comment
XML_PARSER_START_TAG = 6 # within a start tag
XML_PARSER_CONTENT = 7 # within the content
XML_PARSER_CDATA_SECTION = 8 # within a CDATA section
XML_PARSER_END_TAG = 9 # within a closing tag
XML_PARSER_ENTITY_DECL = 10 # within an entity declaration
XML_PARSER_ENTITY_VALUE = 11 # within an entity value in a decl
XML_PARSER_ATTRIBUTE_VALUE = 12 # within an attribute value
XML_PARSER_SYSTEM_LITERAL = 13 # within a SYSTEM value
XML_PARSER_EPILOG = 14 # the Misc* after the last end tag
XML_PARSER_IGNORE = 15 # within an IGNORED section
XML_PARSER_PUBLIC_LITERAL = 16 # within a PUBLIC value
ctypedef struct xmlParserCtxt:
xmlDoc* myDoc
xmlDict* dict
int dictNames
void* _private
bint wellFormed
bint recovery
int options
bint disableSAX
int errNo
xmlParserInputState instate
bint replaceEntities
int loadsubset # != 0 if enabled, int value == why
bint validate
xmlError lastError
xmlNode* node
xmlSAXHandler* sax
void* userData
int* spaceTab
int spaceMax
int nsNr
bint html
bint progressive
int inSubset
int charset
xmlParserInput* input
ctypedef enum xmlParserOption:
XML_PARSE_RECOVER = 1 # recover on errors
XML_PARSE_NOENT = 2 # substitute entities
XML_PARSE_DTDLOAD = 4 # load the external subset
XML_PARSE_DTDATTR = 8 # default DTD attributes
XML_PARSE_DTDVALID = 16 # validate with the DTD
XML_PARSE_NOERROR = 32 # suppress error reports
XML_PARSE_NOWARNING = 64 # suppress warning reports
XML_PARSE_PEDANTIC = 128 # pedantic error reporting
XML_PARSE_NOBLANKS = 256 # remove blank nodes
XML_PARSE_SAX1 = 512 # use the SAX1 interface internally
XML_PARSE_XINCLUDE = 1024 # Implement XInclude substitution
XML_PARSE_NONET = 2048 # Forbid network access
XML_PARSE_NODICT = 4096 # Do not reuse the context dictionary
XML_PARSE_NSCLEAN = 8192 # remove redundant namespaces declarations
XML_PARSE_NOCDATA = 16384 # merge CDATA as text nodes
XML_PARSE_NOXINCNODE = 32768 # do not generate XINCLUDE START/END nodes
# libxml2 2.6.21+ only:
XML_PARSE_COMPACT = 65536 # compact small text nodes
# libxml2 2.7.0+ only:
XML_PARSE_OLD10 = 131072 # parse using XML-1.0 before update 5
XML_PARSE_NOBASEFIX = 262144 # do not fixup XINCLUDE xml:base uris
XML_PARSE_HUGE = 524288 # relax any hardcoded limit from the parser
# libxml2 2.7.3+ only:
XML_PARSE_OLDSAX = 1048576 # parse using SAX2 interface before 2.7.0
# libxml2 2.8.0+ only:
XML_PARSE_IGNORE_ENC = 2097152 # ignore internal document encoding hint
# libxml2 2.9.0+ only:
XML_PARSE_BIG_LINES = 4194304 # Store big lines numbers in text PSVI field
cdef void xmlInitParser() nogil
cdef void xmlCleanupParser() nogil
cdef int xmlLineNumbersDefault(int onoff) nogil
cdef xmlParserCtxt* xmlNewParserCtxt() nogil
cdef xmlParserInput* xmlNewIOInputStream(xmlParserCtxt* ctxt,
xmlParserInputBuffer* input,
int enc) nogil
cdef int xmlCtxtUseOptions(xmlParserCtxt* ctxt, int options) nogil
cdef void xmlFreeParserCtxt(xmlParserCtxt* ctxt) nogil
cdef void xmlCtxtReset(xmlParserCtxt* ctxt) nogil
cdef void xmlClearParserCtxt(xmlParserCtxt* ctxt) nogil
cdef int xmlParseChunk(xmlParserCtxt* ctxt,
char* chunk, int size, int terminate) nogil
cdef xmlDoc* xmlCtxtReadDoc(xmlParserCtxt* ctxt,
char* cur, char* URL, char* encoding,
int options) nogil
cdef xmlDoc* xmlCtxtReadFile(xmlParserCtxt* ctxt,
char* filename, char* encoding,
int options) nogil
cdef xmlDoc* xmlCtxtReadIO(xmlParserCtxt* ctxt,
xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void* ioctx,
char* URL, char* encoding,
int options) nogil
cdef xmlDoc* xmlCtxtReadMemory(xmlParserCtxt* ctxt,
char* buffer, int size,
char* filename, const_char* encoding,
int options) nogil
# iterparse:
cdef xmlParserCtxt* xmlCreatePushParserCtxt(xmlSAXHandler* sax,
void* user_data,
char* chunk,
int size,
char* filename) nogil
cdef int xmlCtxtResetPush(xmlParserCtxt* ctxt,
char* chunk,
int size,
char* filename,
char* encoding) nogil
# entity loaders:
ctypedef xmlParserInput* (*xmlExternalEntityLoader)(
const_char * URL, const_char * ID, xmlParserCtxt* context) nogil
cdef xmlExternalEntityLoader xmlGetExternalEntityLoader() nogil
cdef void xmlSetExternalEntityLoader(xmlExternalEntityLoader f) nogil
# DTDs:
cdef xmlDtd* xmlParseDTD(const_xmlChar* ExternalID, const_xmlChar* SystemID) nogil
cdef xmlDtd* xmlIOParseDTD(xmlSAXHandler* sax,
xmlParserInputBuffer* input,
int enc) nogil
cdef extern from "libxml/parserInternals.h":
cdef xmlParserInput* xmlNewInputStream(xmlParserCtxt* ctxt)
cdef xmlParserInput* xmlNewStringInputStream(xmlParserCtxt* ctxt,
char* buffer) nogil
cdef xmlParserInput* xmlNewInputFromFile(xmlParserCtxt* ctxt,
char* filename) nogil
cdef void xmlFreeInputStream(xmlParserInput* input) nogil
cdef int xmlSwitchEncoding(xmlParserCtxt* ctxt, int enc) nogil

35
.venv/lib/python3.7/site-packages/lxml/includes/xmlschema.pxd Normal file
View File

@@ -0,0 +1,35 @@
from lxml.includes.tree cimport xmlDoc
from lxml.includes.xmlparser cimport xmlSAXHandler
from lxml.includes.xmlerror cimport xmlStructuredErrorFunc
cdef extern from "libxml/xmlschemas.h":
ctypedef struct xmlSchema
ctypedef struct xmlSchemaParserCtxt
ctypedef struct xmlSchemaSAXPlugStruct
ctypedef struct xmlSchemaValidCtxt
ctypedef enum xmlSchemaValidOption:
XML_SCHEMA_VAL_VC_I_CREATE = 1
cdef xmlSchemaValidCtxt* xmlSchemaNewValidCtxt(xmlSchema* schema) nogil
cdef void xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxt* ctxt,
xmlStructuredErrorFunc serror, void *ctx)
cdef void xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxt* ctxt,
xmlStructuredErrorFunc serror, void *ctx)
cdef int xmlSchemaValidateDoc(xmlSchemaValidCtxt* ctxt, xmlDoc* doc) nogil
cdef xmlSchema* xmlSchemaParse(xmlSchemaParserCtxt* ctxt) nogil
cdef xmlSchemaParserCtxt* xmlSchemaNewParserCtxt(char* URL) nogil
cdef xmlSchemaParserCtxt* xmlSchemaNewDocParserCtxt(xmlDoc* doc) nogil
cdef void xmlSchemaFree(xmlSchema* schema) nogil
cdef void xmlSchemaFreeParserCtxt(xmlSchemaParserCtxt* ctxt) nogil
cdef void xmlSchemaFreeValidCtxt(xmlSchemaValidCtxt* ctxt) nogil
cdef int xmlSchemaSetValidOptions(xmlSchemaValidCtxt* ctxt,
int options) nogil
cdef xmlSchemaSAXPlugStruct* xmlSchemaSAXPlug(xmlSchemaValidCtxt* ctxt,
xmlSAXHandler** sax,
void** data) nogil
cdef int xmlSchemaSAXUnplug(xmlSchemaSAXPlugStruct* sax_plug)
cdef int xmlSchemaIsValid(xmlSchemaValidCtxt* ctxt)

135
.venv/lib/python3.7/site-packages/lxml/includes/xpath.pxd Normal file
View File

@@ -0,0 +1,135 @@
from lxml.includes cimport tree
from lxml.includes cimport xmlerror
from libc.string cimport const_char
from lxml.includes.tree cimport xmlChar, const_xmlChar
cdef extern from "libxml/xpath.h":
ctypedef enum xmlXPathObjectType:
XPATH_UNDEFINED = 0
XPATH_NODESET = 1
XPATH_BOOLEAN = 2
XPATH_NUMBER = 3
XPATH_STRING = 4
XPATH_POINT = 5
XPATH_RANGE = 6
XPATH_LOCATIONSET = 7
XPATH_USERS = 8
XPATH_XSLT_TREE = 9
ctypedef enum xmlXPathError:
XPATH_EXPRESSION_OK = 0
XPATH_NUMBER_ERROR = 1
XPATH_UNFINISHED_LITERAL_ERROR = 2
XPATH_START_LITERAL_ERROR = 3
XPATH_VARIABLE_REF_ERROR = 4
XPATH_UNDEF_VARIABLE_ERROR = 5
XPATH_INVALID_PREDICATE_ERROR = 6
XPATH_EXPR_ERROR = 7
XPATH_UNCLOSED_ERROR = 8
XPATH_UNKNOWN_FUNC_ERROR = 9
XPATH_INVALID_OPERAND = 10
XPATH_INVALID_TYPE = 11
XPATH_INVALID_ARITY = 12
XPATH_INVALID_CTXT_SIZE = 13
XPATH_INVALID_CTXT_POSITION = 14
XPATH_MEMORY_ERROR = 15
XPTR_SYNTAX_ERROR = 16
XPTR_RESOURCE_ERROR = 17
XPTR_SUB_RESOURCE_ERROR = 18
XPATH_UNDEF_PREFIX_ERROR = 19
XPATH_ENCODING_ERROR = 20
XPATH_INVALID_CHAR_ERROR = 21
XPATH_INVALID_CTXT = 22
ctypedef struct xmlNodeSet:
int nodeNr
int nodeMax
tree.xmlNode** nodeTab
ctypedef struct xmlXPathObject:
xmlXPathObjectType type
xmlNodeSet* nodesetval
bint boolval
double floatval
xmlChar* stringval
ctypedef struct xmlXPathContext:
tree.xmlDoc* doc
tree.xmlNode* node
tree.xmlDict* dict
tree.xmlHashTable* nsHash
const_xmlChar* function
const_xmlChar* functionURI
xmlerror.xmlStructuredErrorFunc error
xmlerror.xmlError lastError
void* userData
ctypedef struct xmlXPathParserContext:
xmlXPathContext* context
xmlXPathObject* value
tree.xmlNode* ancestor
int error
ctypedef struct xmlXPathCompExpr
ctypedef void (*xmlXPathFunction)(xmlXPathParserContext* ctxt, int nargs) nogil
ctypedef xmlXPathFunction (*xmlXPathFuncLookupFunc)(void* ctxt,
const_xmlChar* name,
const_xmlChar* ns_uri) nogil
cdef xmlXPathContext* xmlXPathNewContext(tree.xmlDoc* doc) nogil
cdef xmlXPathObject* xmlXPathEvalExpression(const_xmlChar* str,
xmlXPathContext* ctxt) nogil
cdef xmlXPathObject* xmlXPathCompiledEval(xmlXPathCompExpr* comp,
xmlXPathContext* ctxt) nogil
cdef xmlXPathCompExpr* xmlXPathCompile(const_xmlChar* str) nogil
cdef xmlXPathCompExpr* xmlXPathCtxtCompile(xmlXPathContext* ctxt,
const_xmlChar* str) nogil
cdef void xmlXPathFreeContext(xmlXPathContext* ctxt) nogil
cdef void xmlXPathFreeCompExpr(xmlXPathCompExpr* comp) nogil
cdef void xmlXPathFreeObject(xmlXPathObject* obj) nogil
cdef int xmlXPathRegisterNs(xmlXPathContext* ctxt,
const_xmlChar* prefix, const_xmlChar* ns_uri) nogil
cdef xmlNodeSet* xmlXPathNodeSetCreate(tree.xmlNode* val) nogil
cdef void xmlXPathFreeNodeSet(xmlNodeSet* val) nogil
cdef extern from "libxml/xpathInternals.h":
cdef int xmlXPathRegisterFunc(xmlXPathContext* ctxt,
const_xmlChar* name,
xmlXPathFunction f) nogil
cdef int xmlXPathRegisterFuncNS(xmlXPathContext* ctxt,
const_xmlChar* name,
const_xmlChar* ns_uri,
xmlXPathFunction f) nogil
cdef void xmlXPathRegisterFuncLookup(xmlXPathContext *ctxt,
xmlXPathFuncLookupFunc f,
void *funcCtxt) nogil
cdef int xmlXPathRegisterVariable(xmlXPathContext *ctxt,
const_xmlChar* name,
xmlXPathObject* value) nogil
cdef int xmlXPathRegisterVariableNS(xmlXPathContext *ctxt,
const_xmlChar* name,
const_xmlChar* ns_uri,
xmlXPathObject* value) nogil
cdef void xmlXPathRegisteredVariablesCleanup(xmlXPathContext *ctxt) nogil
cdef void xmlXPathRegisteredNsCleanup(xmlXPathContext *ctxt) nogil
cdef xmlXPathObject* valuePop (xmlXPathParserContext *ctxt) nogil
cdef int valuePush(xmlXPathParserContext* ctxt, xmlXPathObject *value) nogil
cdef xmlXPathObject* xmlXPathNewCString(const_char *val) nogil
cdef xmlXPathObject* xmlXPathWrapCString(const_char * val) nogil
cdef xmlXPathObject* xmlXPathNewString(const_xmlChar *val) nogil
cdef xmlXPathObject* xmlXPathWrapString(const_xmlChar * val) nogil
cdef xmlXPathObject* xmlXPathNewFloat(double val) nogil
cdef xmlXPathObject* xmlXPathNewBoolean(int val) nogil
cdef xmlXPathObject* xmlXPathNewNodeSet(tree.xmlNode* val) nogil
cdef xmlXPathObject* xmlXPathNewValueTree(tree.xmlNode* val) nogil
cdef void xmlXPathNodeSetAdd(xmlNodeSet* cur,
tree.xmlNode* val) nogil
cdef void xmlXPathNodeSetAddUnique(xmlNodeSet* cur,
tree.xmlNode* val) nogil
cdef xmlXPathObject* xmlXPathWrapNodeSet(xmlNodeSet* val) nogil
cdef void xmlXPathErr(xmlXPathParserContext* ctxt, int error) nogil

191
.venv/lib/python3.7/site-packages/lxml/includes/xslt.pxd Normal file
View File

@@ -0,0 +1,191 @@
from lxml.includes.tree cimport xmlDoc, xmlNode, xmlDict, xmlChar, const_xmlChar, xmlOutputBuffer
from lxml.includes.xmlerror cimport xmlGenericErrorFunc
from lxml.includes.xpath cimport xmlXPathContext, xmlXPathFunction
from libc.string cimport const_char
cdef extern from "libxslt/xslt.h":
cdef int xsltLibxsltVersion
cdef int xsltMaxDepth
cdef extern from "libxslt/xsltconfig.h":
cdef int LIBXSLT_VERSION
cdef extern from "libxslt/xsltInternals.h":
ctypedef enum xsltTransformState:
XSLT_STATE_OK # 0
XSLT_STATE_ERROR # 1
XSLT_STATE_STOPPED # 2
ctypedef struct xsltDocument:
xmlDoc* doc
ctypedef struct xsltStylesheet:
xmlChar* encoding
xmlDoc* doc
int errors
ctypedef struct xsltTransformContext:
xsltStylesheet* style
xmlXPathContext* xpathCtxt
xsltDocument* document
void* _private
xmlDict* dict
int profile
xmlNode* node
xmlDoc* output
xmlNode* insert
xmlNode* inst
xsltTransformState state
ctypedef struct xsltStackElem
ctypedef struct xsltTemplate
cdef xsltStylesheet* xsltParseStylesheetDoc(xmlDoc* doc) nogil
cdef void xsltFreeStylesheet(xsltStylesheet* sheet) nogil
cdef extern from "libxslt/imports.h":
# actually defined in "etree_defs.h"
cdef void LXML_GET_XSLT_ENCODING(const_xmlChar* result_var, xsltStylesheet* style)
cdef extern from "libxslt/extensions.h":
ctypedef void (*xsltTransformFunction)(xsltTransformContext* ctxt,
xmlNode* context_node,
xmlNode* inst,
void* precomp_unused) nogil
cdef int xsltRegisterExtFunction(xsltTransformContext* ctxt,
const_xmlChar* name,
const_xmlChar* URI,
xmlXPathFunction function) nogil
cdef int xsltRegisterExtModuleFunction(const_xmlChar* name, const_xmlChar* URI,
xmlXPathFunction function) nogil
cdef int xsltUnregisterExtModuleFunction(const_xmlChar* name, const_xmlChar* URI)
cdef xmlXPathFunction xsltExtModuleFunctionLookup(
const_xmlChar* name, const_xmlChar* URI) nogil
cdef int xsltRegisterExtPrefix(xsltStylesheet* style,
const_xmlChar* prefix, const_xmlChar* URI) nogil
cdef int xsltRegisterExtElement(xsltTransformContext* ctxt,
const_xmlChar* name, const_xmlChar* URI,
xsltTransformFunction function) nogil
cdef extern from "libxslt/documents.h":
ctypedef enum xsltLoadType:
XSLT_LOAD_START
XSLT_LOAD_STYLESHEET
XSLT_LOAD_DOCUMENT
ctypedef xmlDoc* (*xsltDocLoaderFunc)(const_xmlChar* URI, xmlDict* dict,
int options,
void* ctxt,
xsltLoadType type) nogil
cdef xsltDocLoaderFunc xsltDocDefaultLoader
cdef void xsltSetLoaderFunc(xsltDocLoaderFunc f) nogil
cdef extern from "libxslt/transform.h":
cdef xmlDoc* xsltApplyStylesheet(xsltStylesheet* style, xmlDoc* doc,
const_char** params) nogil
cdef xmlDoc* xsltApplyStylesheetUser(xsltStylesheet* style, xmlDoc* doc,
const_char** params, const_char* output,
void* profile,
xsltTransformContext* context) nogil
cdef void xsltProcessOneNode(xsltTransformContext* ctxt,
xmlNode* contextNode,
xsltStackElem* params) nogil
cdef xsltTransformContext* xsltNewTransformContext(xsltStylesheet* style,
xmlDoc* doc) nogil
cdef void xsltFreeTransformContext(xsltTransformContext* context) nogil
cdef void xsltApplyOneTemplate(xsltTransformContext* ctxt,
xmlNode* contextNode, xmlNode* list,
xsltTemplate* templ,
xsltStackElem* params) nogil
cdef extern from "libxslt/xsltutils.h":
cdef int xsltSaveResultToString(xmlChar** doc_txt_ptr,
int* doc_txt_len,
xmlDoc* result,
xsltStylesheet* style) nogil
cdef int xsltSaveResultToFilename(const_char *URL,
xmlDoc* result,
xsltStylesheet* style,
int compression) nogil
cdef int xsltSaveResultTo(xmlOutputBuffer* buf,
xmlDoc* result,
xsltStylesheet* style) nogil
cdef xmlGenericErrorFunc xsltGenericError
cdef void *xsltGenericErrorContext
cdef void xsltSetGenericErrorFunc(
void* ctxt, void (*handler)(void* ctxt, char* msg, ...)) nogil
cdef void xsltSetTransformErrorFunc(
xsltTransformContext*, void* ctxt,
void (*handler)(void* ctxt, char* msg, ...) nogil) nogil
cdef void xsltTransformError(xsltTransformContext* ctxt,
xsltStylesheet* style,
xmlNode* node, char* msg, ...)
cdef void xsltSetCtxtParseOptions(
xsltTransformContext* ctxt, int options)
cdef extern from "libxslt/security.h":
ctypedef struct xsltSecurityPrefs
ctypedef enum xsltSecurityOption:
XSLT_SECPREF_READ_FILE = 1
XSLT_SECPREF_WRITE_FILE = 2
XSLT_SECPREF_CREATE_DIRECTORY = 3
XSLT_SECPREF_READ_NETWORK = 4
XSLT_SECPREF_WRITE_NETWORK = 5
ctypedef int (*xsltSecurityCheck)(xsltSecurityPrefs* sec,
xsltTransformContext* ctxt,
char* value) nogil
cdef xsltSecurityPrefs* xsltNewSecurityPrefs() nogil
cdef void xsltFreeSecurityPrefs(xsltSecurityPrefs* sec) nogil
cdef int xsltSecurityForbid(xsltSecurityPrefs* sec,
xsltTransformContext* ctxt,
char* value) nogil
cdef int xsltSecurityAllow(xsltSecurityPrefs* sec,
xsltTransformContext* ctxt,
char* value) nogil
cdef int xsltSetSecurityPrefs(xsltSecurityPrefs* sec,
xsltSecurityOption option,
xsltSecurityCheck func) nogil
cdef xsltSecurityCheck xsltGetSecurityPrefs(
xsltSecurityPrefs* sec,
xsltSecurityOption option) nogil
cdef int xsltSetCtxtSecurityPrefs(xsltSecurityPrefs* sec,
xsltTransformContext* ctxt) nogil
cdef xmlDoc* xsltGetProfileInformation(xsltTransformContext* ctxt) nogil
cdef extern from "libxslt/variables.h":
cdef int xsltQuoteUserParams(xsltTransformContext* ctxt,
const_char** params)
cdef int xsltQuoteOneUserParam(xsltTransformContext* ctxt,
const_xmlChar* name,
const_xmlChar* value)
cdef extern from "libxslt/extra.h":
const_xmlChar* XSLT_LIBXSLT_NAMESPACE
const_xmlChar* XSLT_XALAN_NAMESPACE
const_xmlChar* XSLT_SAXON_NAMESPACE
const_xmlChar* XSLT_XT_NAMESPACE
cdef xmlXPathFunction xsltFunctionNodeSet
cdef void xsltRegisterAllExtras() nogil
cdef extern from "libexslt/exslt.h":
cdef void exsltRegisterAll() nogil
# libexslt 1.1.25+
const_xmlChar* EXSLT_DATE_NAMESPACE
const_xmlChar* EXSLT_SETS_NAMESPACE
const_xmlChar* EXSLT_MATH_NAMESPACE
const_xmlChar* EXSLT_STRINGS_NAMESPACE
cdef int exsltDateXpathCtxtRegister(xmlXPathContext* ctxt, const_xmlChar* prefix)
cdef int exsltSetsXpathCtxtRegister(xmlXPathContext* ctxt, const_xmlChar* prefix)
cdef int exsltMathXpathCtxtRegister(xmlXPathContext* ctxt, const_xmlChar* prefix)
cdef int exsltStrXpathCtxtRegister(xmlXPathContext* ctxt, const_xmlChar* prefix)