#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#endif

#include "Python.h"

#include "pycore_ceval.h" // _Py_EnterRecursiveCall()

#include "pycore_codecs.h" // _PyCodec_LookupTextEncoding()

#include "pycore_import.h" // _PyImport_SetModule()

#include "pycore_pyhash.h" // _Py_HashSecret

#include "pycore_traceback.h" // _PyTraceback_Add()

#include <stdbool.h>

#include <stddef.h> // offsetof()

#include "expat_config.h"

#include "expat.h"

#include "pyexpat.h"

/* Do not emit Clinic output to a file as that wreaks havoc with conditionally

included methods. */

/*[clinic input]

module pyexpat

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=b168d503a4490c15]*/

#define XML_COMBINED_VERSION (10000*XML_MAJOR_VERSION+100*XML_MINOR_VERSION+XML_MICRO_VERSION)

#if XML_COMBINED_VERSION >= 20900

# define EXPAT_GetCurrentLineNumber XML_GetCurrentLineNumber64

# define EXPAT_GetCurrentColumnNumber XML_GetCurrentColumnNumber64

# define EXPAT_GetCurrentByteIndex XML_GetCurrentByteIndex64

#else

# define EXPAT_GetCurrentLineNumber XML_GetCurrentLineNumber

# define EXPAT_GetCurrentColumnNumber XML_GetCurrentColumnNumber

# define EXPAT_GetCurrentByteIndex XML_GetCurrentByteIndex

#endif

static XML_Memory_Handling_Suite ExpatMemoryHandler = {

PyMem_Malloc, PyMem_Realloc, PyMem_Free};

enum HandlerTypes {

StartElement,

EndElement,

ProcessingInstruction,

CharacterData,

UnparsedEntityDecl,

NotationDecl,

StartNamespaceDecl,

EndNamespaceDecl,

Comment,

StartCdataSection,

EndCdataSection,

Default,

DefaultHandlerExpand,

NotStandalone,

ExternalEntityRef,

StartDoctypeDecl,

EndDoctypeDecl,

EntityDecl,

XmlDecl,

ElementDecl,

AttlistDecl,

#if XML_COMBINED_VERSION >= 19504

SkippedEntity,

#endif

_DummyDecl

};

typedef struct {

PyTypeObject *xml_parse_type;

PyObject *error;

PyObject *str_read;

} pyexpat_state;

static inline pyexpat_state*

pyexpat_get_state(PyObject *module)

{

void *state = PyModule_GetState(module);

assert(state != NULL);

return (pyexpat_state *)state;

}

/* ----------------------------------------------------- */

/* Declarations for objects of type xmlparser */

typedef struct {

PyObject_HEAD

XML_Parser itself;

/*

* Strong reference to a parent `xmlparseobject` if this parser

* is a child parser. Set to NULL if this parser is a root parser.

* This is needed to keep the parent parser alive as long as it has

* at least one child parser.

*

* See https://github.com/python/cpython/issues/139400 for details.

*/

PyObject *parent;

int ordered_attributes; /* Return attributes as a list. */

int specified_attributes; /* Report only specified attributes. */

int in_callback; /* Is a callback active? */

int ns_prefixes; /* Namespace-triplets mode? */

XML_Char *buffer; /* Buffer used when accumulating characters */

/* NULL if not enabled */

int buffer_size; /* Size of buffer, in XML_Char units */

int buffer_used; /* Buffer units in use */

bool reparse_deferral_enabled; /* Whether to defer reparsing of

unfinished XML tokens; a de-facto cache of

what Expat has the authority on, for lack

of a getter API function

"XML_GetReparseDeferralEnabled" in Expat

2.6.0 */

PyObject *intern; /* Dictionary to intern strings */

PyObject **handlers;

} xmlparseobject;

#define xmlparseobject_CAST(op) ((xmlparseobject *)(op))

#include "clinic/pyexpat.c.h"

#define CHARACTER_DATA_BUFFER_SIZE 8192

// A generic function type for storage.

// To avoid undefined behaviors, a handler must be cast to the correct

// function type before it's called; see SETTER_WRAPPER below.

