xref: /third_party/python/Modules/_pickle.c

441 /* Internal data type used as the unpickling stack. */
539                     "unpickling stack underflow");
544  * must be an lvalue holding PyObject*.  On stack underflow, UnpicklingError
570 /* Push an object on stack, transferring its ownership to the stack. */
574 /* Push an object on stack, adding a new reference to the object. */
670     Pdata *stack;               /* Pickle data stack, store unpickled objects. */
701     Py_ssize_t *marks;          /* Mark stack, used for unpickling container
703     Py_ssize_t num_marks;       /* Number of marks in the mark stack. */
704     Py_ssize_t marks_size;      /* Current allocated size of the mark stack. */
1630     self->stack = (Pdata *)Pdata_New();
1632     if (self->memo == NULL || self->stack == NULL) {
2745 /* A helper for save_tuple.  Push the len elements in tuple t on the stack. */
2804      * which case we'll pop everything we put on the stack, and fetch
2840         /* pop the stack stuff we pushed */
3516        stack, and fetch the object back from the memo. */
4219            stack, and fetch the object back from the memo. */
4251              * tuple of expected arguments (obj, state) onto the stack. The
4254              * modification, the whole operation has to be stack-transparent.
4255              * Thus, we finally pop the call's output from the stack.*/
5150     self->stack->mark_set = self->num_marks != 0;
5151     self->stack->fence = self->num_marks ?
5159     PDATA_APPEND(self->stack, Py_None, -1);
5204     PDATA_PUSH(self->stack, value, -1);
5212     PDATA_APPEND(self->stack, boolean, -1);
5284     PDATA_PUSH(self->stack, value, -1);
5344     PDATA_PUSH(self->stack, value, -1);
5382     PDATA_PUSH(self->stack, value, -1);
5411     PDATA_PUSH(self->stack, value, -1);
5432     PDATA_PUSH(self->stack, value, -1);
5480     PDATA_PUSH(self->stack, obj, -1);
5518     PDATA_PUSH(self->stack, obj, -1);
5548     PDATA_PUSH(self->stack, bytes, -1);
5580     PDATA_PUSH(self->stack, bytearray, -1);
5604     PDATA_PUSH(self->stack, buf, -1);
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;
5650     PDATA_PUSH(self->stack, str, -1);
5679     PDATA_PUSH(self->stack, str, -1);
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);
5706     return load_counted_tuple(self, Py_SIZE(self->stack) - i);
5716     PDATA_PUSH(self->stack, list, -1);
5727     PDATA_PUSH(self->stack, dict, -1);
5738     PDATA_PUSH(self->stack, set, -1);
5751     list = Pdata_poplist(self->stack, i);
5754     PDATA_PUSH(self->stack, list, -1);
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);
5801     items = Pdata_poptuple(self->stack, i);
5810     PDATA_PUSH(self->stack, frozenset, -1);
5818        Pdata_poptuple which packs objects from the top of the stack
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);
5905     if ((args = Pdata_poptuple(self->stack, i)) != NULL) {
5914     PDATA_PUSH(self->stack, obj, -1);
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);
6024     PDATA_PUSH(self->stack, global, -1);
6035     PDATA_POP(self->stack, global_name);
6036     PDATA_POP(self->stack, module_name);
6050     PDATA_PUSH(self->stack, global, -1);
6082         PDATA_PUSH(self->stack, obj, -1);
6100         PDATA_POP(self->stack, pid);
6109         PDATA_PUSH(self->stack, obj, -1);
6124     Py_ssize_t len = Py_SIZE(self->stack);
6126     /* Note that we split the (pickle.py) stack into two stacks,
6127      * an object stack and a mark stack. We have to be clever and
6129      * mark stack first, and only signalling a stack underflow if
6130      * the object stack is empty and the mark stack doesn't match
6135         self->stack->mark_set = self->num_marks != 0;
6136         self->stack->fence = self->num_marks ?
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);
6156     Pdata_clear(self->stack, i);
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);
6207     PDATA_APPEND(self->stack, value, -1);
6234     PDATA_APPEND(self->stack, value, -1);
6261     PDATA_APPEND(self->stack, value, -1);
6297         PDATA_APPEND(self->stack, obj, -1);
6345     PDATA_PUSH(self->stack, obj, -1);
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];
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];
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];
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];
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);
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);
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);
6574     return do_setitems(self, Py_SIZE(self->stack) - 2);
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);
6648      * the stack top, possibly mutated via instance.__setstate__(state).
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];
6753     /* Note that we split the (pickle.py) stack into two stacks, an
6754      * object stack and a mark stack. Here we push a mark onto the
6755      * mark stack.
6770     self->stack->mark_set = 1;
6771     self->marks[self->num_marks++] = self->stack->fence = Py_SIZE(self->stack);
6783     PDATA_POP(self->stack, argtup);
6786     PDATA_POP(self->stack, callable);
6796     PDATA_PUSH(self->stack, obj, -1);
6854     self->stack->mark_set = 0;
6855     self->stack->fence = 0;
6857     if (Py_SIZE(self->stack))
6858         Pdata_clear(self->stack, 0);
6974     PDATA_POP(self->stack, value);
7156     Py_XDECREF(self->stack);
7180     Py_VISIT(self->stack);
7193     Py_CLEAR(self->stack);
7274     self->stack = (Pdata *)Pdata_New();
7275     if (self->stack == NULL)

Indexes created Thu Nov 07 10:32:03 CST 2024