summaryrefslogtreecommitdiffstats
path: root/Python/structmember.c
blob: 1b8be28dcf2eb21b869c9297b5dda38d27549a5e (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293


/* Map C struct members to Python object attributes */

#include "Python.h"
#include "structmember.h"         // PyMemberDef

PyObject *
PyMember_GetOne(const char *obj_addr, PyMemberDef *l)
{
    PyObject *v;

    const char* addr = obj_addr + l->offset;
    switch (l->type) {
    case T_BOOL:
        v = PyBool_FromLong(*(char*)addr);
        break;
    case T_BYTE:
        v = PyLong_FromLong(*(char*)addr);
        break;
    case T_UBYTE:
        v = PyLong_FromUnsignedLong(*(unsigned char*)addr);
        break;
    case T_SHORT:
        v = PyLong_FromLong(*(short*)addr);
        break;
    case T_USHORT:
        v = PyLong_FromUnsignedLong(*(unsigned short*)addr);
        break;
    case T_INT:
        v = PyLong_FromLong(*(int*)addr);
        break;
    case T_UINT:
        v = PyLong_FromUnsignedLong(*(unsigned int*)addr);
        break;
    case T_LONG:
        v = PyLong_FromLong(*(long*)addr);
        break;
    case T_ULONG:
        v = PyLong_FromUnsignedLong(*(unsigned long*)addr);
        break;
    case T_PYSSIZET:
        v = PyLong_FromSsize_t(*(Py_ssize_t*)addr);
        break;
    case T_FLOAT:
        v = PyFloat_FromDouble((double)*(float*)addr);
        break;
    case T_DOUBLE:
        v = PyFloat_FromDouble(*(double*)addr);
        break;
    case T_STRING:
        if (*(char**)addr == NULL) {
            v = Py_NewRef(Py_None);
        }
        else
            v = PyUnicode_FromString(*(char**)addr);
        break;
    case T_STRING_INPLACE:
        v = PyUnicode_FromString((char*)addr);
        break;
    case T_CHAR:
        v = PyUnicode_FromStringAndSize((char*)addr, 1);
        break;
    case T_OBJECT:
        v = *(PyObject **)addr;
        if (v == NULL)
            v = Py_None;
        Py_INCREF(v);
        break;
    case T_OBJECT_EX:
        v = *(PyObject **)addr;
        if (v == NULL) {
            PyObject *obj = (PyObject *)obj_addr;
            PyTypeObject *tp = Py_TYPE(obj);
            PyErr_Format(PyExc_AttributeError,
                         "'%.200s' object has no attribute '%s'",
                         tp->tp_name, l->name);
        }
        Py_XINCREF(v);
        break;
    case T_LONGLONG:
        v = PyLong_FromLongLong(*(long long *)addr);
        break;
    case T_ULONGLONG:
        v = PyLong_FromUnsignedLongLong(*(unsigned long long *)addr);
        break;
    case T_NONE:
        v = Py_NewRef(Py_None);
        break;
    default:
        PyErr_SetString(PyExc_SystemError, "bad memberdescr type");
        v = NULL;
    }
    return v;
}

#define WARN(msg)                                               \
    do {                                                        \
    if (PyErr_WarnEx(PyExc_RuntimeWarning, msg, 1) < 0)         \
        return -1;                                              \
    } while (0)

int
PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v)
{
    PyObject *oldv;

    addr += l->offset;

    if ((l->flags & READONLY))
    {
        PyErr_SetString(PyExc_AttributeError, "readonly attribute");
        return -1;
    }
    if (v == NULL) {
        if (l->type == T_OBJECT_EX) {
            /* Check if the attribute is set. */
            if (*(PyObject **)addr == NULL) {
                PyErr_SetString(PyExc_AttributeError, l->name);
                return -1;
            }
        }
        else if (l->type != T_OBJECT) {
            PyErr_SetString(PyExc_TypeError,
                            "can't delete numeric/char attribute");
            return -1;
        }
    }
    switch (l->type) {
    case T_BOOL:{
        if (!PyBool_Check(v)) {
            PyErr_SetString(PyExc_TypeError,
                            "attribute value type must be bool");
            return -1;
        }
        if (v == Py_True)
            *(char*)addr = (char) 1;
        else
            *(char*)addr = (char) 0;
        break;
        }
    case T_BYTE:{
        long long_val = PyLong_AsLong(v);
        if ((long_val == -1) && PyErr_Occurred())
            return -1;
        *(char*)addr = (char)long_val;
        /* XXX: For compatibility, only warn about truncations
           for now. */
        if ((long_val > CHAR_MAX) || (long_val < CHAR_MIN))
            WARN("Truncation of value to char");
        break;
        }
    case T_UBYTE:{
        long long_val = PyLong_AsLong(v);
        if ((long_val == -1) && PyErr_Occurred())
            return -1;
        *(unsigned char*)addr = (unsigned char)long_val;
        if ((long_val > UCHAR_MAX) || (long_val < 0))
            WARN("Truncation of value to unsigned char");
        break;
        }
    case T_SHORT:{
        long long_val = PyLong_AsLong(v);
        if ((long_val == -1) && PyErr_Occurred())
            return -1;
        *(short*)addr = (short)long_val;
        if ((long_val > SHRT_MAX) || (long_val < SHRT_MIN))
            WARN("Truncation of value to short");
        break;
        }
    case T_USHORT:{
        long long_val = PyLong_AsLong(v);
        if ((long_val == -1) && PyErr_Occurred())
            return -1;
        *(unsigned short*)addr = (unsigned short)long_val;
        if ((long_val > USHRT_MAX) || (long_val < 0))
            WARN("Truncation of value to unsigned short");
        break;
        }
    case T_INT:{
        long long_val = PyLong_AsLong(v);
        if ((long_val == -1) && PyErr_Occurred())
            return -1;
        *(int *)addr = (int)long_val;
        if ((long_val > INT_MAX) || (long_val < INT_MIN))
            WARN("Truncation of value to int");
        break;
        }
    case T_UINT:{
        unsigned long ulong_val = PyLong_AsUnsignedLong(v);
        if ((ulong_val == (unsigned long)-1) && PyErr_Occurred()) {
            /* XXX: For compatibility, accept negative int values
               as well. */
            PyErr_Clear();
            ulong_val = PyLong_AsLong(v);
            if ((ulong_val == (unsigned long)-1) &&
                PyErr_Occurred())
                return -1;
            *(unsigned int *)addr = (unsigned int)ulong_val;
            WARN("Writing negative value into unsigned field");
        } else
            *(unsigned int *)addr = (unsigned int)ulong_val;
        if (ulong_val > UINT_MAX)
            WARN("Truncation of value to unsigned int");
        break;
        }
    case T_LONG:{
        *(long*)addr = PyLong_AsLong(v);
        if ((*(long*)addr == -1) && PyErr_Occurred())
            return -1;
        break;
        }
    case T_ULONG:{
        *(unsigned long*)addr = PyLong_AsUnsignedLong(v);
        if ((*(unsigned long*)addr == (unsigned long)-1)
            && PyErr_Occurred()) {
            /* XXX: For compatibility, accept negative int values
               as well. */
            PyErr_Clear();
            *(unsigned long*)addr = PyLong_AsLong(v);
            if ((*(unsigned long*)addr == (unsigned long)-1)
                && PyErr_Occurred())
                return -1;
            WARN("Writing negative value into unsigned field");
        }
        break;
        }
    case T_PYSSIZET:{
        *(Py_ssize_t*)addr = PyLong_AsSsize_t(v);
        if ((*(Py_ssize_t*)addr == (Py_ssize_t)-1)
            && PyErr_Occurred())
                        return -1;
        break;
        }
    case T_FLOAT:{
        double double_val = PyFloat_AsDouble(v);
        if ((double_val == -1) && PyErr_Occurred())
            return -1;
        *(float*)addr = (float)double_val;
        break;
        }
    case T_DOUBLE:
        *(double*)addr = PyFloat_AsDouble(v);
        if ((*(double*)addr == -1) && PyErr_Occurred())
            return -1;
        break;
    case T_OBJECT:
    case T_OBJECT_EX:
        oldv = *(PyObject **)addr;
        *(PyObject **)addr = Py_XNewRef(v);
        Py_XDECREF(oldv);
        break;
    case T_CHAR: {
        const char *string;
        Py_ssize_t len;

        string = PyUnicode_AsUTF8AndSize(v, &len);
        if (string == NULL || len != 1) {
            PyErr_BadArgument();
            return -1;
        }
        *(char*)addr = string[0];
        break;
        }
    case T_STRING:
    case T_STRING_INPLACE:
        PyErr_SetString(PyExc_TypeError, "readonly attribute");
        return -1;
    case T_LONGLONG:{
        long long value;
        *(long long*)addr = value = PyLong_AsLongLong(v);
        if ((value == -1) && PyErr_Occurred())
            return -1;
        break;
        }
    case T_ULONGLONG:{
        unsigned long long value;
        /* ??? PyLong_AsLongLong accepts an int, but PyLong_AsUnsignedLongLong
            doesn't ??? */
        if (PyLong_Check(v))
            *(unsigned long long*)addr = value = PyLong_AsUnsignedLongLong(v);
        else
            *(unsigned long long*)addr = value = PyLong_AsLong(v);
        if ((value == (unsigned long long)-1) && PyErr_Occurred())
            return -1;
        break;
        }
    default:
        PyErr_Format(PyExc_SystemError,
                     "bad memberdescr type for %s", l->name);
        return -1;
    }
    return 0;
}
generated by cgit v0.12 at 2025-07-29 18:15:07 (GMT)
quot;pycore_pystate.h" // _PyThreadState_GET() #include "structmember.h" // PyMemberDef #include "clinic/context.c.h" /*[clinic input] module _contextvars [clinic start generated code]*/ /*[clinic end generated code: output=da39a3ee5e6b4b0d input=a0955718c8b8cea6]*/ #define ENSURE_Context(o, err_ret) \ if (!PyContext_CheckExact(o)) { \ PyErr_SetString(PyExc_TypeError, \ "an instance of Context was expected"); \ return err_ret; \ } #define ENSURE_ContextVar(o, err_ret) \ if (!PyContextVar_CheckExact(o)) { \ PyErr_SetString(PyExc_TypeError, \ "an instance of ContextVar was expected"); \ return err_ret; \ } #define ENSURE_ContextToken(o, err_ret) \ if (!PyContextToken_CheckExact(o)) { \ PyErr_SetString(PyExc_TypeError, \ "an instance of Token was expected"); \ return err_ret; \ } /////////////////////////// Context API static PyContext * context_new_empty(void); static PyContext * context_new_from_vars(PyHamtObject *vars); static inline PyContext * context_get(void); static PyContextToken * token_new(PyContext *ctx, PyContextVar *var, PyObject *val); static PyContextVar * contextvar_new(PyObject *name, PyObject *def); static int contextvar_set(PyContextVar *var, PyObject *val); static int contextvar_del(PyContextVar *var); #if PyContext_MAXFREELIST > 0 static struct _Py_context_state * get_context_state(void) { PyInterpreterState *interp = _PyInterpreterState_GET(); return &interp->context; } #endif PyObject * _PyContext_NewHamtForTests(void) { return (PyObject *)_PyHamt_New(); } PyObject * PyContext_New(void) { return (PyObject *)context_new_empty(); } PyObject * PyContext_Copy(PyObject * octx) { ENSURE_Context(octx, NULL) PyContext *ctx = (PyContext *)octx; return (PyObject *)context_new_from_vars(ctx->ctx_vars); } PyObject * PyContext_CopyCurrent(void) { PyContext *ctx = context_get(); if (ctx == NULL) { return NULL; } return (PyObject *)context_new_from_vars(ctx->ctx_vars); } static int _PyContext_Enter(PyThreadState *ts, PyObject *octx) { ENSURE_Context(octx, -1) PyContext *ctx = (PyContext *)octx; if (ctx->ctx_entered) { _PyErr_Format(ts, PyExc_RuntimeError, "cannot enter context: %R is already entered", ctx); return -1; } ctx->ctx_prev = (PyContext *)ts->context; /* borrow */ ctx->ctx_entered = 1; ts->context = Py_NewRef(ctx); ts->context_ver++; return 0; } int PyContext_Enter(PyObject *octx) { PyThreadState *ts = _PyThreadState_GET(); assert(ts != NULL); return _PyContext_Enter(ts, octx); } static int _PyContext_Exit(PyThreadState *ts, PyObject *octx) { ENSURE_Context(octx, -1) PyContext *ctx = (PyContext *)octx; if (!ctx->ctx_entered) { PyErr_Format(PyExc_RuntimeError, "cannot exit context: %R has not been entered", ctx); return -1; } if (ts->context != (PyObject *)ctx) { /* Can only happen if someone misuses the C API */ PyErr_SetString(PyExc_RuntimeError, "cannot exit context: thread state references " "a different context object"); return -1; } Py_SETREF(ts->context, (PyObject *)ctx->ctx_prev); ts->context_ver++; ctx->ctx_prev = NULL; ctx->ctx_entered = 0; return 0; } int PyContext_Exit(PyObject *octx) { PyThreadState *ts = _PyThreadState_GET(); assert(ts != NULL); return _PyContext_Exit(ts, octx); } PyObject * PyContextVar_New(const char *name, PyObject *def) { PyObject *pyname = PyUnicode_FromString(name); if (pyname == NULL) { return NULL; } PyContextVar *var = contextvar_new(pyname, def); Py_DECREF(pyname); return (PyObject *)var; } int PyContextVar_Get(PyObject *ovar, PyObject *def, PyObject **val) { ENSURE_ContextVar(ovar, -1) PyContextVar *var = (PyContextVar *)ovar; PyThreadState *ts = _PyThreadState_GET(); assert(ts != NULL); if (ts->context == NULL) { goto not_found; } if (var->var_cached != NULL && var->var_cached_tsid == ts->id && var->var_cached_tsver == ts->context_ver) { *val = var->var_cached; goto found; } assert(PyContext_CheckExact(ts->context)); PyHamtObject *vars = ((PyContext *)ts->context)->ctx_vars; PyObject *found = NULL; int res = _PyHamt_Find(vars, (PyObject*)var, &found); if (res < 0) { goto error; } if (res == 1) { assert(found != NULL); var->var_cached = found; /* borrow */ var->var_cached_tsid = ts->id; var->var_cached_tsver = ts->context_ver; *val = found; goto found; } not_found: if (def == NULL) { if (var->var_default != NULL) { *val = var->var_default; goto found; } *val = NULL; goto found; } else { *val = def; goto found; } found: Py_XINCREF(*val); return 0; error: *val = NULL; return -1; } PyObject * PyContextVar_Set(PyObject *ovar, PyObject *val) { ENSURE_ContextVar(ovar, NULL) PyContextVar *var = (PyContextVar *)ovar; if (!PyContextVar_CheckExact(var)) { PyErr_SetString( PyExc_TypeError, "an instance of ContextVar was expected"); return NULL; } PyContext *ctx = context_get(); if (ctx == NULL) { return NULL; } PyObject *old_val = NULL; int found = _PyHamt_Find(ctx->ctx_vars, (PyObject *)var, &old_val); if (found < 0) { return NULL; } Py_XINCREF(old_val); PyContextToken *tok = token_new(ctx, var, old_val); Py_XDECREF(old_val); if (contextvar_set(var, val)) { Py_DECREF(tok); return NULL; } return (PyObject *)tok; } int PyContextVar_Reset(PyObject *ovar, PyObject *otok) { ENSURE_ContextVar(ovar, -1) ENSURE_ContextToken(otok, -1) PyContextVar *var = (PyContextVar *)ovar; PyContextToken *tok = (PyContextToken *)otok; if (tok->tok_used) { PyErr_Format(PyExc_RuntimeError, "%R has already been used once", tok); return -1; } if (var != tok->tok_var) { PyErr_Format(PyExc_ValueError, "%R was created by a different ContextVar", tok); return -1; } PyContext *ctx = context_get(); if (ctx != tok->tok_ctx) { PyErr_Format(PyExc_ValueError, "%R was created in a different Context", tok); return -1; } tok->tok_used = 1; if (tok->tok_oldval == NULL) { return contextvar_del(var); } else { return contextvar_set(var, tok->tok_oldval); } } /////////////////////////// PyContext /*[clinic input] class _contextvars.Context "PyContext *" "&PyContext_Type" [clinic start generated code]*/ /*[clinic end generated code: output=da39a3ee5e6b4b0d input=bdf87f8e0cb580e8]*/ static inline PyContext * _context_alloc(void) { PyContext *ctx; #if PyContext_MAXFREELIST > 0 struct _Py_context_state *state = get_context_state(); #ifdef Py_DEBUG // _context_alloc() must not be called after _PyContext_Fini() assert(state->numfree != -1); #endif if (state->numfree) { state->numfree--; ctx = state->freelist; state->freelist = (PyContext *)ctx->ctx_weakreflist; OBJECT_STAT_INC(from_freelist); ctx->ctx_weakreflist = NULL; _Py_NewReference((PyObject *)ctx); } else #endif { ctx = PyObject_GC_New(PyContext, &PyContext_Type); if (ctx == NULL) { return NULL; } } ctx->ctx_vars = NULL; ctx->ctx_prev = NULL; ctx->ctx_entered = 0; ctx->ctx_weakreflist = NULL; return ctx; } static PyContext * context_new_empty(void) { PyContext *ctx = _context_alloc(); if (ctx == NULL) { return NULL; } ctx->ctx_vars = _PyHamt_New(); if (ctx->ctx_vars == NULL) { Py_DECREF(ctx); return NULL; } _PyObject_GC_TRACK(ctx); return ctx; } static PyContext * context_new_from_vars(PyHamtObject *vars) { PyContext *ctx = _context_alloc(); if (ctx == NULL) { return NULL; } ctx->ctx_vars = (PyHamtObject*)Py_NewRef(vars); _PyObject_GC_TRACK(ctx); return ctx; } static inline PyContext * context_get(void) { PyThreadState *ts = _PyThreadState_GET(); assert(ts != NULL); PyContext *current_ctx = (PyContext *)ts->context; if (current_ctx == NULL) { current_ctx = context_new_empty(); if (current_ctx == NULL) { return NULL; } ts->context = (PyObject *)current_ctx; } return current_ctx; } static int context_check_key_type(PyObject *key) { if (!PyContextVar_CheckExact(key)) { // abort(); PyErr_Format(PyExc_TypeError, "a ContextVar key was expected, got %R", key); return -1; } return 0; } static PyObject * context_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { if (PyTuple_Size(args) || (kwds != NULL && PyDict_Size(kwds))) { PyErr_SetString( PyExc_TypeError, "Context() does not accept any arguments"); return NULL; } return PyContext_New(); } static int context_tp_clear(PyContext *self) { Py_CLEAR(self->ctx_prev); Py_CLEAR(self->ctx_vars); return 0; } static int context_tp_traverse(PyContext *self, visitproc visit, void *arg) { Py_VISIT(self->ctx_prev); Py_VISIT(self->ctx_vars); return 0; } static void context_tp_dealloc(PyContext *self) { _PyObject_GC_UNTRACK(self); if (self->ctx_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject*)self); } (void)context_tp_clear(self); #if PyContext_MAXFREELIST > 0 struct _Py_context_state *state = get_context_state(); #ifdef Py_DEBUG // _context_alloc() must not be called after _PyContext_Fini() assert(state->numfree != -1); #endif if (state->numfree < PyContext_MAXFREELIST) { state->numfree++; self->ctx_weakreflist = (PyObject *)state->freelist; state->freelist = self; OBJECT_STAT_INC(to_freelist); } else #endif { Py_TYPE(self)->tp_free(self); } } static PyObject * context_tp_iter(PyContext *self) { return _PyHamt_NewIterKeys(self->ctx_vars); } static PyObject * context_tp_richcompare(PyObject *v, PyObject *w, int op) { if (!PyContext_CheckExact(v) || !PyContext_CheckExact(w) || (op != Py_EQ && op != Py_NE)) { Py_RETURN_NOTIMPLEMENTED; } int res = _PyHamt_Eq( ((PyContext *)v)->ctx_vars, ((PyContext *)w)->ctx_vars); if (res < 0) { return NULL; } if (op == Py_NE) { res = !res; } if (res) { Py_RETURN_TRUE; } else { Py_RETURN_FALSE; } } static Py_ssize_t context_tp_len(PyContext *self) { return _PyHamt_Len(self->ctx_vars); } static PyObject * context_tp_subscript(PyContext *self, PyObject *key) { if (context_check_key_type(key)) { return NULL; } PyObject *val = NULL; int found = _PyHamt_Find(self->ctx_vars, key, &val); if (found < 0) { return NULL; } if (found == 0) { PyErr_SetObject(PyExc_KeyError, key); return NULL; } return Py_NewRef(val); } static int context_tp_contains(PyContext *self, PyObject *key) { if (context_check_key_type(key)) { return -1; } PyObject *val = NULL; return _PyHamt_Find(self->ctx_vars, key, &val); } /*[clinic input] _contextvars.Context.get key: object default: object = None / Return the value for `key` if `key` has the value in the context object. If `key` does not exist, return `default`. If `default` is not given, return None. [clinic start generated code]*/ static PyObject * _contextvars_Context_get_impl(PyContext *self, PyObject *key, PyObject *default_value) /*[clinic end generated code: output=0c54aa7664268189 input=c8eeb81505023995]*/ { if (context_check_key_type(key)) { return NULL; } PyObject *val = NULL; int found = _PyHamt_Find(self->ctx_vars, key, &val); if (found < 0) { return NULL; } if (found == 0) { return Py_NewRef(default_value); } return Py_NewRef(val); } /*[clinic input] _contextvars.Context.items Return all variables and their values in the context object. The result is returned as a list of 2-tuples (variable, value). [clinic start generated code]*/ static PyObject * _contextvars_Context_items_impl(PyContext *self) /*[clinic end generated code: output=fa1655c8a08502af input=00db64ae379f9f42]*/ { return _PyHamt_NewIterItems(self->ctx_vars); } /*[clinic input] _contextvars.Context.keys Return a list of all variables in the context object. [clinic start generated code]*/ static PyObject * _contextvars_Context_keys_impl(PyContext *self) /*[clinic end generated code: output=177227c6b63ec0e2 input=114b53aebca3449c]*/ { return _PyHamt_NewIterKeys(self->ctx_vars); } /*[clinic input] _contextvars.Context.values Return a list of all variables' values in the context object. [clinic start generated code]*/ static PyObject * _contextvars_Context_values_impl(PyContext *self) /*[clinic end generated code: output=d286dabfc8db6dde input=ce8075d04a6ea526]*/ { return _PyHamt_NewIterValues(self->ctx_vars); } /*[clinic input] _contextvars.Context.copy Return a shallow copy of the context object. [clinic start generated code]*/ static PyObject * _contextvars_Context_copy_impl(PyContext *self) /*[clinic end generated code: output=30ba8896c4707a15 input=ebafdbdd9c72d592]*/ { return (PyObject *)context_new_from_vars(self->ctx_vars); } static PyObject * context_run(PyContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { PyThreadState *ts = _PyThreadState_GET(); if (nargs < 1) { _PyErr_SetString(ts, PyExc_TypeError, "run() missing 1 required positional argument"); return NULL; } if (_PyContext_Enter(ts, (PyObject *)self)) { return NULL; } PyObject *call_result = _PyObject_VectorcallTstate( ts, args[0], args + 1, nargs - 1, kwnames); if (_PyContext_Exit(ts, (PyObject *)self)) { return NULL; } return call_result; } static PyMethodDef PyContext_methods[] = { _CONTEXTVARS_CONTEXT_GET_METHODDEF _CONTEXTVARS_CONTEXT_ITEMS_METHODDEF _CONTEXTVARS_CONTEXT_KEYS_METHODDEF _CONTEXTVARS_CONTEXT_VALUES_METHODDEF _CONTEXTVARS_CONTEXT_COPY_METHODDEF {"run", _PyCFunction_CAST(context_run), METH_FASTCALL | METH_KEYWORDS, NULL}, {NULL, NULL} }; static PySequenceMethods PyContext_as_sequence = { 0, /* sq_length */ 0, /* sq_concat */ 0, /* sq_repeat */ 0, /* sq_item */ 0, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ (objobjproc)context_tp_contains, /* sq_contains */ 0, /* sq_inplace_concat */ 0, /* sq_inplace_repeat */ }; static PyMappingMethods PyContext_as_mapping = { (lenfunc)context_tp_len, /* mp_length */ (binaryfunc)context_tp_subscript, /* mp_subscript */ }; PyTypeObject PyContext_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "_contextvars.Context", sizeof(PyContext), .tp_methods = PyContext_methods, .tp_as_mapping = &PyContext_as_mapping, .tp_as_sequence = &PyContext_as_sequence, .tp_iter = (getiterfunc)context_tp_iter, .tp_dealloc = (destructor)context_tp_dealloc, .tp_getattro = PyObject_GenericGetAttr, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_richcompare = context_tp_richcompare, .tp_traverse = (traverseproc)context_tp_traverse, .tp_clear = (inquiry)context_tp_clear, .tp_new = context_tp_new, .tp_weaklistoffset = offsetof(PyContext, ctx_weakreflist), .tp_hash = PyObject_HashNotImplemented, }; /////////////////////////// ContextVar static int contextvar_set(PyContextVar *var, PyObject *val) { var->var_cached = NULL; PyThreadState *ts = _PyThreadState_GET(); PyContext *ctx = context_get(); if (ctx == NULL) { return -1; } PyHamtObject *new_vars = _PyHamt_Assoc( ctx->ctx_vars, (PyObject *)var, val); if (new_vars == NULL) { return -1; } Py_SETREF(ctx->ctx_vars, new_vars); var->var_cached = val; /* borrow */ var->var_cached_tsid = ts->id; var->var_cached_tsver = ts->context_ver; return 0; } static int contextvar_del(PyContextVar *var) { var->var_cached = NULL; PyContext *ctx = context_get(); if (ctx == NULL) { return -1; } PyHamtObject *vars = ctx->ctx_vars; PyHamtObject *new_vars = _PyHamt_Without(vars, (PyObject *)var); if (new_vars == NULL) { return -1; } if (vars == new_vars) { Py_DECREF(new_vars); PyErr_SetObject(PyExc_LookupError, (PyObject *)var); return -1; } Py_SETREF(ctx->ctx_vars, new_vars); return 0; } static Py_hash_t contextvar_generate_hash(void *addr, PyObject *name) { /* Take hash of `name` and XOR it with the object's addr. The structure of the tree is encoded in objects' hashes, which means that sufficiently similar hashes would result in tall trees with many Collision nodes. Which would, in turn, result in slower get and set operations. The XORing helps to ensure that: (1) sequentially allocated ContextVar objects have different hashes; (2) context variables with equal names have different hashes. */ Py_hash_t name_hash = PyObject_Hash(name); if (name_hash == -1) { return -1; } Py_hash_t res = _Py_HashPointer(addr) ^ name_hash; return res == -1 ? -2 : res; } static PyContextVar * contextvar_new(PyObject *name, PyObject *def) { if (!PyUnicode_Check(name)) { PyErr_SetString(PyExc_TypeError, "context variable name must be a str"); return NULL; } PyContextVar *var = PyObject_GC_New(PyContextVar, &PyContextVar_Type); if (var == NULL) { return NULL; } var->var_hash = contextvar_generate_hash(var, name); if (var->var_hash == -1) { Py_DECREF(var); return NULL; } var->var_name = Py_NewRef(name); var->var_default = Py_XNewRef(def); var->var_cached = NULL; var->var_cached_tsid = 0; var->var_cached_tsver = 0; if (_PyObject_GC_MAY_BE_TRACKED(name) || (def != NULL && _PyObject_GC_MAY_BE_TRACKED(def))) { PyObject_GC_Track(var); } return var; } /*[clinic input] class _contextvars.ContextVar "PyContextVar *" "&PyContextVar_Type" [clinic start generated code]*/ /*[clinic end generated code: output=da39a3ee5e6b4b0d input=445da935fa8883c3]*/ static PyObject * contextvar_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { static char *kwlist[] = {"", "default", NULL}; PyObject *name; PyObject *def = NULL; if (!PyArg_ParseTupleAndKeywords( args, kwds, "O|$O:ContextVar", kwlist, &name, &def)) { return NULL; } return (PyObject *)contextvar_new(name, def); } static int contextvar_tp_clear(PyContextVar *self) { Py_CLEAR(self->var_name); Py_CLEAR(self->var_default); self->var_cached = NULL; self->var_cached_tsid = 0; self->var_cached_tsver = 0; return 0; } static int contextvar_tp_traverse(PyContextVar *self, visitproc visit, void *arg) { Py_VISIT(self->var_name); Py_VISIT(self->var_default); return 0; } static void contextvar_tp_dealloc(PyContextVar *self) { PyObject_GC_UnTrack(self); (void)contextvar_tp_clear(self); Py_TYPE(self)->tp_free(self); } static Py_hash_t contextvar_tp_hash(PyContextVar *self) { return self->var_hash; } static PyObject * contextvar_tp_repr(PyContextVar *self) { _PyUnicodeWriter writer; _PyUnicodeWriter_Init(&writer); if (_PyUnicodeWriter_WriteASCIIString( &writer, "<ContextVar name=", 17) < 0) { goto error; } PyObject *name = PyObject_Repr(self->var_name); if (name == NULL) { goto error; } if (_PyUnicodeWriter_WriteStr(&writer, name) < 0) { Py_DECREF(name); goto error; } Py_DECREF(name); if (self->var_default != NULL) { if (_PyUnicodeWriter_WriteASCIIString(&writer, " default=", 9) < 0) { goto error; } PyObject *def = PyObject_Repr(self->var_default); if (def == NULL) { goto error; } if (_PyUnicodeWriter_WriteStr(&writer, def) < 0) { Py_DECREF(def); goto error; } Py_DECREF(def); } PyObject *addr = PyUnicode_FromFormat(" at %p>", self); if (addr == NULL) { goto error; } if (_PyUnicodeWriter_WriteStr(&writer, addr) < 0) { Py_DECREF(addr); goto error; } Py_DECREF(addr); return _PyUnicodeWriter_Finish(&writer); error: _PyUnicodeWriter_Dealloc(&writer); return NULL; } /*[clinic input] _contextvars.ContextVar.get default: object = NULL / Return a value for the context variable for the current context. If there is no value for the variable in the current context, the method will: * return the value of the default argument of the method, if provided; or * return the default value for the context variable, if it was created with one; or * raise a LookupError. [clinic start generated code]*/ static PyObject * _contextvars_ContextVar_get_impl(PyContextVar *self, PyObject *default_value) /*[clinic end generated code: output=0746bd0aa2ced7bf input=30aa2ab9e433e401]*/ { if (!PyContextVar_CheckExact(self)) { PyErr_SetString( PyExc_TypeError, "an instance of ContextVar was expected"); return NULL; } PyObject *val; if (PyContextVar_Get((PyObject *)self, default_value, &val) < 0) { return NULL; } if (val == NULL) { PyErr_SetObject(PyExc_LookupError, (PyObject *)self); return NULL; } return val; } /*[clinic input] _contextvars.ContextVar.set value: object / Call to set a new value for the context variable in the current context. The required value argument is the new value for the context variable. Returns a Token object that can be used to restore the variable to its previous value via the `ContextVar.reset()` method. [clinic start generated code]*/ static PyObject * _contextvars_ContextVar_set(PyContextVar *self, PyObject *value) /*[clinic end generated code: output=446ed5e820d6d60b input=c0a6887154227453]*/ { return PyContextVar_Set((PyObject *)self, value); } /*[clinic input] _contextvars.ContextVar.reset token: object / Reset the context variable. The variable is reset to the value it had before the `ContextVar.set()` that created the token was used. [clinic start generated code]*/ static PyObject * _contextvars_ContextVar_reset(PyContextVar *self, PyObject *token) /*[clinic end generated code: output=d4ee34d0742d62ee input=ebe2881e5af4ffda]*/ { if (!PyContextToken_CheckExact(token)) { PyErr_Format(PyExc_TypeError, "expected an instance of Token, got %R", token); return NULL; } if (PyContextVar_Reset((PyObject *)self, token)) { return NULL; } Py_RETURN_NONE; } static PyMemberDef PyContextVar_members[] = { {"name", T_OBJECT, offsetof(PyContextVar, var_name), READONLY}, {NULL} }; static PyMethodDef PyContextVar_methods[] = { _CONTEXTVARS_CONTEXTVAR_GET_METHODDEF _CONTEXTVARS_CONTEXTVAR_SET_METHODDEF _CONTEXTVARS_CONTEXTVAR_RESET_METHODDEF {"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS, PyDoc_STR("See PEP 585")}, {NULL, NULL} }; PyTypeObject PyContextVar_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "_contextvars.ContextVar", sizeof(PyContextVar), .tp_methods = PyContextVar_methods, .tp_members = PyContextVar_members, .tp_dealloc = (destructor)contextvar_tp_dealloc, .tp_getattro = PyObject_GenericGetAttr, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_traverse = (traverseproc)contextvar_tp_traverse, .tp_clear = (inquiry)contextvar_tp_clear, .tp_new = contextvar_tp_new, .tp_free = PyObject_GC_Del, .tp_hash = (hashfunc)contextvar_tp_hash, .tp_repr = (reprfunc)contextvar_tp_repr, }; /////////////////////////// Token static PyObject * get_token_missing(void); /*[clinic input] class _contextvars.Token "PyContextToken *" "&PyContextToken_Type" [clinic start generated code]*/ /*[clinic end generated code: output=da39a3ee5e6b4b0d input=338a5e2db13d3f5b]*/ static PyObject * token_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyErr_SetString(PyExc_RuntimeError, "Tokens can only be created by ContextVars"); return NULL; } static int token_tp_clear(PyContextToken *self) { Py_CLEAR(self->tok_ctx); Py_CLEAR(self->tok_var); Py_CLEAR(self->tok_oldval); return 0; } static int token_tp_traverse(PyContextToken *self, visitproc visit, void *arg) { Py_VISIT(self->tok_ctx); Py_VISIT(self->tok_var); Py_VISIT(self->tok_oldval); return 0; } static void token_tp_dealloc(PyContextToken *self) { PyObject_GC_UnTrack(self); (void)token_tp_clear(self); Py_TYPE(self)->tp_free(self); } static PyObject * token_tp_repr(PyContextToken *self) { _PyUnicodeWriter writer; _PyUnicodeWriter_Init(&writer); if (_PyUnicodeWriter_WriteASCIIString(&writer, "<Token", 6) < 0) { goto error; } if (self->tok_used) { if (_PyUnicodeWriter_WriteASCIIString(&writer, " used", 5) < 0) { goto error; } } if (_PyUnicodeWriter_WriteASCIIString(&writer, " var=", 5) < 0) { goto error; } PyObject *var = PyObject_Repr((PyObject *)self->tok_var); if (var == NULL) { goto error; } if (_PyUnicodeWriter_WriteStr(&writer, var) < 0) { Py_DECREF(var); goto error; } Py_DECREF(var); PyObject *addr = PyUnicode_FromFormat(" at %p>", self); if (addr == NULL) { goto error; } if (_PyUnicodeWriter_WriteStr(&writer, addr) < 0) { Py_DECREF(addr); goto error; } Py_DECREF(addr); return _PyUnicodeWriter_Finish(&writer); error: _PyUnicodeWriter_Dealloc(&writer); return NULL; } static PyObject * token_get_var(PyContextToken *self, void *Py_UNUSED(ignored)) { return Py_NewRef(self->tok_var);; } static PyObject * token_get_old_value(PyContextToken *self, void *Py_UNUSED(ignored)) { if (self->tok_oldval == NULL) { return get_token_missing(); } return Py_NewRef(self->tok_oldval); } static PyGetSetDef PyContextTokenType_getsetlist[] = { {"var", (getter)token_get_var, NULL, NULL}, {"old_value", (getter)token_get_old_value, NULL, NULL}, {NULL} }; static PyMethodDef PyContextTokenType_methods[] = { {"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS, PyDoc_STR("See PEP 585")}, {NULL} }; PyTypeObject PyContextToken_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "_contextvars.Token", sizeof(PyContextToken), .tp_methods = PyContextTokenType_methods, .tp_getset = PyContextTokenType_getsetlist, .tp_dealloc = (destructor)token_tp_dealloc, .tp_getattro = PyObject_GenericGetAttr, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_traverse = (traverseproc)token_tp_traverse, .tp_clear = (inquiry)token_tp_clear, .tp_new = token_tp_new, .tp_free = PyObject_GC_Del, .tp_hash = PyObject_HashNotImplemented, .tp_repr = (reprfunc)token_tp_repr, }; static PyContextToken * token_new(PyContext *ctx, PyContextVar *var, PyObject *val) { PyContextToken *tok = PyObject_GC_New(PyContextToken, &PyContextToken_Type); if (tok == NULL) { return NULL; } tok->tok_ctx = (PyContext*)Py_NewRef(ctx); tok->tok_var = (PyContextVar*)Py_NewRef(var); tok->tok_oldval = Py_XNewRef(val); tok->tok_used = 0; PyObject_GC_Track(tok); return tok; } /////////////////////////// Token.MISSING static PyObject * context_token_missing_tp_repr(PyObject *self) { return PyUnicode_FromString("<Token.MISSING>"); } static void context_token_missing_tp_dealloc(_PyContextTokenMissing *Py_UNUSED(self)) { #ifdef Py_DEBUG /* The singleton is statically allocated. */ _Py_FatalRefcountError("deallocating the token missing singleton"); #else return; #endif } PyTypeObject _PyContextTokenMissing_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "Token.MISSING", sizeof(_PyContextTokenMissing), .tp_dealloc = (destructor)context_token_missing_tp_dealloc, .tp_getattro = PyObject_GenericGetAttr, .tp_flags = Py_TPFLAGS_DEFAULT, .tp_repr = context_token_missing_tp_repr, }; static PyObject * get_token_missing(void) { return Py_NewRef(&_Py_SINGLETON(context_token_missing)); } /////////////////////////// void _PyContext_ClearFreeList(PyInterpreterState *interp) { #if PyContext_MAXFREELIST > 0 struct _Py_context_state *state = &interp->context; for (; state->numfree; state->numfree--) { PyContext *ctx = state->freelist; state->freelist = (PyContext *)ctx->ctx_weakreflist; ctx->ctx_weakreflist = NULL; PyObject_GC_Del(ctx); } #endif } void _PyContext_Fini(PyInterpreterState *interp) { _PyContext_ClearFreeList(interp); #if defined(Py_DEBUG) && PyContext_MAXFREELIST > 0 struct _Py_context_state *state = &interp->context; state->numfree = -1; #endif } PyStatus _PyContext_Init(PyInterpreterState *interp) { if (!_Py_IsMainInterpreter(interp)) { return _PyStatus_OK(); } PyObject *missing = get_token_missing(); if (PyDict_SetItemString( _PyType_GetDict(&PyContextToken_Type), "MISSING", missing)) { Py_DECREF(missing); return _PyStatus_ERR("can't init context types"); } Py_DECREF(missing); return _PyStatus_OK(); }
generated by cgit v0.12 at 2025-07-29 18:15:06 (GMT)