typedef void (*xmlhandler)(void);

typedef void (*xmlhandlersetter)(XML_Parser self, xmlhandler handler);

struct HandlerInfo {

const char *name;

xmlhandlersetter setter;

xmlhandler handler;

PyGetSetDef getset;

};

static struct HandlerInfo handler_info[64];

static inline void

CALL_XML_HANDLER_SETTER(const struct HandlerInfo *handler_info,

XML_Parser xml_parser, xmlhandler xml_handler)

{

xmlhandlersetter setter = (xmlhandlersetter)handler_info->setter;

setter(xml_parser, xml_handler);

}

static int

set_xml_error_attr_code(PyObject *err, enum XML_Error code)

{

PyObject *v = PyLong_FromLong((long)code);

int ok = v != NULL && PyObject_SetAttr(err, &_Py_ID(code), v) != -1;

Py_XDECREF(v);

return ok;

}

/* Set an integer attribute on the error object; return true on success,

* false on an exception.

*/

static int

set_xml_error_attr_location(PyObject *err, const char *name,

unsigned long long value)

{

PyObject *v = PyLong_FromUnsignedLongLong(value);

int ok = v != NULL && PyObject_SetAttrString(err, name, v) != -1;

Py_XDECREF(v);

return ok;

}

static PyObject *

set_xml_error(pyexpat_state *state,

enum XML_Error code,

unsigned long long lineno, unsigned long long column,

const char *errmsg)

{

PyObject *arg;

if (errmsg == NULL) {

arg = PyUnicode_FromFormat(

"%s: line %llu, column %llu",

XML_ErrorString(code),

lineno, column

);

}

else {

arg = PyUnicode_FromStringAndSize(errmsg, strlen(errmsg));

}

if (arg == NULL) {

return NULL;

}

PyObject *res = PyObject_CallOneArg(state->error, arg);

Py_DECREF(arg);

if (

res != NULL

&& set_xml_error_attr_code(res, code)

&& set_xml_error_attr_location(res, "lineno", lineno)

&& set_xml_error_attr_location(res, "offset", column)

) {

PyErr_SetObject(state->error, res);

}

Py_XDECREF(res);

return NULL;

}

#define SET_XML_ERROR(STATE, SELF, CODE, ERRMSG) \

do { \

XML_Parser parser = SELF->itself; \

assert(parser != NULL); \

unsigned long long lineno \

= EXPAT_GetCurrentLineNumber(parser); \

unsigned long long column \

= EXPAT_GetCurrentColumnNumber(parser); \

(void)set_xml_error(state, CODE, lineno, column, ERRMSG); \

} while (0)

/* Build and set an Expat exception, including positioning

* information. Always returns NULL.

*/

static PyObject *

set_error(pyexpat_state *state, xmlparseobject *self, enum XML_Error code)

{

SET_XML_ERROR(state, self, code, NULL);

return NULL;

}

#if XML_COMBINED_VERSION >= 20400

static PyObject *

set_invalid_arg(pyexpat_state *state, xmlparseobject *self, const char *errmsg)

{

SET_XML_ERROR(state, self, XML_ERROR_INVALID_ARGUMENT, errmsg);

return NULL;

}

#endif

#undef SET_XML_ERROR

static int

have_handler(xmlparseobject *self, int type)

{

PyObject *handler = self->handlers[type];

return handler != NULL;

}

/* Convert a string of XML_Chars into a Unicode string.

Returns None if str is a null pointer. */

static PyObject *

conv_string_to_unicode(const XML_Char *str)

{

/* XXX currently this code assumes that XML_Char is 8-bit,

and hence in UTF-8. */

/* UTF-8 from Expat, Unicode desired */

if (str == NULL) {

Py_RETURN_NONE;

}

return PyUnicode_DecodeUTF8(str, strlen(str), "strict");

}

static PyObject *

conv_string_to_unicode_void(void *arg)

{

return conv_string_to_unicode((const XML_Char *)arg);

}

static PyObject *

conv_string_len_to_unicode(const XML_Char *str, int len)

