/*-------------------------------------------------------------------- * Licensed to PSF under a Contributor Agreement. * See https://www.python.org/psf/license for licensing details. * * _elementtree - C accelerator for xml.etree.ElementTree * Copyright (c) 1999-2009 by Secret Labs AB. All rights reserved. * Copyright (c) 1999-2009 by Fredrik Lundh. * * [email protected] * http://www.pythonware.com *-------------------------------------------------------------------- */ #ifndef Py_BUILD_CORE_BUILTIN #define Py_BUILD_CORE_MODULE … #endif #include "Python.h" #include "pycore_import.h" // _PyImport_GetModuleAttrString() #include "pycore_pyhash.h" // _Py_HashSecret #include <stddef.h> // offsetof() #include "expat.h" #include "pyexpat.h" /* -------------------------------------------------------------------- */ /* configuration */ /* An element can hold this many children without extra memory allocations. */ #define STATIC_CHILDREN … /* For best performance, chose a value so that 80-90% of all nodes have no more than the given number of children. Set this to zero to minimize the size of the element structure itself (this only helps if you have lots of leaf nodes with attributes). */ /* Also note that pymalloc always allocates blocks in multiples of eight bytes. For the current C version of ElementTree, this means that the number of children should be an even number, at least on 32-bit platforms. */ /* -------------------------------------------------------------------- */ /* compiler tweaks */ #if defined(_MSC_VER) #define LOCAL … #else #define LOCAL(type) … #endif /* macros used to store 'join' flags in string object pointers. note that all use of text and tail as object pointers must be wrapped in JOIN_OBJ. see comments in the ElementObject definition for more info. */ #define JOIN_GET(p) … #define JOIN_SET(p, flag) … #define JOIN_OBJ(p) … /* Py_SETREF for a PyObject* that uses a join flag. */ Py_LOCAL_INLINE(void) _set_joined_ptr(PyObject **p, PyObject *new_joined_ptr) { … } /* Py_CLEAR for a PyObject* that uses a join flag. Pass the pointer by * reference since this function sets it to NULL. */ static void _clear_joined_ptr(PyObject **p) { … } /* Per-module state; PEP 3121 */ elementtreestate; static struct PyModuleDef elementtreemodule; /* Given a module object (assumed to be _elementtree), get its per-module * state. */ static inline elementtreestate* get_elementtree_state(PyObject *module) { … } static inline elementtreestate * get_elementtree_state_by_cls(PyTypeObject *cls) { … } static inline elementtreestate * get_elementtree_state_by_type(PyTypeObject *tp) { … } static int elementtree_clear(PyObject *m) { … } static int elementtree_traverse(PyObject *m, visitproc visit, void *arg) { … } static void elementtree_free(void *m) { … } /* helpers */ LOCAL(PyObject*) list_join(PyObject* list) { … } /* Is the given object an empty dictionary? */ static int is_empty_dict(PyObject *obj) { … } /* -------------------------------------------------------------------- */ /* the Element type */ ElementObjectExtra; ElementObject; #define Element_CheckExact(st, op) … #define Element_Check(st, op) … /* -------------------------------------------------------------------- */ /* Element constructors and destructor */ LOCAL(int) create_extra(ElementObject* self, PyObject* attrib) { … } LOCAL(void) dealloc_extra(ElementObjectExtra *extra) { … } LOCAL(void) clear_extra(ElementObject* self) { … } /* Convenience internal function to create new Element objects with the given * tag and attributes. */ LOCAL(PyObject*) create_new_element(elementtreestate *st, PyObject *tag, PyObject *attrib) { … } static PyObject * element_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { … } /* Helper function for extracting the attrib dictionary from a keywords dict. * This is required by some constructors/functions in this module that can * either accept attrib as a keyword argument or all attributes splashed * directly into *kwds. * * Return a dictionary with the content of kwds merged into the content of * attrib. If there is no attrib keyword, return a copy of kwds. */ static PyObject* get_attrib_from_keywords(PyObject *kwds) { … } /*[clinic input] module _elementtree class _elementtree.Element "ElementObject *" "clinic_state()->Element_Type" class _elementtree.TreeBuilder "TreeBuilderObject *" "clinic_state()->TreeBuilder_Type" class _elementtree.XMLParser "XMLParserObject *" "clinic_state()->XMLParser_Type" [clinic start generated code]*/ /*[clinic end generated code: output=da39a3ee5e6b4b0d input=6c83ea832d2b0ef1]*/ static int element_init(PyObject *self, PyObject *args, PyObject *kwds) { … } LOCAL(int) element_resize(ElementObject* self, Py_ssize_t extra) { … } LOCAL(void) raise_type_error(PyObject *element) { … } LOCAL(int) element_add_subelement(elementtreestate *st, ElementObject *self, PyObject *element) { … } LOCAL(PyObject*) element_get_attrib(ElementObject* self) { … } LOCAL(PyObject*) element_get_text(ElementObject* self) { … } LOCAL(PyObject*) element_get_tail(ElementObject* self) { … } static PyObject* subelement(PyObject *self, PyObject *args, PyObject *kwds) { … } static int element_gc_traverse(ElementObject *self, visitproc visit, void *arg) { … } static int element_gc_clear(ElementObject *self) { … } static void element_dealloc(ElementObject* self) { … } /* -------------------------------------------------------------------- */ /*[clinic input] _elementtree.Element.append cls: defining_class subelement: object(subclass_of='clinic_state()->Element_Type') / [clinic start generated code]*/ static PyObject * _elementtree_Element_append_impl(ElementObject *self, PyTypeObject *cls, PyObject *subelement) /*[clinic end generated code: output=d00923711ea317fc input=8baf92679f9717b8]*/ { … } /*[clinic input] _elementtree.Element.clear [clinic start generated code]*/ static PyObject * _elementtree_Element_clear_impl(ElementObject *self) /*[clinic end generated code: output=8bcd7a51f94cfff6 input=3c719ff94bf45dd6]*/ { … } /*[clinic input] _elementtree.Element.__copy__ cls: defining_class / [clinic start generated code]*/ static PyObject * _elementtree_Element___copy___impl(ElementObject *self, PyTypeObject *cls) /*[clinic end generated code: output=da22894421ff2b36 input=91edb92d9f441213]*/ { … } /* Helper for a deep copy. */ LOCAL(PyObject *) deepcopy(elementtreestate *, PyObject *, PyObject *); /*[clinic input] _elementtree.Element.__deepcopy__ memo: object(subclass_of="&PyDict_Type") / [clinic start generated code]*/ static PyObject * _elementtree_Element___deepcopy___impl(ElementObject *self, PyObject *memo) /*[clinic end generated code: output=eefc3df50465b642 input=a2d40348c0aade10]*/ { … } LOCAL(PyObject *) deepcopy(elementtreestate *st, PyObject *object, PyObject *memo) { … } /*[clinic input] _elementtree.Element.__sizeof__ -> size_t [clinic start generated code]*/ static size_t _elementtree_Element___sizeof___impl(ElementObject *self) /*[clinic end generated code: output=baae4e7ae9fe04ec input=54e298c501f3e0d0]*/ { … } /* dict keys for getstate/setstate. */ #define PICKLED_TAG … #define PICKLED_CHILDREN … #define PICKLED_ATTRIB … #define PICKLED_TAIL … #define PICKLED_TEXT … /* __getstate__ returns a fabricated instance dict as in the pure-Python * Element implementation, for interoperability/interchangeability. This * makes the pure-Python implementation details an API, but (a) there aren't * any unnecessary structures there; and (b) it buys compatibility with 3.2 * pickles. See issue #16076. */ /*[clinic input] _elementtree.Element.__getstate__ [clinic start generated code]*/ static PyObject * _elementtree_Element___getstate___impl(ElementObject *self) /*[clinic end generated code: output=37279aeeb6bb5b04 input=f0d16d7ec2f7adc1]*/ { … } static PyObject * element_setstate_from_attributes(elementtreestate *st, ElementObject *self, PyObject *tag, PyObject *attrib, PyObject *text, PyObject *tail, PyObject *children) { … } /* __setstate__ for Element instance from the Python implementation. * 'state' should be the instance dict. */ static PyObject * element_setstate_from_Python(elementtreestate *st, ElementObject *self, PyObject *state) { … } /*[clinic input] _elementtree.Element.__setstate__ cls: defining_class state: object / [clinic start generated code]*/ static PyObject * _elementtree_Element___setstate___impl(ElementObject *self, PyTypeObject *cls, PyObject *state) /*[clinic end generated code: output=598bfb5730f71509 input=13830488d35d51f7]*/ { … } LOCAL(int) checkpath(PyObject* tag) { … } /*[clinic input] _elementtree.Element.extend cls: defining_class elements: object / [clinic start generated code]*/ static PyObject * _elementtree_Element_extend_impl(ElementObject *self, PyTypeObject *cls, PyObject *elements) /*[clinic end generated code: output=3e86d37fac542216 input=6479b1b5379d09ae]*/ { … } /*[clinic input] _elementtree.Element.find cls: defining_class / path: object namespaces: object = None [clinic start generated code]*/ static PyObject * _elementtree_Element_find_impl(ElementObject *self, PyTypeObject *cls, PyObject *path, PyObject *namespaces) /*[clinic end generated code: output=18f77d393c9fef1b input=94df8a83f956acc6]*/ { … } /*[clinic input] _elementtree.Element.findtext cls: defining_class / path: object default: object = None namespaces: object = None [clinic start generated code]*/ static PyObject * _elementtree_Element_findtext_impl(ElementObject *self, PyTypeObject *cls, PyObject *path, PyObject *default_value, PyObject *namespaces) /*[clinic end generated code: output=6af7a2d96aac32cb input=32f252099f62a3d2]*/ { … } /*[clinic input] _elementtree.Element.findall cls: defining_class / path: object namespaces: object = None [clinic start generated code]*/ static PyObject * _elementtree_Element_findall_impl(ElementObject *self, PyTypeObject *cls, PyObject *path, PyObject *namespaces) /*[clinic end generated code: output=65e39a1208f3b59e input=7aa0db45673fc9a5]*/ { … } /*[clinic input] _elementtree.Element.iterfind cls: defining_class / path: object namespaces: object = None [clinic start generated code]*/ static PyObject * _elementtree_Element_iterfind_impl(ElementObject *self, PyTypeObject *cls, PyObject *path, PyObject *namespaces) /*[clinic end generated code: output=be5c3f697a14e676 input=88766875a5c9a88b]*/ { … } /*[clinic input] _elementtree.Element.get key: object default: object = None [clinic start generated code]*/ static PyObject * _elementtree_Element_get_impl(ElementObject *self, PyObject *key, PyObject *default_value) /*[clinic end generated code: output=523c614142595d75 input=ee153bbf8cdb246e]*/ { … } static PyObject * create_elementiter(elementtreestate *st, ElementObject *self, PyObject *tag, int gettext); /*[clinic input] _elementtree.Element.iter cls: defining_class / tag: object = None [clinic start generated code]*/ static PyObject * _elementtree_Element_iter_impl(ElementObject *self, PyTypeObject *cls, PyObject *tag) /*[clinic end generated code: output=bff29dc5d4566c68 input=f6944c48d3f84c58]*/ { … } /*[clinic input] _elementtree.Element.itertext cls: defining_class / [clinic start generated code]*/ static PyObject * _elementtree_Element_itertext_impl(ElementObject *self, PyTypeObject *cls) /*[clinic end generated code: output=fdeb2a3bca0ae063 input=a1ef1f0fc872a586]*/ { … } static PyObject* element_getitem(PyObject* self_, Py_ssize_t index) { … } static int element_bool(PyObject* self_) { … } /*[clinic input] _elementtree.Element.insert index: Py_ssize_t subelement: object(subclass_of='clinic_state()->Element_Type') / [clinic start generated code]*/ static PyObject * _elementtree_Element_insert_impl(ElementObject *self, Py_ssize_t index, PyObject *subelement) /*[clinic end generated code: output=990adfef4d424c0b input=9530f4905aa401ca]*/ { … } /*[clinic input] _elementtree.Element.items [clinic start generated code]*/ static PyObject * _elementtree_Element_items_impl(ElementObject *self) /*[clinic end generated code: output=6db2c778ce3f5a4d input=adbe09aaea474447]*/ { … } /*[clinic input] _elementtree.Element.keys [clinic start generated code]*/ static PyObject * _elementtree_Element_keys_impl(ElementObject *self) /*[clinic end generated code: output=bc5bfabbf20eeb3c input=f02caf5b496b5b0b]*/ { … } static Py_ssize_t element_length(ElementObject* self) { … } /*[clinic input] _elementtree.Element.makeelement cls: defining_class tag: object attrib: object(subclass_of='&PyDict_Type') / [clinic start generated code]*/ static PyObject * _elementtree_Element_makeelement_impl(ElementObject *self, PyTypeObject *cls, PyObject *tag, PyObject *attrib) /*[clinic end generated code: output=d50bb17a47077d47 input=589829dab92f26e8]*/ { … } /*[clinic input] _elementtree.Element.remove subelement: object(subclass_of='clinic_state()->Element_Type') / [clinic start generated code]*/ static PyObject * _elementtree_Element_remove_impl(ElementObject *self, PyObject *subelement) /*[clinic end generated code: output=38fe6c07d6d87d1f input=6133e1d05597d5ee]*/ { … } static PyObject* element_repr(ElementObject* self) { … } /*[clinic input] _elementtree.Element.set key: object value: object / [clinic start generated code]*/ static PyObject * _elementtree_Element_set_impl(ElementObject *self, PyObject *key, PyObject *value) /*[clinic end generated code: output=fb938806be3c5656 input=1efe90f7d82b3fe9]*/ { … } static int element_setitem(PyObject* self_, Py_ssize_t index, PyObject* item) { … } static PyObject* element_subscr(PyObject* self_, PyObject* item) { … } static int element_ass_subscr(PyObject* self_, PyObject* item, PyObject* value) { … } static PyObject* element_tag_getter(ElementObject *self, void *closure) { … } static PyObject* element_text_getter(ElementObject *self, void *closure) { … } static PyObject* element_tail_getter(ElementObject *self, void *closure) { … } static PyObject* element_attrib_getter(ElementObject *self, void *closure) { … } /* macro for setter validation */ #define _VALIDATE_ATTR_VALUE(V) … static int element_tag_setter(ElementObject *self, PyObject *value, void *closure) { … } static int element_text_setter(ElementObject *self, PyObject *value, void *closure) { … } static int element_tail_setter(ElementObject *self, PyObject *value, void *closure) { … } static int element_attrib_setter(ElementObject *self, PyObject *value, void *closure) { … } /******************************* Element iterator ****************************/ /* ElementIterObject represents the iteration state over an XML element in * pre-order traversal. To keep track of which sub-element should be returned * next, a stack of parents is maintained. This is a standard stack-based * iterative pre-order traversal of a tree. * The stack is managed using a continuous array. * Each stack item contains the saved parent to which we should return after * the current one is exhausted, and the next child to examine in that parent. */ ParentLocator; ElementIterObject; static void elementiter_dealloc(ElementIterObject *it) { … } static int elementiter_traverse(ElementIterObject *it, visitproc visit, void *arg) { … } /* Helper function for elementiter_next. Add a new parent to the parent stack. */ static int parent_stack_push_new(ElementIterObject *it, ElementObject *parent) { … } static PyObject * elementiter_next(ElementIterObject *it) { … } static PyType_Slot elementiter_slots[] = …; static PyType_Spec elementiter_spec = …; #define INIT_PARENT_STACK_SIZE … static PyObject * create_elementiter(elementtreestate *st, ElementObject *self, PyObject *tag, int gettext) { … } /* ==================================================================== */ /* the tree builder type */ TreeBuilderObject; #define TreeBuilder_CheckExact(st, op) … /* -------------------------------------------------------------------- */ /* constructor and destructor */ static PyObject * treebuilder_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { … } /*[clinic input] _elementtree.TreeBuilder.__init__ element_factory: object = None * comment_factory: object = None pi_factory: object = None insert_comments: bool = False insert_pis: bool = False [clinic start generated code]*/ static int _elementtree_TreeBuilder___init___impl(TreeBuilderObject *self, PyObject *element_factory, PyObject *comment_factory, PyObject *pi_factory, int insert_comments, int insert_pis) /*[clinic end generated code: output=8571d4dcadfdf952 input=ae98a94df20b5cc3]*/ { … } static int treebuilder_gc_traverse(TreeBuilderObject *self, visitproc visit, void *arg) { … } static int treebuilder_gc_clear(TreeBuilderObject *self) { … } static void treebuilder_dealloc(TreeBuilderObject *self) { … } /* -------------------------------------------------------------------- */ /* helpers for handling of arbitrary element-like objects */ /*[clinic input] _elementtree._set_factories comment_factory: object pi_factory: object / Change the factories used to create comments and processing instructions. For internal use only. [clinic start generated code]*/ static PyObject * _elementtree__set_factories_impl(PyObject *module, PyObject *comment_factory, PyObject *pi_factory) /*[clinic end generated code: output=813b408adee26535 input=99d17627aea7fb3b]*/ { … } static int treebuilder_extend_element_text_or_tail(elementtreestate *st, PyObject *element, PyObject **data, PyObject **dest, PyObject *name) { … } LOCAL(int) treebuilder_flush_data(TreeBuilderObject* self) { … } static int treebuilder_add_subelement(elementtreestate *st, PyObject *element, PyObject *child) { … } LOCAL(int) treebuilder_append_event(TreeBuilderObject *self, PyObject *action, PyObject *node) { … } /* -------------------------------------------------------------------- */ /* handlers */ LOCAL(PyObject*) treebuilder_handle_start(TreeBuilderObject* self, PyObject* tag, PyObject* attrib) { … } LOCAL(PyObject*) treebuilder_handle_data(TreeBuilderObject* self, PyObject* data) { … } LOCAL(PyObject*) treebuilder_handle_end(TreeBuilderObject* self, PyObject* tag) { … } LOCAL(PyObject*) treebuilder_handle_comment(TreeBuilderObject* self, PyObject* text) { … } LOCAL(PyObject*) treebuilder_handle_pi(TreeBuilderObject* self, PyObject* target, PyObject* text) { … } LOCAL(PyObject*) treebuilder_handle_start_ns(TreeBuilderObject* self, PyObject* prefix, PyObject* uri) { … } LOCAL(PyObject*) treebuilder_handle_end_ns(TreeBuilderObject* self, PyObject* prefix) { … } /* -------------------------------------------------------------------- */ /* methods (in alphabetical order) */ /*[clinic input] _elementtree.TreeBuilder.data data: object / [clinic start generated code]*/ static PyObject * _elementtree_TreeBuilder_data(TreeBuilderObject *self, PyObject *data) /*[clinic end generated code: output=69144c7100795bb2 input=a0540c532b284d29]*/ { … } /*[clinic input] _elementtree.TreeBuilder.end tag: object / [clinic start generated code]*/ static PyObject * _elementtree_TreeBuilder_end(TreeBuilderObject *self, PyObject *tag) /*[clinic end generated code: output=9a98727cc691cd9d input=22dc3674236f5745]*/ { … } /*[clinic input] _elementtree.TreeBuilder.comment text: object / [clinic start generated code]*/ static PyObject * _elementtree_TreeBuilder_comment(TreeBuilderObject *self, PyObject *text) /*[clinic end generated code: output=22835be41deeaa27 input=47e7ebc48ed01dfa]*/ { … } /*[clinic input] _elementtree.TreeBuilder.pi target: object text: object = None / [clinic start generated code]*/ static PyObject * _elementtree_TreeBuilder_pi_impl(TreeBuilderObject *self, PyObject *target, PyObject *text) /*[clinic end generated code: output=21eb95ec9d04d1d9 input=349342bd79c35570]*/ { … } LOCAL(PyObject*) treebuilder_done(TreeBuilderObject* self) { … } /*[clinic input] _elementtree.TreeBuilder.close [clinic start generated code]*/ static PyObject * _elementtree_TreeBuilder_close_impl(TreeBuilderObject *self) /*[clinic end generated code: output=b441fee3202f61ee input=f7c9c65dc718de14]*/ { … } /*[clinic input] _elementtree.TreeBuilder.start tag: object attrs: object(subclass_of='&PyDict_Type') / [clinic start generated code]*/ static PyObject * _elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag, PyObject *attrs) /*[clinic end generated code: output=e7e9dc2861349411 input=7288e9e38e63b2b6]*/ { … } /* ==================================================================== */ /* the expat interface */ #define EXPAT(st, func) … static XML_Memory_Handling_Suite ExpatMemoryHandler = …; XMLParserObject; /* helpers */ LOCAL(PyObject*) makeuniversal(XMLParserObject* self, const char* string) { … } /* Set the ParseError exception with the given parameters. * If message is not NULL, it's used as the error string. Otherwise, the * message string is the default for the given error_code. */ static void expat_set_error(elementtreestate *st, enum XML_Error error_code, Py_ssize_t line, Py_ssize_t column, const char *message) { … } /* -------------------------------------------------------------------- */ /* handlers */ static void expat_default_handler(XMLParserObject* self, const XML_Char* data_in, int data_len) { … } static void expat_start_handler(XMLParserObject* self, const XML_Char* tag_in, const XML_Char **attrib_in) { … } static void expat_data_handler(XMLParserObject* self, const XML_Char* data_in, int data_len) { … } static void expat_end_handler(XMLParserObject* self, const XML_Char* tag_in) { … } static void expat_start_ns_handler(XMLParserObject* self, const XML_Char* prefix_in, const XML_Char *uri_in) { … } static void expat_end_ns_handler(XMLParserObject* self, const XML_Char* prefix_in) { … } static void expat_comment_handler(XMLParserObject* self, const XML_Char* comment_in) { … } static void expat_start_doctype_handler(XMLParserObject *self, const XML_Char *doctype_name, const XML_Char *sysid, const XML_Char *pubid, int has_internal_subset) { … } static void expat_pi_handler(XMLParserObject* self, const XML_Char* target_in, const XML_Char* data_in) { … } /* -------------------------------------------------------------------- */ static PyObject * xmlparser_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { … } static int ignore_attribute_error(PyObject *value) { … } /*[clinic input] _elementtree.XMLParser.__init__ * target: object = None encoding: str(accept={str, NoneType}) = None [clinic start generated code]*/ static int _elementtree_XMLParser___init___impl(XMLParserObject *self, PyObject *target, const char *encoding) /*[clinic end generated code: output=3ae45ec6cdf344e4 input=7e716dd6e4f3e439]*/ { … } static int xmlparser_gc_traverse(XMLParserObject *self, visitproc visit, void *arg) { … } static int xmlparser_gc_clear(XMLParserObject *self) { … } static void xmlparser_dealloc(XMLParserObject* self) { … } Py_LOCAL_INLINE(int) _check_xmlparser(XMLParserObject* self) { … } LOCAL(PyObject*) expat_parse(elementtreestate *st, XMLParserObject *self, const char *data, int data_len, int final) { … } /*[clinic input] _elementtree.XMLParser.close [clinic start generated code]*/ static PyObject * _elementtree_XMLParser_close_impl(XMLParserObject *self) /*[clinic end generated code: output=d68d375dd23bc7fb input=ca7909ca78c3abfe]*/ { … } /*[clinic input] _elementtree.XMLParser.flush [clinic start generated code]*/ static PyObject * _elementtree_XMLParser_flush_impl(XMLParserObject *self) /*[clinic end generated code: output=42fdb8795ca24509 input=effbecdb28715949]*/ { … } /*[clinic input] _elementtree.XMLParser.feed data: object / [clinic start generated code]*/ static PyObject * _elementtree_XMLParser_feed(XMLParserObject *self, PyObject *data) /*[clinic end generated code: output=e42b6a78eec7446d input=fe231b6b8de3ce1f]*/ { … } /*[clinic input] _elementtree.XMLParser._parse_whole file: object / [clinic start generated code]*/ static PyObject * _elementtree_XMLParser__parse_whole(XMLParserObject *self, PyObject *file) /*[clinic end generated code: output=f797197bb818dda3 input=19ecc893b6f3e752]*/ { … } /*[clinic input] _elementtree.XMLParser._setevents events_queue: object events_to_report: object = None / [clinic start generated code]*/ static PyObject * _elementtree_XMLParser__setevents_impl(XMLParserObject *self, PyObject *events_queue, PyObject *events_to_report) /*[clinic end generated code: output=1440092922b13ed1 input=abf90830a1c3b0fc]*/ { … } static PyMemberDef xmlparser_members[] = …; static PyObject* xmlparser_version_getter(XMLParserObject *self, void *closure) { … } static PyGetSetDef xmlparser_getsetlist[] = …; #define clinic_state … #include "clinic/_elementtree.c.h" #undef clinic_state static PyMethodDef element_methods[] = …; static struct PyMemberDef element_members[] = …; static PyGetSetDef element_getsetlist[] = …; static PyType_Slot element_slots[] = …; static PyType_Spec element_spec = …; static PyMethodDef treebuilder_methods[] = …; static PyType_Slot treebuilder_slots[] = …; static PyType_Spec treebuilder_spec = …; static PyMethodDef xmlparser_methods[] = …; static PyType_Slot xmlparser_slots[] = …; static PyType_Spec xmlparser_spec = …; /* ==================================================================== */ /* python module interface */ static PyMethodDef _functions[] = …; #define CREATE_TYPE(module, type, spec) … static int module_exec(PyObject *m) { … } static struct PyModuleDef_Slot elementtree_slots[] = …; static struct PyModuleDef elementtreemodule = …; PyMODINIT_FUNC PyInit__elementtree(void) { … }
Codebase Browser
cpython