Lines Matching refs:self
216 create_extra(ElementObject* self, PyObject* attrib)
218 self->extra = PyObject_Malloc(sizeof(ElementObjectExtra));
219 if (!self->extra) {
225 self->extra->attrib = attrib;
227 self->extra->length = 0;
228 self->extra->allocated = STATIC_CHILDREN;
229 self->extra->children = self->extra->_children;
254 clear_extra(ElementObject* self)
258 if (!self->extra)
263 myextra = self->extra;
264 self->extra = NULL;
275 ElementObject* self;
277 self = PyObject_GC_New(ElementObject, &Element_Type);
278 if (self == NULL)
280 self->extra = NULL;
283 self->tag = tag;
286 self->text = Py_None;
289 self->tail = Py_None;
291 self->weakreflist = NULL;
293 PyObject_GC_Track(self);
296 if (create_extra(self, attrib) < 0) {
297 Py_DECREF(self);
302 return (PyObject*) self;
380 element_init(PyObject *self, PyObject *args, PyObject *kwds)
407 self_elem = (ElementObject *)self;
433 element_resize(ElementObject* self, Py_ssize_t extra)
439 /* make sure self->children can hold the given number of extra
442 if (!self->extra) {
443 if (create_extra(self, NULL) < 0)
447 size = self->extra->length + extra; /* never overflows */
449 if (size > self->extra->allocated) {
460 if (self->extra->children != self->extra->_children) {
465 children = PyObject_Realloc(self->extra->children,
474 memcpy(children, self->extra->children,
475 self->extra->length * sizeof(PyObject*));
477 self->extra->children = children;
478 self->extra->allocated = size;
497 element_add_subelement(ElementObject* self, PyObject* element)
506 if (element_resize(self, 1) < 0)
510 self->extra->children[self->extra->length] = element;
512 self->extra->length++;
518 element_get_attrib(ElementObject* self)
523 PyObject* res = self->extra->attrib;
527 res = self->extra->attrib = PyDict_New();
534 element_get_text(ElementObject* self)
538 PyObject *res = self->text;
546 self->text = tmp;
556 element_get_tail(ElementObject* self)
560 PyObject *res = self->tail;
568 self->tail = tmp;
578 subelement(PyObject *self, PyObject *args, PyObject *kwds)
623 element_gc_traverse(ElementObject *self, visitproc visit, void *arg)
625 Py_VISIT(self->tag);
626 Py_VISIT(JOIN_OBJ(self->text));
627 Py_VISIT(JOIN_OBJ(self->tail));
629 if (self->extra) {
631 Py_VISIT(self->extra->attrib);
633 for (i = 0; i < self->extra->length; ++i)
634 Py_VISIT(self->extra->children[i]);
640 element_gc_clear(ElementObject *self)
642 Py_CLEAR(self->tag);
643 _clear_joined_ptr(&self->text);
644 _clear_joined_ptr(&self->tail);
649 clear_extra(self);
654 element_dealloc(ElementObject* self)
657 PyObject_GC_UnTrack(self);
658 Py_TRASHCAN_BEGIN(self, element_dealloc)
660 if (self->weakreflist != NULL)
661 PyObject_ClearWeakRefs((PyObject *) self);
665 element_gc_clear(self);
667 Py_TYPE(self)->tp_free((PyObject *)self);
682 _elementtree_Element_append_impl(ElementObject *self, PyObject *subelement)
685 if (element_add_subelement(self, subelement) < 0)
697 _elementtree_Element_clear_impl(ElementObject *self)
700 clear_extra(self);
703 _set_joined_ptr(&self->text, Py_None);
706 _set_joined_ptr(&self->tail, Py_None);
717 _elementtree_Element___copy___impl(ElementObject *self)
724 self->tag, self->extra ? self->extra->attrib : NULL);
728 Py_INCREF(JOIN_OBJ(self->text));
729 _set_joined_ptr(&element->text, self->text);
731 Py_INCREF(JOIN_OBJ(self->tail));
732 _set_joined_ptr(&element->tail, self->tail);
735 if (self->extra) {
736 if (element_resize(element, self->extra->length) < 0) {
741 for (i = 0; i < self->extra->length; i++) {
742 Py_INCREF(self->extra->children[i]);
743 element->extra->children[i] = self->extra->children[i];
747 element->extra->length = self->extra->length;
765 _elementtree_Element___deepcopy___impl(ElementObject *self, PyObject *memo)
776 tag = deepcopy(self->tag, memo);
780 if (self->extra && self->extra->attrib) {
781 attrib = deepcopy(self->extra->attrib, memo);
798 text = deepcopy(JOIN_OBJ(self->text), memo);
801 _set_joined_ptr(&element->text, JOIN_SET(text, JOIN_GET(self->text)));
803 tail = deepcopy(JOIN_OBJ(self->tail), memo);
806 _set_joined_ptr(&element->tail, JOIN_SET(tail, JOIN_GET(self->tail)));
809 if (self->extra) {
810 if (element_resize(element, self->extra->length) < 0)
813 for (i = 0; i < self->extra->length; i++) {
814 PyObject* child = deepcopy(self->extra->children[i], memo);
827 element->extra->length = self->extra->length;
831 id = PyLong_FromSsize_t((uintptr_t) self);
903 _elementtree_Element___sizeof___impl(ElementObject *self)
906 Py_ssize_t result = _PyObject_SIZE(Py_TYPE(self));
907 if (self->extra) {
909 if (self->extra->children != self->extra->_children)
910 result += sizeof(PyObject*) * self->extra->allocated;
934 _elementtree_Element___getstate___impl(ElementObject *self)
941 children = PyList_New(self->extra ? self->extra->length : 0);
945 PyObject *child = self->extra->children[i];
950 if (self->extra && self->extra->attrib) {
951 attrib = self->extra->attrib;
963 PICKLED_TAG, self->tag,
966 PICKLED_TEXT, JOIN_OBJ(self->text),
967 PICKLED_TAIL, JOIN_OBJ(self->tail));
971 element_setstate_from_attributes(ElementObject *self,
987 Py_XSETREF(self->tag, tag);
991 _set_joined_ptr(&self->text, text);
995 _set_joined_ptr(&self->tail, tail);
1013 oldextra = self->extra;
1014 self->extra = NULL;
1015 if (element_resize(self, nchildren)) {
1016 assert(!self->extra || !self->extra->length);
1017 clear_extra(self);
1018 self->extra = oldextra;
1021 assert(self->extra);
1022 assert(self->extra->allocated >= nchildren);
1024 assert(self->extra->attrib == NULL);
1025 self->extra->attrib = oldextra->attrib;
1034 self->extra->length = i;
1039 self->extra->children[i] = child;
1042 assert(!self->extra->length);
1043 self->extra->length = nchildren;
1046 if (element_resize(self, 0)) {
1053 Py_XSETREF(self->extra->attrib, attrib);
1064 element_setstate_from_Python(ElementObject *self, PyObject *state)
1079 retval = element_setstate_from_attributes(self, tag, attrib, text,
1097 _elementtree_Element___setstate__(ElementObject *self, PyObject *state)
1107 return element_setstate_from_Python(self, state);
1174 _elementtree_Element_extend(ElementObject *self, PyObject *elements)
1192 if (element_add_subelement(self, element) < 0) {
1214 _elementtree_Element_find_impl(ElementObject *self, PyObject *path,
1224 st->elementpath_obj, &PyId_find, self, path, namespaces, NULL
1228 if (!self->extra)
1231 for (i = 0; i < self->extra->length; i++) {
1232 PyObject* item = self->extra->children[i];
1257 _elementtree_Element_findtext_impl(ElementObject *self, PyObject *path,
1269 self, path, default_value, namespaces, NULL
1272 if (!self->extra) {
1277 for (i = 0; i < self->extra->length; i++) {
1278 PyObject *item = self->extra->children[i];
1311 _elementtree_Element_findall_impl(ElementObject *self, PyObject *path,
1322 st->elementpath_obj, &PyId_findall, self, path, namespaces, NULL
1330 if (!self->extra)
1333 for (i = 0; i < self->extra->length; i++) {
1334 PyObject* item = self->extra->children[i];
1359 _elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path,
1368 st->elementpath_obj, &PyId_iterfind, self, tag, namespaces, NULL);
1380 _elementtree_Element_get_impl(ElementObject *self, PyObject *key,
1384 if (self->extra && self->extra->attrib) {
1385 PyObject *attrib = self->extra->attrib;
1400 create_elementiter(ElementObject *self, PyObject *tag, int gettext);
1411 _elementtree_Element_iter_impl(ElementObject *self, PyObject *tag)
1425 return create_elementiter(self, tag, 0);
1435 _elementtree_Element_itertext_impl(ElementObject *self)
1438 return create_elementiter(self, Py_None, 1);
1445 ElementObject* self = (ElementObject*) self_;
1447 if (!self->extra || index < 0 || index >= self->extra->length) {
1455 Py_INCREF(self->extra->children[index]);
1456 return self->extra->children[index];
1469 _elementtree_Element_insert_impl(ElementObject *self, Py_ssize_t index,
1475 if (!self->extra) {
1476 if (create_extra(self, NULL) < 0)
1481 index += self->extra->length;
1485 if (index > self->extra->length)
1486 index = self->extra->length;
1488 if (element_resize(self, 1) < 0)
1491 for (i = self->extra->length; i > index; i--)
1492 self->extra->children[i] = self->extra->children[i-1];
1495 self->extra->children[index] = subelement;
1497 self->extra->length++;
1508 _elementtree_Element_items_impl(ElementObject *self)
1511 if (!self->extra || !self->extra->attrib)
1514 return PyDict_Items(self->extra->attrib);
1523 _elementtree_Element_keys_impl(ElementObject *self)
1526 if (!self->extra || !self->extra->attrib)
1529 return PyDict_Keys(self->extra->attrib);
1533 element_length(ElementObject* self)
1535 if (!self->extra)
1538 return self->extra->length;
1551 _elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,
1577 _elementtree_Element_remove_impl(ElementObject *self, PyObject *subelement)
1584 if (!self->extra) {
1593 for (i = 0; i < self->extra->length; i++) {
1594 if (self->extra->children[i] == subelement)
1596 rc = PyObject_RichCompareBool(self->extra->children[i], subelement, Py_EQ);
1603 if (i >= self->extra->length) {
1612 found = self->extra->children[i];
1614 self->extra->length--;
1615 for (; i < self->extra->length; i++)
1616 self->extra->children[i] = self->extra->children[i+1];
1623 element_repr(ElementObject* self)
1627 if (self->tag == NULL)
1628 return PyUnicode_FromFormat("<Element at %p>", self);
1630 status = Py_ReprEnter((PyObject *)self);
1633 res = PyUnicode_FromFormat("<Element %R at %p>", self->tag, self);
1634 Py_ReprLeave((PyObject *)self);
1640 Py_TYPE(self)->tp_name);
1654 _elementtree_Element_set_impl(ElementObject *self, PyObject *key,
1660 if (!self->extra) {
1661 if (create_extra(self, NULL) < 0)
1665 attrib = element_get_attrib(self);
1678 ElementObject* self = (ElementObject*) self_;
1682 if (!self->extra || index < 0 || index >= self->extra->length) {
1689 old = self->extra->children[index];
1697 self->extra->children[index] = item;
1699 self->extra->length--;
1700 for (i = index; i < self->extra->length; i++)
1701 self->extra->children[i] = self->extra->children[i+1];
1712 ElementObject* self = (ElementObject*) self_;
1720 if (i < 0 && self->extra)
1721 i += self->extra->length;
1729 if (!self->extra)
1735 slicelen = PySlice_AdjustIndices(self->extra->length, &start, &stop,
1747 PyObject* item = self->extra->children[cur];
1765 ElementObject* self = (ElementObject*) self_;
1773 if (i < 0 && self->extra)
1774 i += self->extra->length;
1784 if (!self->extra) {
1785 if (create_extra(self, NULL) < 0)
1792 slicelen = PySlice_AdjustIndices(self->extra->length, &start, &stop,
1833 if (cur + step >= (size_t)self->extra->length) {
1834 num_moved = self->extra->length - cur - 1;
1837 PyList_SET_ITEM(recycle, i, self->extra->children[cur]);
1840 self->extra->children + cur - i,
1841 self->extra->children + cur + 1,
1847 if (cur < (size_t)self->extra->length) {
1849 self->extra->children + cur - slicelen,
1850 self->extra->children + cur,
1851 (self->extra->length - cur) * sizeof(PyObject *));
1854 self->extra->length -= slicelen;
1885 if (element_resize(self, newlen - slicelen) < 0) {
1911 PyList_SET_ITEM(recycle, i, self->extra->children[cur]);
1916 for (i = stop; i < self->extra->length; i++)
1917 self->extra->children[i + newlen - slicelen] = self->extra->children[i];
1920 for (i = self->extra->length-1; i >= stop; i--)
1921 self->extra->children[i + newlen - slicelen] = self->extra->children[i];
1929 self->extra->children[cur] = element;
1932 self->extra->length += newlen - slicelen;
1949 element_tag_getter(ElementObject *self, void *closure)
1951 PyObject *res = self->tag;
1957 element_text_getter(ElementObject *self, void *closure)
1959 PyObject *res = element_get_text(self);
1965 element_tail_getter(ElementObject *self, void *closure)
1967 PyObject *res = element_get_tail(self);
1973 element_attrib_getter(ElementObject *self, void *closure)
1976 if (!self->extra) {
1977 if (create_extra(self, NULL) < 0)
1980 res = element_get_attrib(self);
1995 element_tag_setter(ElementObject *self, PyObject *value, void *closure)
1999 Py_SETREF(self->tag, value);
2004 element_text_setter(ElementObject *self, PyObject *value, void *closure)
2008 _set_joined_ptr(&self->text, value);
2013 element_tail_setter(ElementObject *self, PyObject *value, void *closure)
2017 _set_joined_ptr(&self->tail, value);
2022 element_attrib_setter(ElementObject *self, PyObject *value, void *closure)
2031 if (!self->extra) {
2032 if (create_extra(self, NULL) < 0)
2036 Py_XSETREF(self->extra->attrib, value);
2282 create_elementiter(ElementObject *self, PyObject *tag, int gettext)
2293 Py_INCREF(self);
2294 it->root_element = self;
2397 _elementtree_TreeBuilder___init___impl(TreeBuilderObject *self,
2406 Py_XSETREF(self->element_factory, element_factory);
2408 Py_CLEAR(self->element_factory);
2417 Py_XSETREF(self->comment_factory, comment_factory);
2418 self->insert_comments = insert_comments;
2420 Py_CLEAR(self->comment_factory);
2421 self->insert_comments = 0;
2430 Py_XSETREF(self->pi_factory, pi_factory);
2431 self->insert_pis = insert_pis;
2433 Py_CLEAR(self->pi_factory);
2434 self->insert_pis = 0;
2441 treebuilder_gc_traverse(TreeBuilderObject *self, visitproc visit, void *arg)
2443 Py_VISIT(self->pi_event_obj);
2444 Py_VISIT(self->comment_event_obj);
2445 Py_VISIT(self->end_ns_event_obj);
2446 Py_VISIT(self->start_ns_event_obj);
2447 Py_VISIT(self->end_event_obj);
2448 Py_VISIT(self->start_event_obj);
2449 Py_VISIT(self->events_append);
2450 Py_VISIT(self->root);
2451 Py_VISIT(self->this);
2452 Py_VISIT(self->last);
2453 Py_VISIT(self->last_for_tail);
2454 Py_VISIT(self->data);
2455 Py_VISIT(self->stack);
2456 Py_VISIT(self->pi_factory);
2457 Py_VISIT(self->comment_factory);
2458 Py_VISIT(self->element_factory);
2463 treebuilder_gc_clear(TreeBuilderObject *self)
2465 Py_CLEAR(self->pi_event_obj);
2466 Py_CLEAR(self->comment_event_obj);
2467 Py_CLEAR(self->end_ns_event_obj);
2468 Py_CLEAR(self->start_ns_event_obj);
2469 Py_CLEAR(self->end_event_obj);
2470 Py_CLEAR(self->start_event_obj);
2471 Py_CLEAR(self->events_append);
2472 Py_CLEAR(self->stack);
2473 Py_CLEAR(self->data);
2474 Py_CLEAR(self->last);
2475 Py_CLEAR(self->last_for_tail);
2476 Py_CLEAR(self->this);
2477 Py_CLEAR(self->pi_factory);
2478 Py_CLEAR(self->comment_factory);
2479 Py_CLEAR(self->element_factory);
2480 Py_CLEAR(self->root);
2485 treebuilder_dealloc(TreeBuilderObject *self)
2487 PyObject_GC_UnTrack(self);
2488 treebuilder_gc_clear(self);
2489 Py_TYPE(self)->tp_free((PyObject *)self);
2601 treebuilder_flush_data(TreeBuilderObject* self)
2603 if (!self->data) {
2607 if (!self->last_for_tail) {
2608 PyObject *element = self->last;
2611 element, &self->data,
2615 PyObject *element = self->last_for_tail;
2618 element, &self->data,
2642 treebuilder_append_event(TreeBuilderObject *self, PyObject *action,
2650 res = PyObject_CallOneArg(self->events_append, event);
2663 treebuilder_handle_start(TreeBuilderObject* self, PyObject* tag,
2670 if (treebuilder_flush_data(self) < 0) {
2674 if (!self->element_factory) {
2680 node = PyObject_CallFunctionObjArgs(self->element_factory,
2685 node = PyObject_CallFunctionObjArgs(self->element_factory,
2692 this = self->this;
2693 Py_CLEAR(self->last_for_tail);
2699 if (self->root) {
2707 self->root = node;
2710 if (self->index < PyList_GET_SIZE(self->stack)) {
2711 if (PyList_SetItem(self->stack, self->index, this) < 0)
2715 if (PyList_Append(self->stack, this) < 0)
2718 self->index++;
2721 Py_SETREF(self->this, node);
2723 Py_SETREF(self->last, node);
2725 if (treebuilder_append_event(self, self->start_event_obj, node) < 0)
2736 treebuilder_handle_data(TreeBuilderObject* self, PyObject* data)
2738 if (!self->data) {
2739 if (self->last == Py_None) {
2744 Py_INCREF(data); self->data = data;
2747 if (PyBytes_CheckExact(self->data) && Py_REFCNT(self->data) == 1 &&
2752 Py_ssize_t size = PyBytes_GET_SIZE(self->data);
2753 if (_PyBytes_Resize(&self->data, size + 1) < 0)
2755 PyBytes_AS_STRING(self->data)[size] = PyBytes_AS_STRING(data)[0];
2756 } else if (PyList_CheckExact(self->data)) {
2757 if (PyList_Append(self->data, data) < 0)
2763 PyList_SET_ITEM(list, 0, self->data);
2765 self->data = list;
2773 treebuilder_handle_end(TreeBuilderObject* self, PyObject* tag)
2777 if (treebuilder_flush_data(self) < 0) {
2781 if (self->index == 0) {
2789 item = self->last;
2790 self->last = self->this;
2791 Py_INCREF(self->last);
2792 Py_XSETREF(self->last_for_tail, self->last);
2793 self->index--;
2794 self->this = PyList_GET_ITEM(self->stack, self->index);
2795 Py_INCREF(self->this);
2798 if (treebuilder_append_event(self, self->end_event_obj, self->last) < 0)
2801 Py_INCREF(self->last);
2802 return (PyObject*) self->last;
2806 treebuilder_handle_comment(TreeBuilderObject* self, PyObject* text)
2811 if (treebuilder_flush_data(self) < 0) {
2815 if (self->comment_factory) {
2816 comment = PyObject_CallOneArg(self->comment_factory, text);
2820 this = self->this;
2821 if (self->insert_comments && this != Py_None) {
2825 Py_XSETREF(self->last_for_tail, comment);
2832 if (self->events_append && self->comment_event_obj) {
2833 if (treebuilder_append_event(self, self->comment_event_obj, comment) < 0)
2845 treebuilder_handle_pi(TreeBuilderObject* self, PyObject* target, PyObject* text)
2851 if (treebuilder_flush_data(self) < 0) {
2855 if (self->pi_factory) {
2856 pi = _PyObject_FastCall(self->pi_factory, stack, 2);
2861 this = self->this;
2862 if (self->insert_pis && this != Py_None) {
2866 Py_XSETREF(self->last_for_tail, pi);
2875 if (self->events_append && self->pi_event_obj) {
2876 if (treebuilder_append_event(self, self->pi_event_obj, pi) < 0)
2888 treebuilder_handle_start_ns(TreeBuilderObject* self, PyObject* prefix, PyObject* uri)
2892 if (self->events_append && self->start_ns_event_obj) {
2898 if (treebuilder_append_event(self, self->start_ns_event_obj, parcel) < 0) {
2909 treebuilder_handle_end_ns(TreeBuilderObject* self, PyObject* prefix)
2911 if (self->events_append && self->end_ns_event_obj) {
2912 if (treebuilder_append_event(self, self->end_ns_event_obj, prefix) < 0) {
2932 _elementtree_TreeBuilder_data(TreeBuilderObject *self, PyObject *data)
2935 return treebuilder_handle_data(self, data);
2947 _elementtree_TreeBuilder_end(TreeBuilderObject *self, PyObject *tag)
2950 return treebuilder_handle_end(self, tag);
2962 _elementtree_TreeBuilder_comment(TreeBuilderObject *self, PyObject *text)
2965 return treebuilder_handle_comment(self, text);
2978 _elementtree_TreeBuilder_pi_impl(TreeBuilderObject *self, PyObject *target,
2982 return treebuilder_handle_pi(self, target, text);
2986 treebuilder_done(TreeBuilderObject* self)
2992 if (self->root)
2993 res = self->root;
3007 _elementtree_TreeBuilder_close_impl(TreeBuilderObject *self)
3010 return treebuilder_done(self);
3023 _elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag,
3027 return treebuilder_handle_start(self, tag, attrs);
3072 makeuniversal(XMLParserObject* self, const char* string)
3086 value = PyDict_GetItemWithError(self->names, key);
3130 if (PyDict_SetItem(self->names, key, value) < 0) {
3196 expat_default_handler(XMLParserObject* self, const XML_Char* data_in,
3213 value = PyDict_GetItemWithError(self->entity, key);
3216 if (TreeBuilder_CheckExact(self->target))
3218 (TreeBuilderObject*) self->target, value
3220 else if (self->handle_data)
3221 res = PyObject_CallOneArg(self->handle_data, value);
3231 EXPAT(GetErrorLineNumber)(self->parser),
3232 EXPAT(GetErrorColumnNumber)(self->parser),
3241 expat_start_handler(XMLParserObject* self, const XML_Char* tag_in,
3253 tag = makeuniversal(self, tag_in);
3265 PyObject* key = makeuniversal(self, attrib_in[0]);
3288 if (TreeBuilder_CheckExact(self->target)) {
3290 res = treebuilder_handle_start((TreeBuilderObject*) self->target,
3293 else if (self->handle_start) {
3301 res = PyObject_CallFunctionObjArgs(self->handle_start,
3313 expat_data_handler(XMLParserObject* self, const XML_Char* data_in,
3326 if (TreeBuilder_CheckExact(self->target))
3328 res = treebuilder_handle_data((TreeBuilderObject*) self->target, data);
3329 else if (self->handle_data)
3330 res = PyObject_CallOneArg(self->handle_data, data);
3340 expat_end_handler(XMLParserObject* self, const XML_Char* tag_in)
3348 if (TreeBuilder_CheckExact(self->target))
3352 (TreeBuilderObject*) self->target, Py_None
3354 else if (self->handle_end) {
3355 tag = makeuniversal(self, tag_in);
3357 res = PyObject_CallOneArg(self->handle_end, tag);
3366 expat_start_ns_handler(XMLParserObject* self, const XML_Char* prefix_in,
3382 if (TreeBuilder_CheckExact(self->target)) {
3384 TreeBuilderObject *target = (TreeBuilderObject*) self->target;
3400 } else if (self->handle_start_ns) {
3412 res = _PyObject_FastCall(self->handle_start_ns, stack, 2);
3421 expat_end_ns_handler(XMLParserObject* self, const XML_Char* prefix_in)
3432 if (TreeBuilder_CheckExact(self->target)) {
3434 TreeBuilderObject *target = (TreeBuilderObject*) self->target;
3439 } else if (self->handle_end_ns) {
3444 res = PyObject_CallOneArg(self->handle_end_ns, prefix);
3452 expat_comment_handler(XMLParserObject* self, const XML_Char* comment_in)
3460 if (TreeBuilder_CheckExact(self->target)) {
3462 TreeBuilderObject *target = (TreeBuilderObject*) self->target;
3471 } else if (self->handle_comment) {
3476 res = PyObject_CallOneArg(self->handle_comment, comment);
3483 expat_start_doctype_handler(XMLParserObject *self,
3496 doctype_name_obj = makeuniversal(self, doctype_name);
3501 sysid_obj = makeuniversal(self, sysid);
3512 pubid_obj = makeuniversal(self, pubid);
3524 if (self->handle_doctype) {
3525 res = PyObject_CallFunctionObjArgs(self->handle_doctype,
3530 else if (_PyObject_LookupAttrId((PyObject *)self, &PyId_doctype, &res) > 0) {
3544 expat_pi_handler(XMLParserObject* self, const XML_Char* target_in,
3555 if (TreeBuilder_CheckExact(self->target)) {
3557 TreeBuilderObject *target = (TreeBuilderObject*) self->target;
3571 } else if (self->handle_pi) {
3581 res = _PyObject_FastCall(self->handle_pi, stack, 2);
3599 XMLParserObject *self = (XMLParserObject *)type->tp_alloc(type, 0);
3600 if (self) {
3601 self->parser = NULL;
3602 self->target = self->entity = self->names = NULL;
3603 self->handle_start_ns = self->handle_end_ns = NULL;
3604 self->handle_start = self->handle_data = self->handle_end = NULL;
3605 self->handle_comment = self->handle_pi = self->handle_close = NULL;
3606 self->handle_doctype = NULL;
3608 return (PyObject *)self;
3633 _elementtree_XMLParser___init___impl(XMLParserObject *self, PyObject *target,
3637 self->entity = PyDict_New();
3638 if (!self->entity)
3641 self->names = PyDict_New();
3642 if (!self->names) {
3643 Py_CLEAR(self->entity);
3647 self->parser = EXPAT(ParserCreate_MM)(encoding, &ExpatMemoryHandler, "}");
3648 if (!self->parser) {
3649 Py_CLEAR(self->entity);
3650 Py_CLEAR(self->names);
3656 EXPAT(SetHashSalt)(self->parser,
3665 Py_CLEAR(self->entity);
3666 Py_CLEAR(self->names);
3670 self->target = target;
3672 self->handle_start_ns = PyObject_GetAttrString(target, "start_ns");
3673 if (ignore_attribute_error(self->handle_start_ns)) {
3676 self->handle_end_ns = PyObject_GetAttrString(target, "end_ns");
3677 if (ignore_attribute_error(self->handle_end_ns)) {
3680 self->handle_start = PyObject_GetAttrString(target, "start");
3681 if (ignore_attribute_error(self->handle_start)) {
3684 self->handle_data = PyObject_GetAttrString(target, "data");
3685 if (ignore_attribute_error(self->handle_data)) {
3688 self->handle_end = PyObject_GetAttrString(target, "end");
3689 if (ignore_attribute_error(self->handle_end)) {
3692 self->handle_comment = PyObject_GetAttrString(target, "comment");
3693 if (ignore_attribute_error(self->handle_comment)) {
3696 self->handle_pi = PyObject_GetAttrString(target, "pi");
3697 if (ignore_attribute_error(self->handle_pi)) {
3700 self->handle_close = PyObject_GetAttrString(target, "close");
3701 if (ignore_attribute_error(self->handle_close)) {
3704 self->handle_doctype = PyObject_GetAttrString(target, "doctype");
3705 if (ignore_attribute_error(self->handle_doctype)) {
3710 EXPAT(SetUserData)(self->parser, self);
3711 if (self->handle_start_ns || self->handle_end_ns)
3713 self->parser,
3718 self->parser,
3723 self->parser,
3727 self->parser,
3730 if (self->handle_comment)
3732 self->parser,
3735 if (self->handle_pi)
3737 self->parser,
3741 self->parser,
3745 self->parser,
3753 xmlparser_gc_traverse(XMLParserObject *self, visitproc visit, void *arg)
3755 Py_VISIT(self->handle_close);
3756 Py_VISIT(self->handle_pi);
3757 Py_VISIT(self->handle_comment);
3758 Py_VISIT(self->handle_end);
3759 Py_VISIT(self->handle_data);
3760 Py_VISIT(self->handle_start);
3761 Py_VISIT(self->handle_start_ns);
3762 Py_VISIT(self->handle_end_ns);
3763 Py_VISIT(self->handle_doctype);
3765 Py_VISIT(self->target);
3766 Py_VISIT(self->entity);
3767 Py_VISIT(self->names);
3773 xmlparser_gc_clear(XMLParserObject *self)
3775 if (self->parser != NULL) {
3776 XML_Parser parser = self->parser;
3777 self->parser = NULL;
3781 Py_CLEAR(self->handle_close);
3782 Py_CLEAR(self->handle_pi);
3783 Py_CLEAR(self->handle_comment);
3784 Py_CLEAR(self->handle_end);
3785 Py_CLEAR(self->handle_data);
3786 Py_CLEAR(self->handle_start);
3787 Py_CLEAR(self->handle_start_ns);
3788 Py_CLEAR(self->handle_end_ns);
3789 Py_CLEAR(self->handle_doctype);
3791 Py_CLEAR(self->target);
3792 Py_CLEAR(self->entity);
3793 Py_CLEAR(self->names);
3799 xmlparser_dealloc(XMLParserObject* self)
3801 PyObject_GC_UnTrack(self);
3802 xmlparser_gc_clear(self);
3803 Py_TYPE(self)->tp_free((PyObject *)self);
3807 _check_xmlparser(XMLParserObject* self)
3809 if (self->target == NULL) {
3818 expat_parse(XMLParserObject* self, const char* data, int data_len, int final)
3823 ok = EXPAT(Parse)(self->parser, data, data_len, final);
3830 EXPAT(GetErrorCode)(self->parser),
3831 EXPAT(GetErrorLineNumber)(self->parser),
3832 EXPAT(GetErrorColumnNumber)(self->parser),
3847 _elementtree_XMLParser_close_impl(XMLParserObject *self)
3854 if (!_check_xmlparser(self)) {
3857 res = expat_parse(self, "", 0, 1);
3861 if (TreeBuilder_CheckExact(self->target)) {
3863 return treebuilder_done((TreeBuilderObject*) self->target);
3865 else if (self->handle_close) {
3867 return PyObject_CallNoArgs(self->handle_close);
3883 _elementtree_XMLParser_feed(XMLParserObject *self, PyObject *data)
3888 if (!_check_xmlparser(self)) {
3901 (void)EXPAT(SetEncoding)(self->parser, "utf-8");
3902 return expat_parse(self, data_ptr, (int)data_len, 0);
3914 res = expat_parse(self, view.buf, (int)view.len, 0);
3929 _elementtree_XMLParser__parse_whole(XMLParserObject *self, PyObject *file)
3938 if (!_check_xmlparser(self)) {
3983 self, PyBytes_AS_STRING(buffer), (int)PyBytes_GET_SIZE(buffer), 0
3998 res = expat_parse(self, "", 0, 1);
4000 if (res && TreeBuilder_CheckExact(self->target)) {
4002 return treebuilder_done((TreeBuilderObject*) self->target);
4018 _elementtree_XMLParser__setevents_impl(XMLParserObject *self,
4028 if (!_check_xmlparser(self)) {
4031 if (!TreeBuilder_CheckExact(self->target)) {
4040 target = (TreeBuilderObject*) self->target;
4088 self->parser,
4095 self->parser,
4102 self->parser,
4108 self->parser,
4130 xmlparser_version_getter(XMLParserObject *self, void *closure)