{

/* XXX currently this code assumes that XML_Char is 8-bit,

and hence in UTF-8. */

/* UTF-8 from Expat, Unicode desired */

if (str == NULL) {

Py_RETURN_NONE;

}

return PyUnicode_DecodeUTF8((const char *)str, len, "strict");

}

/* Callback routines */

static void clear_handlers(xmlparseobject *self, int initial);

/* This handler is used when an error has been detected, in the hope

that actual parsing can be terminated early. This will only help

if an external entity reference is encountered. */

static int

error_external_entity_ref_handler(XML_Parser parser,

const XML_Char *context,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId)

{

return 0;

}

/* Dummy character data handler used when an error (exception) has

been detected, and the actual parsing can be terminated early.

This is needed since the character data and default handlers can't be

safely removed from within a callback, only replaced: Expat may call

them several times for one piece of text (a long comment in a document

that is not UTF-8, for example). The default handler has the same

signature, so this function serves for both. clear_handlers() installs

it after `flag_error()`, and the handler setter installs it when a

handler is set to None from within a callback. */

static void

noop_character_data_handler(void *userData, const XML_Char *data, int len)

{

/* Do nothing. */

}

static void

flag_error(xmlparseobject *self)

{

clear_handlers(self, 0);

XML_SetExternalEntityRefHandler(self->itself,

error_external_entity_ref_handler);

}

static PyObject*

call_with_frame(const char *funcname, int lineno, PyObject* func, PyObject* args,

xmlparseobject *self)

{

PyObject *res;

Py_INCREF(func);

res = PyObject_Call(func, args, NULL);

Py_DECREF(func);

if (res == NULL) {

_PyTraceback_Add(funcname, __FILE__, lineno);

XML_StopParser(self->itself, XML_FALSE);

}

return res;

}

static PyObject*

string_intern(xmlparseobject *self, const char* str)

{

PyObject *result = conv_string_to_unicode(str);

PyObject *value;

/* result can be NULL if the unicode conversion failed. */

if (!result)

return result;

if (!self->intern)

return result;

if (PyDict_GetItemRef(self->intern, result, &value) == 0 &&

PyDict_SetItem(self->intern, result, result) == 0)

{

return result;

}

assert((value != NULL) == !PyErr_Occurred());

Py_DECREF(result);

return value;

}

/* Return 0 on success, -1 on exception.

* flag_error() will be called before return if needed.

*/

static int

call_character_handler(xmlparseobject *self, const XML_Char *buffer, int len)

{

PyObject *args;

PyObject *temp;

if (!have_handler(self, CharacterData))

return -1;

/* Copy the buffer before tuple allocation can trigger a GC callback. */

temp = conv_string_len_to_unicode(buffer, len);

if (temp == NULL) {

flag_error(self);

XML_SetCharacterDataHandler(self->itself,

noop_character_data_handler);

return -1;

}

args = PyTuple_New(1);

if (args == NULL) {

Py_DECREF(temp);

return -1;

}

PyTuple_SET_ITEM(args, 0, temp);

/* temp is now a borrowed reference; consider it unused. */

if (!have_handler(self, CharacterData)) {

Py_DECREF(args);

return 0;

}

self->in_callback = 1;

temp = call_with_frame("CharacterData", __LINE__,

self->handlers[CharacterData], args, self);

/* temp is an owned reference again, or NULL */

Py_DECREF(args);

if (temp == NULL) {

self->in_callback = 0;

flag_error(self);

XML_SetCharacterDataHandler(self->itself,

noop_character_data_handler);

return -1;

}

/* Releasing the result can run arbitrary code, which must still be

treated as being within the callback by the handler setter. */

Py_DECREF(temp);

self->in_callback = 0;

return 0;

}

static int

flush_character_buffer(xmlparseobject *self)

{

if (self->buffer == NULL || self->buffer_used == 0)

return 0;

int len = self->buffer_used;

/* The callback may change buffering or install a new handler, which

also flushes. Do not expose the same pending data a second time. */

self->buffer_used = 0;

return call_character_handler(self, self->buffer, len);

}

static void

my_CharacterDataHandler(void *userData, const XML_Char *data, int len)

