Lines Matching defs:self
136 checking for self-referential data-structures. */
384 init_method_ref(PyObject *self, PyObject *name,
392 ret = _PyObject_LookupAttr(self, name, &func);
399 if (PyMethod_Check(func) && PyMethod_GET_SELF(func) == self) {
403 *method_self = self; /* borrowed */
417 reconstruct_method(PyObject *func, PyObject *self)
419 if (self) {
420 return PyMethod_New(func, self);
429 call_method(PyObject *func, PyObject *self, PyObject *obj)
431 if (self) {
432 return PyObject_CallFunctionObjArgs(func, self, obj, NULL);
451 Pdata_dealloc(Pdata *self)
453 Py_ssize_t i = Py_SIZE(self);
455 Py_DECREF(self->data[i]);
457 PyMem_Free(self->data);
458 PyObject_Free(self);
472 Pdata *self;
474 if (!(self = PyObject_New(Pdata, &Pdata_Type)))
476 Py_SET_SIZE(self, 0);
477 self->mark_set = 0;
478 self->fence = 0;
479 self->allocated = 8;
480 self->data = PyMem_Malloc(self->allocated * sizeof(PyObject *));
481 if (self->data)
482 return (PyObject *)self;
483 Py_DECREF(self);
492 Pdata_clear(Pdata *self, Py_ssize_t clearto)
494 Py_ssize_t i = Py_SIZE(self);
496 assert(clearto >= self->fence);
501 Py_CLEAR(self->data[i]);
503 Py_SET_SIZE(self, clearto);
508 Pdata_grow(Pdata *self)
510 PyObject **data = self->data;
511 size_t allocated = (size_t)self->allocated;
523 self->data = data;
524 self->allocated = (Py_ssize_t)new_allocated;
533 Pdata_stack_underflow(Pdata *self)
537 self->mark_set ?
548 Pdata_pop(Pdata *self)
550 if (Py_SIZE(self) <= self->fence) {
551 Pdata_stack_underflow(self);
554 Py_SET_SIZE(self, Py_SIZE(self) - 1);
555 return self->data[Py_SIZE(self)];
560 Pdata_push(Pdata *self, PyObject *obj)
562 if (Py_SIZE(self) == self->allocated && Pdata_grow(self) < 0) {
565 self->data[Py_SIZE(self)] = obj;
566 Py_SET_SIZE(self, Py_SIZE(self) + 1);
580 Pdata_poptuple(Pdata *self, Py_ssize_t start)
585 if (start < self->fence) {
586 Pdata_stack_underflow(self);
589 len = Py_SIZE(self) - start;
594 PyTuple_SET_ITEM(tuple, j, self->data[i]);
596 Py_SET_SIZE(self, start);
601 Pdata_poplist(Pdata *self, Py_ssize_t start)
606 len = Py_SIZE(self) - start;
611 PyList_SET_ITEM(list, j, self->data[i]);
613 Py_SET_SIZE(self, start);
632 objects to support self-referential objects
635 PyObject *pers_func_self; /* borrowed reference to self if pers_func
659 should not be used if with self-referential
679 PyObject *pers_func_self; /* borrowed reference to self if pers_func
762 PyMemoTable_Copy(PyMemoTable *self)
768 new->mt_used = self->mt_used;
769 new->mt_allocated = self->mt_allocated;
770 new->mt_mask = self->mt_mask;
774 new->mt_table = PyMem_NEW(PyMemoEntry, self->mt_allocated);
780 for (size_t i = 0; i < self->mt_allocated; i++) {
781 Py_XINCREF(self->mt_table[i].me_key);
783 memcpy(new->mt_table, self->mt_table,
784 sizeof(PyMemoEntry) * self->mt_allocated);
790 PyMemoTable_Size(PyMemoTable *self)
792 return self->mt_used;
796 PyMemoTable_Clear(PyMemoTable *self)
798 Py_ssize_t i = self->mt_allocated;
801 Py_XDECREF(self->mt_table[i].me_key);
803 self->mt_used = 0;
804 memset(self->mt_table, 0, self->mt_allocated * sizeof(PyMemoEntry));
809 PyMemoTable_Del(PyMemoTable *self)
811 if (self == NULL)
813 PyMemoTable_Clear(self);
815 PyMem_Free(self->mt_table);
816 PyMem_Free(self);
822 _PyMemoTable_Lookup(PyMemoTable *self, PyObject *key)
826 size_t mask = self->mt_mask;
827 PyMemoEntry *table = self->mt_table;
847 _PyMemoTable_ResizeTable(PyMemoTable *self, size_t min_size)
869 oldtable = self->mt_table;
870 self->mt_table = PyMem_NEW(PyMemoEntry, new_size);
871 if (self->mt_table == NULL) {
872 self->mt_table = oldtable;
876 self->mt_allocated = new_size;
877 self->mt_mask = new_size - 1;
878 memset(self->mt_table, 0, sizeof(PyMemoEntry) * new_size);
881 to_process = self->mt_used;
888 newentry = _PyMemoTable_Lookup(self, oldentry->me_key);
901 PyMemoTable_Get(PyMemoTable *self, PyObject *key)
903 PyMemoEntry *entry = _PyMemoTable_Lookup(self, key);
911 PyMemoTable_Set(PyMemoTable *self, PyObject *key, Py_ssize_t value)
917 entry = _PyMemoTable_Lookup(self, key);
925 self->mt_used++;
937 if (SIZE_MAX / 3 >= self->mt_used && self->mt_used * 3 < self->mt_allocated * 2) {
940 // self->mt_used is always < PY_SSIZE_T_MAX, so this can't overflow.
941 size_t desired_size = (self->mt_used > 50000 ? 2 : 4) * self->mt_used;
942 return _PyMemoTable_ResizeTable(self, desired_size);
952 _Pickler_ClearBuffer(PicklerObject *self)
954 Py_XSETREF(self->output_buffer,
955 PyBytes_FromStringAndSize(NULL, self->max_output_len));
956 if (self->output_buffer == NULL)
958 self->output_len = 0;
959 self->frame_start = -1;
979 _Pickler_CommitFrame(PicklerObject *self)
984 if (!self->framing || self->frame_start == -1)
986 frame_len = self->output_len - self->frame_start - FRAME_HEADER_SIZE;
987 qdata = PyBytes_AS_STRING(self->output_buffer) + self->frame_start;
994 self->output_len -= FRAME_HEADER_SIZE;
996 self->frame_start = -1;
1001 _Pickler_GetString(PicklerObject *self)
1003 PyObject *output_buffer = self->output_buffer;
1005 assert(self->output_buffer != NULL);
1007 if (_Pickler_CommitFrame(self))
1010 self->output_buffer = NULL;
1012 if (_PyBytes_Resize(&output_buffer, self->output_len) < 0)
1018 _Pickler_FlushToFile(PicklerObject *self)
1022 assert(self->write != NULL);
1025 output = _Pickler_GetString(self);
1029 result = _Pickle_FastCall(self->write, output);
1035 _Pickler_OpcodeBoundary(PicklerObject *self)
1039 if (!self->framing || self->frame_start == -1) {
1042 frame_len = self->output_len - self->frame_start - FRAME_HEADER_SIZE;
1044 if(_Pickler_CommitFrame(self)) {
1052 * self->write is NULL when called via dumps.
1054 if (self->write != NULL) {
1055 if (_Pickler_FlushToFile(self) < 0) {
1058 if (_Pickler_ClearBuffer(self) < 0) {
1067 _Pickler_Write(PicklerObject *self, const char *s, Py_ssize_t data_len)
1074 need_new_frame = (self->framing && self->frame_start == -1);
1081 required = self->output_len + n;
1082 if (required > self->max_output_len) {
1084 if (self->output_len >= PY_SSIZE_T_MAX / 2 - n) {
1088 self->max_output_len = (self->output_len + n) / 2 * 3;
1089 if (_PyBytes_Resize(&self->output_buffer, self->max_output_len) < 0)
1092 buffer = PyBytes_AS_STRING(self->output_buffer);
1095 Py_ssize_t frame_start = self->output_len;
1096 self->frame_start = frame_start;
1101 self->output_len += FRAME_HEADER_SIZE;
1106 buffer[self->output_len + i] = s[i];
1110 memcpy(buffer + self->output_len, s, data_len);
1112 self->output_len += data_len;
1119 PicklerObject *self;
1121 self = PyObject_GC_New(PicklerObject, &Pickler_Type);
1122 if (self == NULL)
1125 self->pers_func = NULL;
1126 self->dispatch_table = NULL;
1127 self->buffer_callback = NULL;
1128 self->write = NULL;
1129 self->proto = 0;
1130 self->bin = 0;
1131 self->framing = 0;
1132 self->frame_start = -1;
1133 self->fast = 0;
1134 self->fast_nesting = 0;
1135 self->fix_imports = 0;
1136 self->fast_memo = NULL;
1137 self->max_output_len = WRITE_BUF_SIZE;
1138 self->output_len = 0;
1139 self->reducer_override = NULL;
1141 self->memo = PyMemoTable_New();
1142 self->output_buffer = PyBytes_FromStringAndSize(NULL,
1143 self->max_output_len);
1145 if (self->memo == NULL || self->output_buffer == NULL) {
1146 Py_DECREF(self);
1150 PyObject_GC_Track(self);
1151 return self;
1155 _Pickler_SetProtocol(PicklerObject *self, PyObject *protocol, int fix_imports)
1175 self->proto = (int)proto;
1176 self->bin = proto > 0;
1177 self->fix_imports = fix_imports && proto < 3;
1184 _Pickler_SetOutputStream(PicklerObject *self, PyObject *file)
1187 if (_PyObject_LookupAttr(file, &_Py_ID(write), &self->write) < 0) {
1190 if (self->write == NULL) {
1200 _Pickler_SetBufferCallback(PicklerObject *self, PyObject *buffer_callback)
1205 if (buffer_callback != NULL && self->proto < 5) {
1212 self->buffer_callback = buffer_callback;
1219 _Unpickler_SetStringInput(UnpicklerObject *self, PyObject *input)
1221 if (self->buffer.buf != NULL)
1222 PyBuffer_Release(&self->buffer);
1223 if (PyObject_GetBuffer(input, &self->buffer, PyBUF_CONTIG_RO) < 0)
1225 self->input_buffer = self->buffer.buf;
1226 self->input_len = self->buffer.len;
1227 self->next_read_idx = 0;
1228 self->prefetched_idx = self->input_len;
1229 return self->input_len;
1242 _Unpickler_SkipConsumed(UnpicklerObject *self)
1247 consumed = self->next_read_idx - self->prefetched_idx;
1251 assert(self->peek); /* otherwise we did something wrong */
1253 r = PyObject_CallFunction(self->read, "n", consumed);
1258 self->prefetched_idx = self->next_read_idx;
1274 On success, self->input_len will be 0; this is intentional so that when
1279 _Unpickler_ReadFromFile(UnpicklerObject *self, Py_ssize_t n)
1284 assert(self->read != NULL);
1286 if (_Unpickler_SkipConsumed(self) < 0)
1290 data = PyObject_CallNoArgs(self->readline);
1295 if (self->peek && n < PREFETCH) {
1299 data = _Pickle_FastCall(self->peek, len);
1305 Py_CLEAR(self->peek);
1308 read_size = _Unpickler_SetStringInput(self, data);
1310 self->prefetched_idx = 0;
1318 data = _Pickle_FastCall(self->read, len);
1323 read_size = _Unpickler_SetStringInput(self, data);
1330 _Unpickler_ReadImpl(UnpicklerObject *self, char **s, Py_ssize_t n)
1335 if (self->next_read_idx > PY_SSIZE_T_MAX - n) {
1343 assert(self->next_read_idx + n > self->input_len);
1345 if (!self->read)
1349 num_read = _Unpickler_ReadFromFile(self, n);
1354 *s = self->input_buffer;
1355 self->next_read_idx = n;
1368 _Unpickler_ReadInto(UnpicklerObject *self, char *buf, Py_ssize_t n)
1373 Py_ssize_t in_buffer = self->input_len - self->next_read_idx;
1376 memcpy(buf, self->input_buffer + self->next_read_idx, to_read);
1377 self->next_read_idx += to_read;
1387 if (!self->read) {
1391 if (_Unpickler_SkipConsumed(self) < 0) {
1395 if (!self->readinto) {
1402 PyObject* data = _Pickle_FastCall(self->read, len);
1428 PyObject *read_size_obj = _Pickle_FastCall(self->readinto, buf_obj);
1454 Note that when reading from a file-like object, self->next_read_idx won't
1461 #define _Unpickler_Read(self, s, n) \
1462 (((n) <= (self)->input_len - (self)->next_read_idx) \
1463 ? (*(s) = (self)->input_buffer + (self)->next_read_idx, \
1464 (self)->next_read_idx += (n), \
1466 : _Unpickler_ReadImpl(self, (s), (n)))
1469 _Unpickler_CopyLine(UnpicklerObject *self, char *line, Py_ssize_t len,
1472 char *input_line = PyMem_Realloc(self->input_line, len + 1);
1480 self->input_line = input_line;
1481 *result = self->input_line;
1490 _Unpickler_Readline(UnpicklerObject *self, char **result)
1494 for (i = self->next_read_idx; i < self->input_len; i++) {
1495 if (self->input_buffer[i] == '\n') {
1496 char *line_start = self->input_buffer + self->next_read_idx;
1497 num_read = i - self->next_read_idx + 1;
1498 self->next_read_idx = i + 1;
1499 return _Unpickler_CopyLine(self, line_start, num_read, result);
1502 if (!self->read)
1505 num_read = _Unpickler_ReadFromFile(self, READ_WHOLE_LINE);
1508 if (num_read == 0 || self->input_buffer[num_read - 1] != '\n')
1510 self->next_read_idx = num_read;
1511 return _Unpickler_CopyLine(self, self->input_buffer, num_read, result);
1517 _Unpickler_ResizeMemoList(UnpicklerObject *self, size_t new_size)
1521 assert(new_size > self->memo_size);
1523 PyObject **memo_new = self->memo;
1529 self->memo = memo_new;
1530 for (i = self->memo_size; i < new_size; i++)
1531 self->memo[i] = NULL;
1532 self->memo_size = new_size;
1538 _Unpickler_MemoGet(UnpicklerObject *self, size_t idx)
1540 if (idx >= self->memo_size)
1543 return self->memo[idx];
1549 _Unpickler_MemoPut(UnpicklerObject *self, size_t idx, PyObject *value)
1553 if (idx >= self->memo_size) {
1554 if (_Unpickler_ResizeMemoList(self, idx * 2) < 0)
1556 assert(idx < self->memo_size);
1559 old_item = self->memo[idx];
1560 self->memo[idx] = value;
1565 self->memo_len++;
1584 _Unpickler_MemoCleanup(UnpicklerObject *self)
1587 PyObject **memo = self->memo;
1589 if (self->memo == NULL)
1591 self->memo = NULL;
1592 i = self->memo_size;
1602 UnpicklerObject *self;
1604 self = PyObject_GC_New(UnpicklerObject, &Unpickler_Type);
1605 if (self == NULL)
1608 self->pers_func = NULL;
1609 self->input_buffer = NULL;
1610 self->input_line = NULL;
1611 self->input_len = 0;
1612 self->next_read_idx = 0;
1613 self->prefetched_idx = 0;
1614 self->read = NULL;
1615 self->readinto = NULL;
1616 self->readline = NULL;
1617 self->peek = NULL;
1618 self->buffers = NULL;
1619 self->encoding = NULL;
1620 self->errors = NULL;
1621 self->marks = NULL;
1622 self->num_marks = 0;
1623 self->marks_size = 0;
1624 self->proto = 0;
1625 self->fix_imports = 0;
1626 memset(&self->buffer, 0, sizeof(Py_buffer));
1627 self->memo_size = 32;
1628 self->memo_len = 0;
1629 self->memo = _Unpickler_NewMemo(self->memo_size);
1630 self->stack = (Pdata *)Pdata_New();
1632 if (self->memo == NULL || self->stack == NULL) {
1633 Py_DECREF(self);
1637 PyObject_GC_Track(self);
1638 return self;
1644 _Unpickler_SetInputStream(UnpicklerObject *self, PyObject *file)
1647 if (_PyObject_LookupAttr(file, &_Py_ID(peek), &self->peek) < 0) {
1650 if (_PyObject_LookupAttr(file, &_Py_ID(readinto), &self->readinto) < 0) {
1653 (void)_PyObject_LookupAttr(file, &_Py_ID(read), &self->read);
1654 (void)_PyObject_LookupAttr(file, &_Py_ID(readline), &self->readline);
1655 if (!self->readline || !self->read) {
1660 Py_CLEAR(self->read);
1661 Py_CLEAR(self->readinto);
1662 Py_CLEAR(self->readline);
1663 Py_CLEAR(self->peek);
1672 _Unpickler_SetInputEncoding(UnpicklerObject *self,
1681 self->encoding = _PyMem_Strdup(encoding);
1682 self->errors = _PyMem_Strdup(errors);
1683 if (self->encoding == NULL || self->errors == NULL) {
1693 _Unpickler_SetBuffers(UnpicklerObject *self, PyObject *buffers)
1696 self->buffers = NULL;
1699 self->buffers = PyObject_GetIter(buffers);
1700 if (self->buffers == NULL) {
1709 memo_get(PicklerObject *self, PyObject *key)
1715 value = PyMemoTable_Get(self->memo, key);
1721 if (!self->bin) {
1749 if (_Pickler_Write(self, pdata, len) < 0)
1758 memo_put(PicklerObject *self, PyObject *obj)
1766 if (self->fast)
1769 idx = PyMemoTable_Size(self->memo);
1770 if (PyMemoTable_Set(self->memo, obj, idx) < 0)
1773 if (self->proto >= 4) {
1774 if (_Pickler_Write(self, &memoize_op, 1) < 0)
1778 else if (!self->bin) {
1805 if (_Pickler_Write(self, pdata, len) < 0)
1993 fast_save_enter(PicklerObject *self, PyObject *obj)
1996 if (++self->fast_nesting >= FAST_NESTING_LIMIT) {
1998 if (self->fast_memo == NULL) {
1999 self->fast_memo = PyDict_New();
2000 if (self->fast_memo == NULL) {
2001 self->fast_nesting = -1;
2007 self->fast_nesting = -1;
2010 int r = PyDict_Contains(self->fast_memo, key);
2018 r = PyDict_SetItem(self->fast_memo, key, Py_None);
2022 self->fast_nesting = -1;
2030 fast_save_leave(PicklerObject *self, PyObject *obj)
2032 if (self->fast_nesting-- >= FAST_NESTING_LIMIT) {
2036 if (PyDict_DelItem(self->fast_memo, key) < 0) {
2046 save_none(PicklerObject *self, PyObject *obj)
2049 if (_Pickler_Write(self, &none_op, 1) < 0)
2056 save_bool(PicklerObject *self, PyObject *obj)
2058 if (self->proto >= 2) {
2060 if (_Pickler_Write(self, &bool_op, 1) < 0)
2070 if (_Pickler_Write(self, bool_str, strlen(bool_str)) < 0)
2077 save_long(PicklerObject *self, PyObject *obj)
2101 if (self->bin) {
2124 if (_Pickler_Write(self, pdata, len) < 0)
2131 if (self->proto >= 2) {
2143 if (_Pickler_Write(self, header, 2) < 0)
2204 if (_Pickler_Write(self, header, size) < 0 ||
2205 _Pickler_Write(self, (char *)pdata, (int)nbytes) < 0)
2224 if (_Pickler_Write(self, &long_op, 1) < 0 ||
2225 _Pickler_Write(self, string, size) < 0 ||
2226 _Pickler_Write(self, "L\n", 2) < 0)
2240 save_float(PicklerObject *self, PyObject *obj)
2244 if (self->bin) {
2249 if (_Pickler_Write(self, pdata, 9) < 0)
2257 if (_Pickler_Write(self, &op, 1) < 0)
2266 if (_Pickler_Write(self, buf, strlen(buf)) < 0)
2269 if (_Pickler_Write(self, "\n", 1) < 0)
2289 _Pickler_write_bytes(PicklerObject *self,
2295 int framing = self->framing;
2298 assert(self->output_buffer != NULL);
2300 if (_Pickler_CommitFrame(self)) {
2304 self->framing = 0;
2307 if (_Pickler_Write(self, header, header_size) < 0) {
2311 if (bypass_buffer && self->write != NULL) {
2316 if (_Pickler_FlushToFile(self) < 0) {
2330 result = PyObject_CallOneArg(self->write, payload);
2338 if (_Pickler_ClearBuffer(self) < 0) {
2343 if (_Pickler_Write(self, data, data_size) < 0) {
2349 self->framing = framing;
2355 _save_bytes_data(PicklerObject *self, PyObject *obj, const char *data,
2358 assert(self->proto >= 3);
2379 else if (self->proto >= 4) {
2391 if (_Pickler_write_bytes(self, header, len, data, size, obj) < 0) {
2395 if (memo_put(self, obj) < 0) {
2403 save_bytes(PicklerObject *self, PyObject *obj)
2405 if (self->proto < 3) {
2442 status = save_reduce(self, reduce_value, obj);
2447 return _save_bytes_data(self, obj, PyBytes_AS_STRING(obj),
2453 _save_bytearray_data(PicklerObject *self, PyObject *obj, const char *data,
2456 assert(self->proto >= 5);
2468 if (_Pickler_write_bytes(self, header, len, data, size, obj) < 0) {
2472 if (memo_put(self, obj) < 0) {
2480 save_bytearray(PicklerObject *self, PyObject *obj)
2482 if (self->proto < 5) {
2505 status = save_reduce(self, reduce_value, obj);
2510 return _save_bytearray_data(self, obj, PyByteArray_AS_STRING(obj),
2516 save_picklebuffer(PicklerObject *self, PyObject *obj)
2518 if (self->proto < 5) {
2536 if (self->buffer_callback != NULL) {
2537 PyObject *ret = PyObject_CallOneArg(self->buffer_callback, obj);
2550 return _save_bytes_data(self, obj, (const char*) view->buf,
2554 return _save_bytearray_data(self, obj, (const char*) view->buf,
2561 if (_Pickler_Write(self, &next_buffer_op, 1) < 0) {
2566 if (_Pickler_Write(self, &readonly_buffer_op, 1) < 0) {
2649 write_unicode_binary(PicklerObject *self, PyObject *obj)
2674 if (size <= 0xff && self->proto >= 4) {
2687 else if (self->proto >= 4) {
2700 if (_Pickler_write_bytes(self, header, len, data, size, encoded) < 0) {
2709 save_unicode(PicklerObject *self, PyObject *obj)
2711 if (self->bin) {
2712 if (write_unicode_binary(self, obj) < 0)
2724 if (_Pickler_Write(self, &unicode_op, 1) < 0) {
2730 if (_Pickler_Write(self, PyBytes_AS_STRING(encoded), size) < 0) {
2736 if (_Pickler_Write(self, "\n", 1) < 0)
2739 if (memo_put(self, obj) < 0)
2747 store_tuple_elements(PicklerObject *self, PyObject *t, Py_ssize_t len)
2758 if (save(self, element, 0) < 0)
2772 save_tuple(PicklerObject *self, PyObject *obj)
2788 if (self->proto) {
2797 if (_Pickler_Write(self, pdata, len) < 0)
2807 if (len <= 3 && self->proto >= 2) {
2809 if (store_tuple_elements(self, obj, len) < 0)
2812 if (PyMemoTable_Get(self->memo, obj)) {
2815 if (_Pickler_Write(self, &pop_op, 1) < 0)
2818 if (memo_get(self, obj) < 0)
2824 if (_Pickler_Write(self, len2opcode + len, 1) < 0)
2833 if (_Pickler_Write(self, &mark_op, 1) < 0)
2836 if (store_tuple_elements(self, obj, len) < 0)
2839 if (PyMemoTable_Get(self->memo, obj)) {
2841 if (self->bin) {
2842 if (_Pickler_Write(self, &pop_mark_op, 1) < 0)
2850 if (_Pickler_Write(self, &pop_op, 1) < 0)
2854 if (memo_get(self, obj) < 0)
2860 if (_Pickler_Write(self, &tuple_op, 1) < 0)
2865 if (memo_put(self, obj) < 0)
2878 batch_list(PicklerObject *self, PyObject *iter)
2895 if (self->proto == 0) {
2904 i = save(self, obj, 0);
2908 if (_Pickler_Write(self, &append_op, 1) < 0)
2933 if (save(self, firstitem, 0) < 0)
2935 if (_Pickler_Write(self, &append_op, 1) < 0)
2944 if (_Pickler_Write(self, &mark_op, 1) < 0)
2947 if (save(self, firstitem, 0) < 0)
2954 if (save(self, obj, 0) < 0)
2970 if (_Pickler_Write(self, &appends_op, 1) < 0)
2994 batch_list_exact(PicklerObject *self, PyObject *obj)
3004 assert(self->proto > 0);
3010 int err = save(self, item, 0);
3014 if (_Pickler_Write(self, &append_op, 1) < 0)
3023 if (_Pickler_Write(self, &mark_op, 1) < 0)
3028 int err = save(self, item, 0);
3036 if (_Pickler_Write(self, &appends_op, 1) < 0)
3045 save_list(PicklerObject *self, PyObject *obj)
3051 if (self->fast && !fast_save_enter(self, obj))
3055 if (self->bin) {
3065 if (_Pickler_Write(self, header, len) < 0)
3072 if (memo_put(self, obj) < 0)
3077 if (PyList_CheckExact(obj) && self->proto > 0) {
3080 status = batch_list_exact(self, obj);
3091 status = batch_list(self, iter);
3101 if (self->fast && !fast_save_leave(self, obj))
3119 batch_dict(PicklerObject *self, PyObject *iter)
3131 if (self->proto == 0) {
3145 i = save(self, PyTuple_GET_ITEM(obj, 0), 0);
3147 i = save(self, PyTuple_GET_ITEM(obj, 1), 0);
3151 if (_Pickler_Write(self, &setitem_op, 1) < 0)
3181 if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)
3183 if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)
3185 if (_Pickler_Write(self, &setitem_op, 1) < 0)
3194 if (_Pickler_Write(self, &mark_op, 1) < 0)
3197 if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)
3199 if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)
3211 if (save(self, PyTuple_GET_ITEM(obj, 0), 0) < 0 ||
3212 save(self, PyTuple_GET_ITEM(obj, 1), 0) < 0)
3228 if (_Pickler_Write(self, &setitems_op, 1) < 0)
3250 batch_dict_exact(PicklerObject *self, PyObject *obj)
3261 assert(self->proto > 0);
3270 if (save(self, key, 0) < 0) {
3273 if (save(self, value, 0) < 0) {
3278 if (_Pickler_Write(self, &setitem_op, 1) < 0)
3286 if (_Pickler_Write(self, &mark_op, 1) < 0)
3291 if (save(self, key, 0) < 0) {
3294 if (save(self, value, 0) < 0) {
3302 if (_Pickler_Write(self, &setitems_op, 1) < 0)
3320 save_dict(PicklerObject *self, PyObject *obj)
3328 if (self->fast && !fast_save_enter(self, obj))
3332 if (self->bin) {
3342 if (_Pickler_Write(self, header, len) < 0)
3345 if (memo_put(self, obj) < 0)
3350 if (PyDict_CheckExact(obj) && self->proto > 0) {
3355 status = batch_dict_exact(self, obj);
3369 status = batch_dict(self, iter);
3380 if (self->fast && !fast_save_leave(self, obj))
3387 save_set(PicklerObject *self, PyObject *obj)
3398 if (self->proto < 4) {
3413 status = save_reduce(self, reduce_value, obj);
3418 if (_Pickler_Write(self, &empty_set_op, 1) < 0)
3421 if (memo_put(self, obj) < 0)
3431 if (_Pickler_Write(self, &mark_op, 1) < 0)
3435 int err = save(self, item, 0);
3442 if (_Pickler_Write(self, &additems_op, 1) < 0)
3456 save_frozenset(PicklerObject *self, PyObject *obj)
3463 if (self->fast && !fast_save_enter(self, obj))
3466 if (self->proto < 4) {
3482 status = save_reduce(self, reduce_value, obj);
3487 if (_Pickler_Write(self, &mark_op, 1) < 0)
3505 if (save(self, item, 0) < 0) {
3517 if (PyMemoTable_Get(self->memo, obj)) {
3520 if (_Pickler_Write(self, &pop_mark_op, 1) < 0)
3522 if (memo_get(self, obj) < 0)
3527 if (_Pickler_Write(self, &frozenset_op, 1) < 0)
3529 if (memo_put(self, obj) < 0)
3602 save_global(PicklerObject *self, PyObject *obj, PyObject *name)
3671 if (self->proto >= 2) {
3737 if (_Pickler_Write(self, pdata, n) < 0)
3747 if (self->proto >= 4) {
3750 if (save(self, module_name, 0) < 0)
3752 if (save(self, global_name, 0) < 0)
3755 if (_Pickler_Write(self, &stack_global_op, 1) < 0)
3764 status = save_reduce(self, reduce_value, NULL);
3776 if (_Pickler_Write(self, &global_op, 1) < 0)
3781 if (self->proto < 3 && self->fix_imports) {
3792 if (self->proto == 3) {
3804 module_name, self->proto);
3807 if (_Pickler_Write(self, PyBytes_AS_STRING(encoded),
3813 if(_Pickler_Write(self, "\n", 1) < 0)
3823 global_name, self->proto);
3826 if (_Pickler_Write(self, PyBytes_AS_STRING(encoded),
3832 if (_Pickler_Write(self, "\n", 1) < 0)
3836 if (memo_put(self, obj) < 0)
3855 save_singleton_type(PicklerObject *self, PyObject *obj, PyObject *singleton)
3864 status = save_reduce(self, reduce_value, obj);
3870 save_type(PicklerObject *self, PyObject *obj)
3873 return save_singleton_type(self, obj, Py_None);
3876 return save_singleton_type(self, obj, Py_Ellipsis);
3879 return save_singleton_type(self, obj, Py_NotImplemented);
3881 return save_global(self, obj, NULL);
3885 save_pers(PicklerObject *self, PyObject *obj)
3893 pid = call_method(self->pers_func, self->pers_func_self, obj);
3898 if (self->bin) {
3899 if (save(self, pid, 1) < 0 ||
3900 _Pickler_Write(self, &binpersid_op, 1) < 0)
3920 if (_Pickler_Write(self, &persid_op, 1) < 0 ||
3921 _Pickler_Write(self, PyUnicode_DATA(pid_str),
3923 _Pickler_Write(self, "\n", 1) < 0) {
3957 save_reduce(PicklerObject *self, PyObject *args, PyObject *obj)
4027 if (self->proto >= 2) {
4076 if (self->proto >= 4) {
4077 if (save(self, cls, 0) < 0 ||
4078 save(self, args, 0) < 0 ||
4079 save(self, kwargs, 0) < 0 ||
4080 _Pickler_Write(self, &newobj_ex_op, 1) < 0) {
4118 if (save(self, callable, 0) < 0 ||
4119 save(self, newargs, 0) < 0 ||
4120 _Pickler_Write(self, &reduce_op, 1) < 0) {
4189 if (save(self, cls, 0) < 0)
4196 p = save(self, newargtup, 0);
4202 if (_Pickler_Write(self, &newobj_op, 1) < 0)
4206 if (save(self, callable, 0) < 0 ||
4207 save(self, argtup, 0) < 0 ||
4208 _Pickler_Write(self, &reduce_op, 1) < 0)
4220 if (PyMemoTable_Get(self->memo, obj)) {
4223 if (_Pickler_Write(self, &pop_op, 1) < 0)
4225 if (memo_get(self, obj) < 0)
4230 else if (memo_put(self, obj) < 0)
4234 if (listitems && batch_list(self, listitems) < 0)
4237 if (dictitems && batch_dict(self, dictitems) < 0)
4242 if (save(self, state, 0) < 0 ||
4243 _Pickler_Write(self, &build_op, 1) < 0)
4259 if (save(self, state_setter, 0) < 0 ||
4260 save(self, obj, 0) < 0 || save(self, state, 0) < 0 ||
4261 _Pickler_Write(self, &tupletwo_op, 1) < 0 ||
4262 _Pickler_Write(self, &reduce_op, 1) < 0 ||
4263 _Pickler_Write(self, &pop_op, 1) < 0)
4271 save(PicklerObject *self, PyObject *obj, int pers_save)
4278 if (_Pickler_OpcodeBoundary(self) < 0)
4283 if (!pers_save && self->pers_func) {
4289 if ((status = save_pers(self, obj)) != 0)
4303 return save_none(self, obj);
4306 return save_bool(self, obj);
4309 return save_long(self, obj);
4312 return save_float(self, obj);
4318 if (PyMemoTable_Get(self->memo, obj)) {
4319 return memo_get(self, obj);
4323 return save_bytes(self, obj);
4326 return save_unicode(self, obj);
4336 status = save_dict(self, obj);
4340 status = save_set(self, obj);
4344 status = save_frozenset(self, obj);
4348 status = save_list(self, obj);
4352 status = save_tuple(self, obj);
4356 status = save_bytearray(self, obj);
4360 status = save_picklebuffer(self, obj);
4368 if (self->reducer_override != NULL) {
4369 reduce_value = PyObject_CallOneArg(self->reducer_override, obj);
4381 status = save_type(self, obj);
4385 status = save_global(self, obj, NULL);
4392 * self.dispatch_table, copyreg.dispatch_table, the object's
4395 if (self->dispatch_table == NULL) {
4410 reduce_func = PyObject_GetItem(self->dispatch_table,
4424 status = save_global(self, obj, NULL);
4442 proto = PyLong_FromLong(self->proto);
4470 status = save_global(self, obj, reduce_value);
4481 status = save_reduce(self, reduce_value, obj);
4497 dump(PicklerObject *self, PyObject *obj)
4503 if (_PyObject_LookupAttr((PyObject *)self, &_Py_ID(reducer_override),
4509 Py_XSETREF(self->reducer_override, tmp);
4512 Py_CLEAR(self->reducer_override);
4515 if (self->proto >= 2) {
4519 assert(self->proto >= 0 && self->proto < 256);
4520 header[1] = (unsigned char)self->proto;
4521 if (_Pickler_Write(self, header, 2) < 0)
4523 if (self->proto >= 4)
4524 self->framing = 1;
4527 if (save(self, obj, 0) < 0 ||
4528 _Pickler_Write(self, &stop_op, 1) < 0 ||
4529 _Pickler_CommitFrame(self) < 0)
4536 self->framing = 0;
4544 Py_CLEAR(self->reducer_override);
4561 _pickle_Pickler_clear_memo_impl(PicklerObject *self)
4564 if (self->memo)
4565 PyMemoTable_Clear(self->memo);
4581 _pickle_Pickler_dump(PicklerObject *self, PyObject *obj)
4587 if (self->write == NULL) {
4591 Py_TYPE(self)->tp_name);
4595 if (_Pickler_ClearBuffer(self) < 0)
4598 if (dump(self, obj) < 0)
4601 if (_Pickler_FlushToFile(self) < 0)
4615 _pickle_Pickler___sizeof___impl(PicklerObject *self)
4620 res = _PyObject_SIZE(Py_TYPE(self));
4621 if (self->memo != NULL) {
4623 res += self->memo->mt_allocated * sizeof(PyMemoEntry);
4625 if (self->output_buffer != NULL) {
4626 s = _PySys_GetSizeOf(self->output_buffer);
4642 Pickler_dealloc(PicklerObject *self)
4644 PyObject_GC_UnTrack(self);
4646 Py_XDECREF(self->output_buffer);
4647 Py_XDECREF(self->write);
4648 Py_XDECREF(self->pers_func);
4649 Py_XDECREF(self->dispatch_table);
4650 Py_XDECREF(self->fast_memo);
4651 Py_XDECREF(self->reducer_override);
4652 Py_XDECREF(self->buffer_callback);
4654 PyMemoTable_Del(self->memo);
4656 Py_TYPE(self)->tp_free((PyObject *)self);
4660 Pickler_traverse(PicklerObject *self, visitproc visit, void *arg)
4662 Py_VISIT(self->write);
4663 Py_VISIT(self->pers_func);
4664 Py_VISIT(self->dispatch_table);
4665 Py_VISIT(self->fast_memo);
4666 Py_VISIT(self->reducer_override);
4667 Py_VISIT(self->buffer_callback);
4672 Pickler_clear(PicklerObject *self)
4674 Py_CLEAR(self->output_buffer);
4675 Py_CLEAR(self->write);
4676 Py_CLEAR(self->pers_func);
4677 Py_CLEAR(self->dispatch_table);
4678 Py_CLEAR(self->fast_memo);
4679 Py_CLEAR(self->reducer_override);
4680 Py_CLEAR(self->buffer_callback);
4682 if (self->memo != NULL) {
4683 PyMemoTable *memo = self->memo;
4684 self->memo = NULL;
4734 _pickle_Pickler___init___impl(PicklerObject *self, PyObject *file,
4740 if (self->write != NULL)
4741 (void)Pickler_clear(self);
4743 if (_Pickler_SetProtocol(self, protocol, fix_imports) < 0)
4746 if (_Pickler_SetOutputStream(self, file) < 0)
4749 if (_Pickler_SetBufferCallback(self, buffer_callback) < 0)
4753 if (self->memo == NULL) {
4754 self->memo = PyMemoTable_New();
4755 if (self->memo == NULL)
4758 self->output_len = 0;
4759 if (self->output_buffer == NULL) {
4760 self->max_output_len = WRITE_BUF_SIZE;
4761 self->output_buffer = PyBytes_FromStringAndSize(NULL,
4762 self->max_output_len);
4763 if (self->output_buffer == NULL)
4767 self->fast = 0;
4768 self->fast_nesting = 0;
4769 self->fast_memo = NULL;
4771 if (init_method_ref((PyObject *)self, &_Py_ID(persistent_id),
4772 &self->pers_func, &self->pers_func_self) < 0)
4776 if (self->dispatch_table != NULL) {
4779 if (_PyObject_LookupAttr((PyObject *)self, &_Py_ID(dispatch_table),
4780 &self->dispatch_table) < 0) {
4805 _pickle_PicklerMemoProxy_clear_impl(PicklerMemoProxyObject *self)
4808 if (self->pickler->memo)
4809 PyMemoTable_Clear(self->pickler->memo);
4820 _pickle_PicklerMemoProxy_copy_impl(PicklerMemoProxyObject *self)
4828 memo = self->pickler->memo;
4864 _pickle_PicklerMemoProxy___reduce___impl(PicklerMemoProxyObject *self)
4868 PyObject *contents = _pickle_PicklerMemoProxy_copy_impl(self);
4898 PicklerMemoProxy_dealloc(PicklerMemoProxyObject *self)
4900 PyObject_GC_UnTrack(self);
4901 Py_XDECREF(self->pickler);
4902 PyObject_GC_Del((PyObject *)self);
4906 PicklerMemoProxy_traverse(PicklerMemoProxyObject *self,
4909 Py_VISIT(self->pickler);
4914 PicklerMemoProxy_clear(PicklerMemoProxyObject *self)
4916 Py_CLEAR(self->pickler);
4954 PicklerMemoProxyObject *self;
4956 self = PyObject_GC_New(PicklerMemoProxyObject, &PicklerMemoProxyType);
4957 if (self == NULL)
4960 self->pickler = pickler;
4961 PyObject_GC_Track(self);
4962 return (PyObject *)self;
4968 Pickler_get_memo(PicklerObject *self, void *Py_UNUSED(ignored))
4970 return PicklerMemoProxy_New(self);
4974 Pickler_set_memo(PicklerObject *self, PyObject *obj, void *Py_UNUSED(ignored))
5024 PyMemoTable_Del(self->memo);
5025 self->memo = new_memo;
5036 Pickler_get_persid(PicklerObject *self, void *Py_UNUSED(ignored))
5038 if (self->pers_func == NULL) {
5042 return reconstruct_method(self->pers_func, self->pers_func_self);
5046 Pickler_set_persid(PicklerObject *self, PyObject *value, void *Py_UNUSED(ignored))
5059 self->pers_func_self = NULL;
5061 Py_XSETREF(self->pers_func, value);
5124 /* Temporary helper for calling self.find_class().
5129 simpler optimization would be to call the C function when self is not a
5132 find_class(UnpicklerObject *self, PyObject *module_name, PyObject *global_name)
5134 return PyObject_CallMethodObjArgs((PyObject *)self, &_Py_ID(find_class),
5139 marker(UnpicklerObject *self)
5143 if (self->num_marks < 1) {
5149 mark = self->marks[--self->num_marks];
5150 self->stack->mark_set = self->num_marks != 0;
5151 self->stack->fence = self->num_marks ?
5152 self->marks[self->num_marks - 1] : 0;
5157 load_none(UnpicklerObject *self)
5159 PDATA_APPEND(self->stack, Py_None, -1);
5164 load_int(UnpicklerObject *self)
5171 if ((len = _Unpickler_Readline(self, &s)) < 0)
5204 PDATA_PUSH(self->stack, value, -1);
5209 load_bool(UnpicklerObject *self, PyObject *boolean)
5212 PDATA_APPEND(self->stack, boolean, -1);
5274 load_binintx(UnpicklerObject *self, char *s, int size)
5284 PDATA_PUSH(self->stack, value, -1);
5289 load_binint(UnpicklerObject *self)
5293 if (_Unpickler_Read(self, &s, 4) < 0)
5296 return load_binintx(self, s, 4);
5300 load_binint1(UnpicklerObject *self)
5304 if (_Unpickler_Read(self, &s, 1) < 0)
5307 return load_binintx(self, s, 1);
5311 load_binint2(UnpicklerObject *self)
5315 if (_Unpickler_Read(self, &s, 2) < 0)
5318 return load_binintx(self, s, 2);
5322 load_long(UnpicklerObject *self)
5328 if ((len = _Unpickler_Readline(self, &s)) < 0)
5344 PDATA_PUSH(self->stack, value, -1);
5352 load_counted_long(UnpicklerObject *self, int size)
5359 if (_Unpickler_Read(self, &nbytes, size) < 0)
5375 if (_Unpickler_Read(self, &pdata, size) < 0)
5382 PDATA_PUSH(self->stack, value, -1);
5387 load_float(UnpicklerObject *self)
5394 if ((len = _Unpickler_Readline(self, &s)) < 0)
5411 PDATA_PUSH(self->stack, value, -1);
5416 load_binfloat(UnpicklerObject *self)
5422 if (_Unpickler_Read(self, &s, 8) < 0)
5432 PDATA_PUSH(self->stack, value, -1);
5437 load_string(UnpicklerObject *self)
5444 if ((len = _Unpickler_Readline(self, &s)) < 0)
5469 if (strcmp(self->encoding, "bytes") == 0) {
5473 obj = PyUnicode_FromEncodedObject(bytes, self->encoding, self->errors);
5480 PDATA_PUSH(self->stack, obj, -1);
5485 load_counted_binstring(UnpicklerObject *self, int nbytes)
5491 if (_Unpickler_Read(self, &s, nbytes) < 0)
5503 if (_Unpickler_Read(self, &s, size) < 0)
5508 if (strcmp(self->encoding, "bytes") == 0) {
5512 obj = PyUnicode_Decode(s, size, self->encoding, self->errors);
5518 PDATA_PUSH(self->stack, obj, -1);
5523 load_counted_binbytes(UnpicklerObject *self, int nbytes)
5529 if (_Unpickler_Read(self, &s, nbytes) < 0)
5543 if (_Unpickler_ReadInto(self, PyBytes_AS_STRING(bytes), size) < 0) {
5548 PDATA_PUSH(self->stack, bytes, -1);
5553 load_counted_bytearray(UnpicklerObject *self)
5559 if (_Unpickler_Read(self, &s, 8) < 0) {
5575 if (_Unpickler_ReadInto(self, PyByteArray_AS_STRING(bytearray), size) < 0) {
5580 PDATA_PUSH(self->stack, bytearray, -1);
5585 load_next_buffer(UnpicklerObject *self)
5587 if (self->buffers == NULL) {
5594 PyObject *buf = PyIter_Next(self->buffers);
5604 PDATA_PUSH(self->stack, buf, -1);
5609 load_readonly_buffer(UnpicklerObject *self)
5611 Py_ssize_t len = Py_SIZE(self->stack);
5612 if (len <= self->stack->fence) {
5613 return Pdata_stack_underflow(self->stack);
5616 PyObject *obj = self->stack->data[len - 1];
5624 self->stack->data[len - 1] = view;
5635 load_unicode(UnpicklerObject *self)
5641 if ((len = _Unpickler_Readline(self, &s)) < 0)
5650 PDATA_PUSH(self->stack, str, -1);
5655 load_counted_binunicode(UnpicklerObject *self, int nbytes)
5661 if (_Unpickler_Read(self, &s, nbytes) < 0)
5672 if (_Unpickler_Read(self, &s, size) < 0)
5679 PDATA_PUSH(self->stack, str, -1);
5684 load_counted_tuple(UnpicklerObject *self, Py_ssize_t len)
5688 if (Py_SIZE(self->stack) < len)
5689 return Pdata_stack_underflow(self->stack);
5691 tuple = Pdata_poptuple(self->stack, Py_SIZE(self->stack) - len);
5694 PDATA_PUSH(self->stack, tuple, -1);
5699 load_tuple(UnpicklerObject *self)
5703 if ((i = marker(self)) < 0)
5706 return load_counted_tuple(self, Py_SIZE(self->stack) - i);
5710 load_empty_list(UnpicklerObject *self)
5716 PDATA_PUSH(self->stack, list, -1);
5721 load_empty_dict(UnpicklerObject *self)
5727 PDATA_PUSH(self->stack, dict, -1);
5732 load_empty_set(UnpicklerObject *self)
5738 PDATA_PUSH(self->stack, set, -1);
5743 load_list(UnpicklerObject *self)
5748 if ((i = marker(self)) < 0)
5751 list = Pdata_poplist(self->stack, i);
5754 PDATA_PUSH(self->stack, list, -1);
5759 load_dict(UnpicklerObject *self)
5764 if ((i = marker(self)) < 0)
5766 j = Py_SIZE(self->stack);
5779 key = self->stack->data[k - 1];
5780 value = self->stack->data[k];
5786 Pdata_clear(self->stack, i);
5787 PDATA_PUSH(self->stack, dict, -1);
5792 load_frozenset(UnpicklerObject *self)
5798 if ((i = marker(self)) < 0)
5801 items = Pdata_poptuple(self->stack, i);
5810 PDATA_PUSH(self->stack, frozenset, -1);
5835 load_obj(UnpicklerObject *self)
5840 if ((i = marker(self)) < 0)
5843 if (Py_SIZE(self->stack) - i < 1)
5844 return Pdata_stack_underflow(self->stack);
5846 args = Pdata_poptuple(self->stack, i + 1);
5850 PDATA_POP(self->stack, cls);
5859 PDATA_PUSH(self->stack, obj, -1);
5864 load_inst(UnpicklerObject *self)
5875 if ((i = marker(self)) < 0)
5877 if ((len = _Unpickler_Readline(self, &s)) < 0)
5889 if ((len = _Unpickler_Readline(self, &s)) >= 0) {
5896 cls = find_class(self, module_name, class_name);
5905 if ((args = Pdata_poptuple(self->stack, i)) != NULL) {
5914 PDATA_PUSH(self->stack, obj, -1);
5928 load_newobj(UnpicklerObject *self, int use_kwargs)
5937 PDATA_POP(self->stack, kwargs);
5942 PDATA_POP(self->stack, args);
5947 PDATA_POP(self->stack, cls);
5982 PDATA_PUSH(self->stack, obj, -1);
5993 load_global(UnpicklerObject *self)
6001 if ((len = _Unpickler_Readline(self, &s)) < 0)
6009 if ((len = _Unpickler_Readline(self, &s)) >= 0) {
6016 global = find_class(self, module_name, global_name);
6024 PDATA_PUSH(self->stack, global, -1);
6029 load_stack_global(UnpicklerObject *self)
6035 PDATA_POP(self->stack, global_name);
6036 PDATA_POP(self->stack, module_name);
6045 global = find_class(self, module_name, global_name);
6050 PDATA_PUSH(self->stack, global, -1);
6055 load_persid(UnpicklerObject *self)
6061 if (self->pers_func) {
6062 if ((len = _Unpickler_Readline(self, &s)) < 0)
6077 obj = call_method(self->pers_func, self->pers_func_self, pid);
6082 PDATA_PUSH(self->stack, obj, -1);
6095 load_binpersid(UnpicklerObject *self)
6099 if (self->pers_func) {
6100 PDATA_POP(self->stack, pid);
6104 obj = call_method(self->pers_func, self->pers_func_self, pid);
6109 PDATA_PUSH(self->stack, obj, -1);
6122 load_pop(UnpicklerObject *self)
6124 Py_ssize_t len = Py_SIZE(self->stack);
6133 if (self->num_marks > 0 && self->marks[self->num_marks - 1] == len) {
6134 self->num_marks--;
6135 self->stack->mark_set = self->num_marks != 0;
6136 self->stack->fence = self->num_marks ?
6137 self->marks[self->num_marks - 1] : 0;
6138 } else if (len <= self->stack->fence)
6139 return Pdata_stack_underflow(self->stack);
6142 Py_DECREF(self->stack->data[len]);
6143 Py_SET_SIZE(self->stack, len);
6149 load_pop_mark(UnpicklerObject *self)
6153 if ((i = marker(self)) < 0)
6156 Pdata_clear(self->stack, i);
6162 load_dup(UnpicklerObject *self)
6165 Py_ssize_t len = Py_SIZE(self->stack);
6167 if (len <= self->stack->fence)
6168 return Pdata_stack_underflow(self->stack);
6169 last = self->stack->data[len - 1];
6170 PDATA_APPEND(self->stack, last, -1);
6175 load_get(UnpicklerObject *self)
6182 if ((len = _Unpickler_Readline(self, &s)) < 0)
6196 value = _Unpickler_MemoGet(self, idx);
6207 PDATA_APPEND(self->stack, value, -1);
6212 load_binget(UnpicklerObject *self)
6218 if (_Unpickler_Read(self, &s, 1) < 0)
6223 value = _Unpickler_MemoGet(self, idx);
6234 PDATA_APPEND(self->stack, value, -1);
6239 load_long_binget(UnpicklerObject *self)
6245 if (_Unpickler_Read(self, &s, 4) < 0)
6250 value = _Unpickler_MemoGet(self, idx);
6261 PDATA_APPEND(self->stack, value, -1);
6269 load_extension(UnpicklerObject *self, int nbytes)
6280 if (_Unpickler_Read(self, &codebytes, nbytes) < 0)
6297 PDATA_APPEND(self->stack, obj, -1);
6333 obj = find_class(self, module_name, class_name);
6345 PDATA_PUSH(self->stack, obj, -1);
6356 load_put(UnpicklerObject *self)
6363 if ((len = _Unpickler_Readline(self, &s)) < 0)
6367 if (Py_SIZE(self->stack) <= self->stack->fence)
6368 return Pdata_stack_underflow(self->stack);
6369 value = self->stack->data[Py_SIZE(self->stack) - 1];
6383 return _Unpickler_MemoPut(self, idx, value);
6387 load_binput(UnpicklerObject *self)
6393 if (_Unpickler_Read(self, &s, 1) < 0)
6396 if (Py_SIZE(self->stack) <= self->stack->fence)
6397 return Pdata_stack_underflow(self->stack);
6398 value = self->stack->data[Py_SIZE(self->stack) - 1];
6402 return _Unpickler_MemoPut(self, idx, value);
6406 load_long_binput(UnpicklerObject *self)
6412 if (_Unpickler_Read(self, &s, 4) < 0)
6415 if (Py_SIZE(self->stack) <= self->stack->fence)
6416 return Pdata_stack_underflow(self->stack);
6417 value = self->stack->data[Py_SIZE(self->stack) - 1];
6426 return _Unpickler_MemoPut(self, idx, value);
6430 load_memoize(UnpicklerObject *self)
6434 if (Py_SIZE(self->stack) <= self->stack->fence)
6435 return Pdata_stack_underflow(self->stack);
6436 value = self->stack->data[Py_SIZE(self->stack) - 1];
6438 return _Unpickler_MemoPut(self, self->memo_len, value);
6442 do_append(UnpicklerObject *self, Py_ssize_t x)
6450 len = Py_SIZE(self->stack);
6451 if (x > len || x <= self->stack->fence)
6452 return Pdata_stack_underflow(self->stack);
6456 list = self->stack->data[x - 1];
6462 slice = Pdata_poplist(self->stack, x);
6477 slice = Pdata_poplist(self->stack, x);
6498 value = self->stack->data[i];
6501 Pdata_clear(self->stack, i + 1);
6502 Py_SET_SIZE(self->stack, x);
6508 Py_SET_SIZE(self->stack, x);
6517 load_append(UnpicklerObject *self)
6519 if (Py_SIZE(self->stack) - 1 <= self->stack->fence)
6520 return Pdata_stack_underflow(self->stack);
6521 return do_append(self, Py_SIZE(self->stack) - 1);
6525 load_appends(UnpicklerObject *self)
6527 Py_ssize_t i = marker(self);
6530 return do_append(self, i);
6534 do_setitems(UnpicklerObject *self, Py_ssize_t x)
6541 len = Py_SIZE(self->stack);
6542 if (x > len || x <= self->stack->fence)
6543 return Pdata_stack_underflow(self->stack);
6556 dict = self->stack->data[x - 1];
6559 key = self->stack->data[i - 1];
6560 value = self->stack->data[i];
6567 Pdata_clear(self->stack, x);
6572 load_setitem(UnpicklerObject *self)
6574 return do_setitems(self, Py_SIZE(self->stack) - 2);
6578 load_setitems(UnpicklerObject *self)
6580 Py_ssize_t i = marker(self);
6583 return do_setitems(self, i);
6587 load_additems(UnpicklerObject *self)
6592 mark = marker(self);
6595 len = Py_SIZE(self->stack);
6596 if (mark > len || mark <= self->stack->fence)
6597 return Pdata_stack_underflow(self->stack);
6601 set = self->stack->data[mark - 1];
6607 items = Pdata_poptuple(self->stack, mark);
6625 item = self->stack->data[i];
6628 Pdata_clear(self->stack, i + 1);
6629 Py_SET_SIZE(self->stack, mark);
6634 Py_SET_SIZE(self->stack, mark);
6641 load_build(UnpicklerObject *self)
6650 if (Py_SIZE(self->stack) - 2 < self->stack->fence)
6651 return Pdata_stack_underflow(self->stack);
6653 PDATA_POP(self->stack, state);
6657 inst = self->stack->data[Py_SIZE(self->stack) - 1];
6750 load_mark(UnpicklerObject *self)
6758 if (self->num_marks >= self->marks_size) {
6759 size_t alloc = ((size_t)self->num_marks << 1) + 20;
6760 Py_ssize_t *marks_new = self->marks;
6766 self->marks = marks_new;
6767 self->marks_size = (Py_ssize_t)alloc;
6770 self->stack->mark_set = 1;
6771 self->marks[self->num_marks++] = self->stack->fence = Py_SIZE(self->stack);
6777 load_reduce(UnpicklerObject *self)
6783 PDATA_POP(self->stack, argtup);
6786 PDATA_POP(self->stack, callable);
6796 PDATA_PUSH(self->stack, obj, -1);
6804 load_proto(UnpicklerObject *self)
6809 if (_Unpickler_Read(self, &s, 1) < 0)
6814 self->proto = i;
6823 load_frame(UnpicklerObject *self)
6828 if (_Unpickler_Read(self, &s, 8) < 0)
6839 if (_Unpickler_Read(self, &s, frame_len) < 0)
6843 self->next_read_idx -= frame_len;
6848 load(UnpicklerObject *self)
6853 self->num_marks = 0;
6854 self->stack->mark_set = 0;
6855 self->stack->fence = 0;
6856 self->proto = 0;
6857 if (Py_SIZE(self->stack))
6858 Pdata_clear(self->stack, 0);
6862 case opcode: if (load_func(self) < 0) break; continue;
6865 case opcode: if (load_func(self, (arg)) < 0) break; continue;
6868 if (_Unpickler_Read(self, &s, 1) < 0) {
6971 if (_Unpickler_SkipConsumed(self) < 0)
6974 PDATA_POP(self->stack, value);
6990 _pickle_Unpickler_load_impl(UnpicklerObject *self)
6993 UnpicklerObject *unpickler = (UnpicklerObject*)self;
6997 not call Unpickler.__init__(). Here, we simply ensure that self->read
7033 _pickle_Unpickler_find_class_impl(UnpicklerObject *self,
7049 if (self->proto < 3 && self->fix_imports) {
7109 global = getattribute(module, global_name, self->proto >= 4);
7122 _pickle_Unpickler___sizeof___impl(UnpicklerObject *self)
7127 res = _PyObject_SIZE(Py_TYPE(self));
7128 if (self->memo != NULL)
7129 res += self->memo_size * sizeof(PyObject *);
7130 if (self->marks != NULL)
7131 res += self->marks_size * sizeof(Py_ssize_t);
7132 if (self->input_line != NULL)
7133 res += strlen(self->input_line) + 1;
7134 if (self->encoding != NULL)
7135 res += strlen(self->encoding) + 1;
7136 if (self->errors != NULL)
7137 res += strlen(self->errors) + 1;
7149 Unpickler_dealloc(UnpicklerObject *self)
7151 PyObject_GC_UnTrack((PyObject *)self);
7152 Py_XDECREF(self->readline);
7153 Py_XDECREF(self->readinto);
7154 Py_XDECREF(self->read);
7155 Py_XDECREF(self->peek);
7156 Py_XDECREF(self->stack);
7157 Py_XDECREF(self->pers_func);
7158 Py_XDECREF(self->buffers);
7159 if (self->buffer.buf != NULL) {
7160 PyBuffer_Release(&self->buffer);
7161 self->buffer.buf = NULL;
7164 _Unpickler_MemoCleanup(self);
7165 PyMem_Free(self->marks);
7166 PyMem_Free(self->input_line);
7167 PyMem_Free(self->encoding);
7168 PyMem_Free(self->errors);
7170 Py_TYPE(self)->tp_free((PyObject *)self);
7174 Unpickler_traverse(UnpicklerObject *self, visitproc visit, void *arg)
7176 Py_VISIT(self->readline);
7177 Py_VISIT(self->readinto);
7178 Py_VISIT(self->read);
7179 Py_VISIT(self->peek);
7180 Py_VISIT(self->stack);
7181 Py_VISIT(self->pers_func);
7182 Py_VISIT(self->buffers);
7187 Unpickler_clear(UnpicklerObject *self)
7189 Py_CLEAR(self->readline);
7190 Py_CLEAR(self->readinto);
7191 Py_CLEAR(self->read);
7192 Py_CLEAR(self->peek);
7193 Py_CLEAR(self->stack);
7194 Py_CLEAR(self->pers_func);
7195 Py_CLEAR(self->buffers);
7196 if (self->buffer.buf != NULL) {
7197 PyBuffer_Release(&self->buffer);
7198 self->buffer.buf = NULL;
7201 _Unpickler_MemoCleanup(self);
7202 PyMem_Free(self->marks);
7203 self->marks = NULL;
7204 PyMem_Free(self->input_line);
7205 self->input_line = NULL;
7206 PyMem_Free(self->encoding);
7207 self->encoding = NULL;
7208 PyMem_Free(self->errors);
7209 self->errors = NULL;
7248 _pickle_Unpickler___init___impl(UnpicklerObject *self, PyObject *file,
7254 if (self->read != NULL)
7255 (void)Unpickler_clear(self);
7257 if (_Unpickler_SetInputStream(self, file) < 0)
7260 if (_Unpickler_SetInputEncoding(self, encoding, errors) < 0)
7263 if (_Unpickler_SetBuffers(self, buffers) < 0)
7266 self->fix_imports = fix_imports;
7268 if (init_method_ref((PyObject *)self, &_Py_ID(persistent_load),
7269 &self->pers_func, &self->pers_func_self) < 0)
7274 self->stack = (Pdata *)Pdata_New();
7275 if (self->stack == NULL)
7278 self->memo_size = 32;
7279 self->memo = _Unpickler_NewMemo(self->memo_size);
7280 if (self->memo == NULL)
7283 self->proto = 0;
7309 _pickle_UnpicklerMemoProxy_clear_impl(UnpicklerMemoProxyObject *self)
7312 _Unpickler_MemoCleanup(self->unpickler);
7313 self->unpickler->memo = _Unpickler_NewMemo(self->unpickler->memo_size);
7314 if (self->unpickler->memo == NULL)
7326 _pickle_UnpicklerMemoProxy_copy_impl(UnpicklerMemoProxyObject *self)
7334 for (i = 0; i < self->unpickler->memo_size; i++) {
7338 value = self->unpickler->memo[i];
7364 _pickle_UnpicklerMemoProxy___reduce___impl(UnpicklerMemoProxyObject *self)
7369 PyObject *contents = _pickle_UnpicklerMemoProxy_copy_impl(self);
7399 UnpicklerMemoProxy_dealloc(UnpicklerMemoProxyObject *self)
7401 PyObject_GC_UnTrack(self);
7402 Py_XDECREF(self->unpickler);
7403 PyObject_GC_Del((PyObject *)self);
7407 UnpicklerMemoProxy_traverse(UnpicklerMemoProxyObject *self,
7410 Py_VISIT(self->unpickler);
7415 UnpicklerMemoProxy_clear(UnpicklerMemoProxyObject *self)
7417 Py_CLEAR(self->unpickler);
7455 UnpicklerMemoProxyObject *self;
7457 self = PyObject_GC_New(UnpicklerMemoProxyObject,
7459 if (self == NULL)
7462 self->unpickler = unpickler;
7463 PyObject_GC_Track(self);
7464 return (PyObject *)self;
7471 Unpickler_get_memo(UnpicklerObject *self, void *Py_UNUSED(ignored))
7473 return UnpicklerMemoProxy_New(self);
7477 Unpickler_set_memo(UnpicklerObject *self, PyObject *obj, void *Py_UNUSED(ignored))
7526 if (_Unpickler_MemoPut(self, idx, value) < 0)
7537 _Unpickler_MemoCleanup(self);
7538 self->memo_size = new_memo_size;
7539 self->memo = new_memo;
7554 Unpickler_get_persload(UnpicklerObject *self, void *Py_UNUSED(ignored))
7556 if (self->pers_func == NULL) {
7560 return reconstruct_method(self->pers_func, self->pers_func_self);
7564 Unpickler_set_persload(UnpicklerObject *self, PyObject *value, void *Py_UNUSED(ignored))
7578 self->pers_func_self = NULL;
7580 Py_XSETREF(self->pers_func, value);