{

xmlparseobject *self = xmlparseobject_CAST(userData);

if (PyErr_Occurred())

return;

if (self->buffer != NULL &&

len > (self->buffer_size - self->buffer_used)) {

if (flush_character_buffer(self) < 0)

return;

/* The callback may replace the handler or disable buffering. */

if (!have_handler(self, CharacterData))

return;

}

if (self->buffer == NULL ||

len > (self->buffer_size - self->buffer_used)) {

call_character_handler(self, data, len);

}

else {

memcpy(self->buffer + self->buffer_used,

data, len * sizeof(XML_Char));

self->buffer_used += len;

}

}

static void

my_StartElementHandler(void *userData,

const XML_Char *name, const XML_Char *atts[])

{

xmlparseobject *self = xmlparseobject_CAST(userData);

if (have_handler(self, StartElement)) {

PyObject *container, *rv, *args;

int i, max;

if (PyErr_Occurred())

return;

if (flush_character_buffer(self) < 0)

return;

/* Set max to the number of slots filled in atts[]; max/2 is

* the number of attributes we need to process.

*/

if (self->specified_attributes) {

max = XML_GetSpecifiedAttributeCount(self->itself);

}

else {

max = 0;

while (atts[max] != NULL)

max += 2;

}

/* Build the container. */

/* Intern-dictionary comparisons can change the mode mid-loop. */

int ordered_attributes = self->ordered_attributes;

if (ordered_attributes)

container = PyList_New(max);

else

container = PyDict_New();

if (container == NULL) {

flag_error(self);

return;

}

for (i = 0; i < max; i += 2) {

PyObject *n = string_intern(self, (XML_Char *) atts[i]);

PyObject *v;

if (n == NULL) {

flag_error(self);

Py_DECREF(container);

return;

}

v = conv_string_to_unicode((XML_Char *) atts[i+1]);

if (v == NULL) {

flag_error(self);

Py_DECREF(container);

Py_DECREF(n);

return;

}

if (ordered_attributes) {

PyList_SET_ITEM(container, i, n);

PyList_SET_ITEM(container, i+1, v);

}

else if (PyDict_SetItem(container, n, v)) {

flag_error(self);

Py_DECREF(n);

Py_DECREF(v);

Py_DECREF(container);

return;

}

else {

Py_DECREF(n);

Py_DECREF(v);

}

}

args = string_intern(self, name);

if (args == NULL) {

Py_DECREF(container);

return;

}

args = Py_BuildValue("(NN)", args, container);

if (args == NULL) {

return;

}

/* Container is now a borrowed reference; ignore it. */

if (!have_handler(self, StartElement)) {

Py_DECREF(args);

return;

}

self->in_callback = 1;

rv = call_with_frame("StartElement", __LINE__,

self->handlers[StartElement], args, self);

self->in_callback = 0;

Py_DECREF(args);

if (rv == NULL) {

flag_error(self);

return;

}

Py_DECREF(rv);

}

}

static inline void

invalid_expat_handler_rv(const char *name)

{

PyObject *exc = PyErr_GetRaisedException();

assert(exc != NULL);

PyObject *note = PyUnicode_FromFormat("invalid '%s' event handler return value", name);

if (note == NULL) {

goto error;

}

int rc = _PyException_AddNote(exc, note);

Py_DECREF(note);

if (rc < 0) {

goto error;

};

goto done;

error:

PyErr_Clear();

done:

PyErr_SetRaisedException(exc);

}

#define RC_HANDLER(RETURN_TYPE, NAME, PARAMS, \

INIT, PARSE_FORMAT, CONVERSION, \

RETURN_VARIABLE, GETUSERDATA) \

static RETURN_TYPE \

my_ ## NAME ## Handler PARAMS { \

xmlparseobject *self = GETUSERDATA; \

INIT \

if (!have_handler(self, NAME)) { \

return RETURN_VARIABLE; \

} \

if (PyErr_Occurred()) { \

return RETURN_VARIABLE; \

} \

if (flush_character_buffer(self) < 0) { \

return RETURN_VARIABLE; \

} \

PyObject *args = Py_BuildValue PARSE_FORMAT; \

if (args == NULL) { \

flag_error(self); \

return RETURN_VARIABLE; \

} \

if (!have_handler(self, NAME)) { \

Py_DECREF(args); \

return RETURN_VARIABLE; \

} \

self->in_callback = 1; \

PyObject *rv = call_with_frame( \

#NAME, __LINE__, \

self->handlers[NAME], args, self); \

Py_DECREF(args); \

if (rv == NULL) { \

self->in_callback = 0; \

flag_error(self); \

return RETURN_VARIABLE; \

} \

CONVERSION \

/* Releasing the result can run arbitrary code, \

which must still be treated as being within \

the callback by the handler setter. */ \

Py_DECREF(rv); \

self->in_callback = 0; \

if (PyErr_Occurred()) { \

invalid_expat_handler_rv(#NAME); \

} \

return RETURN_VARIABLE; \

}

#define VOID_HANDLER(NAME, PARAMS, PARAM_FORMAT) \

RC_HANDLER( \

void, NAME, PARAMS, \

/* no init */, PARAM_FORMAT, \

/* no conversion */, /* no return var */, \

xmlparseobject_CAST(userData) \

)

#define INT_HANDLER(NAME, PARAMS, PARAM_FORMAT) \

RC_HANDLER( \

int, NAME, PARAMS, \

int rc = 0;, PARAM_FORMAT, \

rc = PyLong_AsLong(rv);, rc, \

xmlparseobject_CAST(userData) \

)

VOID_HANDLER(EndElement,

(void *userData, const XML_Char *name),

("(N)", string_intern(self, name)))

VOID_HANDLER(ProcessingInstruction,

(void *userData,

const XML_Char *target,

const XML_Char *data),

("(NO&)", string_intern(self, target), conv_string_to_unicode_void, data))

VOID_HANDLER(UnparsedEntityDecl,

(void *userData,

const XML_Char *entityName,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId,

const XML_Char *notationName),

("(NNNNN)",

string_intern(self, entityName), string_intern(self, base),

string_intern(self, systemId), string_intern(self, publicId),

string_intern(self, notationName)))

VOID_HANDLER(EntityDecl,

(void *userData,

const XML_Char *entityName,

int is_parameter_entity,

const XML_Char *value,

int value_length,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId,

const XML_Char *notationName),

("NiNNNNN",

string_intern(self, entityName), is_parameter_entity,

(conv_string_len_to_unicode(value, value_length)),

string_intern(self, base), string_intern(self, systemId),

string_intern(self, publicId),

string_intern(self, notationName)))

VOID_HANDLER(XmlDecl,

(void *userData,

const XML_Char *version,

const XML_Char *encoding,

int standalone),

("(O&O&i)",

conv_string_to_unicode_void, version,

conv_string_to_unicode_void, encoding,

standalone))

static PyObject *

conv_content_model(XML_Content * const model,

PyObject *(*conv_string)(void *))

{

if (_Py_EnterRecursiveCall(" in conv_content_model")) {

return NULL;

}

PyObject *result = NULL;

PyObject *children = PyTuple_New(model->numchildren);

int i;

if (children != NULL) {

assert(model->numchildren < INT_MAX);

for (i = 0; i < (int)model->numchildren; ++i) {

PyObject *child = conv_content_model(&model->children[i],

conv_string);

if (child == NULL) {

Py_XDECREF(children);

goto done;

}

PyTuple_SET_ITEM(children, i, child);

}

result = Py_BuildValue("(iiO&N)",

model->type, model->quant,

conv_string, model->name, children);

}

done:

_Py_LeaveRecursiveCall();

return result;

}

static void

my_ElementDeclHandler(void *userData,

const XML_Char *name,

XML_Content *model)

{

xmlparseobject *self = xmlparseobject_CAST(userData);

PyObject *args = NULL;

if (have_handler(self, ElementDecl)) {

PyObject *rv = NULL;

PyObject *modelobj, *nameobj;

if (PyErr_Occurred())

goto finally;

if (flush_character_buffer(self) < 0)

goto finally;

modelobj = conv_content_model(model, conv_string_to_unicode_void);

if (modelobj == NULL) {

flag_error(self);

goto finally;

}

nameobj = string_intern(self, name);

if (nameobj == NULL) {

Py_DECREF(modelobj);

flag_error(self);

goto finally;

}

args = Py_BuildValue("NN", nameobj, modelobj);

if (args == NULL) {

flag_error(self);

goto finally;

}

if (!have_handler(self, ElementDecl)) {

goto finally;

}

self->in_callback = 1;

rv = call_with_frame("ElementDecl", __LINE__,

self->handlers[ElementDecl], args, self);

self->in_callback = 0;

if (rv == NULL) {

flag_error(self);

goto finally;

}

Py_DECREF(rv);

}

finally:

Py_XDECREF(args);

XML_FreeContentModel(self->itself, model);

return;

}

VOID_HANDLER(AttlistDecl,

(void *userData,

const XML_Char *elname,

const XML_Char *attname,

const XML_Char *att_type,

const XML_Char *dflt,

int isrequired),

("(NNO&O&i)",

string_intern(self, elname), string_intern(self, attname),

conv_string_to_unicode_void, att_type,

conv_string_to_unicode_void, dflt,

isrequired))

#if XML_COMBINED_VERSION >= 19504

VOID_HANDLER(SkippedEntity,

(void *userData,

const XML_Char *entityName,

int is_parameter_entity),

("Ni",

string_intern(self, entityName), is_parameter_entity))

#endif

VOID_HANDLER(NotationDecl,

(void *userData,

const XML_Char *notationName,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId),

("(NNNN)",

string_intern(self, notationName), string_intern(self, base),

string_intern(self, systemId), string_intern(self, publicId)))

VOID_HANDLER(StartNamespaceDecl,

(void *userData,

const XML_Char *prefix,

const XML_Char *uri),

("(NN)",

string_intern(self, prefix), string_intern(self, uri)))

VOID_HANDLER(EndNamespaceDecl,

(void *userData,

const XML_Char *prefix),

("(N)", string_intern(self, prefix)))

VOID_HANDLER(Comment,

(void *userData, const XML_Char *data),

("(O&)", conv_string_to_unicode_void, data))

VOID_HANDLER(StartCdataSection,

(void *userData),

("()"))

VOID_HANDLER(EndCdataSection,

(void *userData),

("()"))

VOID_HANDLER(Default,

(void *userData, const XML_Char *s, int len),

("(N)", (conv_string_len_to_unicode(s,len))))

VOID_HANDLER(DefaultHandlerExpand,

(void *userData, const XML_Char *s, int len),

("(N)", (conv_string_len_to_unicode(s,len))))

#define my_DefaultHandlerExpand my_DefaultHandlerExpandHandler

INT_HANDLER(NotStandalone,

(void *userData),

("()"))

RC_HANDLER(int, ExternalEntityRef,

(XML_Parser parser,

const XML_Char *context,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId),

int rc=0;,

("(O&NNN)",

conv_string_to_unicode_void, context,

string_intern(self, base),

string_intern(self, systemId), string_intern(self, publicId)),

rc = PyLong_AsLong(rv);, rc,

XML_GetUserData(parser))

/* XXX UnknownEncodingHandler */

VOID_HANDLER(StartDoctypeDecl,

(void *userData, const XML_Char *doctypeName,

const XML_Char *sysid, const XML_Char *pubid,

int has_internal_subset),

("(NNNi)", string_intern(self, doctypeName),

string_intern(self, sysid), string_intern(self, pubid),

has_internal_subset))

VOID_HANDLER(EndDoctypeDecl, (void *userData), ("()"))

/* check that the current function is not called from within a handler */

#define CHECK_NOT_IN_HANDLER(PARSER, FUNCNAME) \

do { \

if (PARSER->in_callback) { \

PyErr_SetString(PyExc_RuntimeError, \

"cannot call " FUNCNAME "() " \

"from within a handler"); \

return NULL; \

} \

} while (0)

/* ---------------------------------------------------------------- */

/*[clinic input]

class pyexpat.xmlparser "xmlparseobject *" "&Xmlparsetype"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=2393162385232e1c]*/

static PyObject *

get_parse_result(pyexpat_state *state, xmlparseobject *self, int rv)

{

if (PyErr_Occurred()) {

return NULL;

}

if (rv == 0) {

return set_error(state, self, XML_GetErrorCode(self->itself));

}

if (flush_character_buffer(self) < 0) {

return NULL;

}

return PyLong_FromLong(rv);

}

#define MAX_CHUNK_SIZE (1 << 20)

/*[clinic input]

@permit_long_summary

pyexpat.xmlparser.SetReparseDeferralEnabled

enabled: bool

/

Enable/Disable reparse deferral; enabled by default with Expat >=2.6.0.

[clinic start generated code]*/

static PyObject *

pyexpat_xmlparser_SetReparseDeferralEnabled_impl(xmlparseobject *self,

int enabled)

/*[clinic end generated code: output=5ec539e3b63c8c49 input=6d3743500dcee799]*/

{

#if XML_COMBINED_VERSION >= 20600

XML_SetReparseDeferralEnabled(self->itself, enabled ? XML_TRUE : XML_FALSE);

self->reparse_deferral_enabled = (bool)enabled;

#endif

Py_RETURN_NONE;

}

/*[clinic input]

@permit_long_summary

pyexpat.xmlparser.GetReparseDeferralEnabled

Retrieve reparse deferral enabled status; always returns false with Expat <2.6.0.

[clinic start generated code]*/

static PyObject *

pyexpat_xmlparser_GetReparseDeferralEnabled_impl(xmlparseobject *self)

/*[clinic end generated code: output=4e91312e88a595a8 input=ae02d7152ab9e2d0]*/

{

return PyBool_FromLong(self->reparse_deferral_enabled);

}

/*[clinic input]

pyexpat.xmlparser.Parse

cls: defining_class

data: object

isfinal: bool = False

/

Parse XML data.

'data' can be a bytes-like object or a string. If it is a string,

the encoding declaration in the XML data is ignored.

'isfinal' should be true at end of input.

[clinic start generated code]*/

static PyObject *

pyexpat_xmlparser_Parse_impl(xmlparseobject *self, PyTypeObject *cls,

PyObject *data, int isfinal)

/*[clinic end generated code: output=8faffe07fe1f862a input=f8f3ba4eadf837e5]*/

{

// avoid re-entrant calls to XML_Parse()

CHECK_NOT_IN_HANDLER(self, "Parse");

const char *s;

Py_ssize_t slen;

Py_buffer view;

int rc;

pyexpat_state *state = PyType_GetModuleState(cls);

if (PyUnicode_Check(data)) {

view.buf = NULL;

s = PyUnicode_AsUTF8AndSize(data, &slen);

if (s == NULL)

return NULL;

/* Explicitly set UTF-8 encoding. Return code ignored. */

(void)XML_SetEncoding(self->itself, "utf-8");

}

else {

if (PyObject_GetBuffer(data, &view, PyBUF_SIMPLE) < 0)

return NULL;

s = view.buf;

slen = view.len;

}

static_assert(MAX_CHUNK_SIZE <= INT_MAX,

"MAX_CHUNK_SIZE is larger than INT_MAX");

while (slen > MAX_CHUNK_SIZE) {

rc = XML_Parse(self->itself, s, MAX_CHUNK_SIZE, 0);

if (!rc)

goto done;

s += MAX_CHUNK_SIZE;

slen -= MAX_CHUNK_SIZE;

}

assert(slen <= INT_MAX);

rc = XML_Parse(self->itself, s, (int)slen, isfinal);

done:

if (view.buf != NULL) {

PyBuffer_Release(&view);

}

return get_parse_result(state, self, rc);

}

/* File reading copied from cPickle */

#define BUF_SIZE 2048

static int

readinst(char *buf, int buf_size, PyObject *meth)

{

PyObject *str;

Py_ssize_t len;

const char *ptr;

str = PyObject_CallFunction(meth, "i", buf_size);

if (str == NULL)

goto error;