{
assert(callable != NULL);
PyTypeObject *tp = Py_TYPE(callable);
- if (!PyType_HasFeature(tp, _Py_TPFLAGS_HAVE_VECTORCALL)) {
+ if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) {
return NULL;
}
assert(PyCallable_Check(callable));
static inline PyObject *
PyObject_CallMethodNoArgs(PyObject *self, PyObject *name)
{
- return _PyObject_VectorcallMethod(name, &self,
+ return PyObject_VectorcallMethod(name, &self,
1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
}
{
assert(arg != NULL);
PyObject *args[2] = {self, arg};
- return _PyObject_VectorcallMethod(name, args,
+ return PyObject_VectorcallMethod(name, args,
2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
}
self.check_result(result, expected)
def test_vectorcall_dict(self):
- # Test _PyObject_FastCallDict()
+ # Test PyObject_VectorcallDict()
for func, args, expected in self.CALLS_POSARGS:
with self.subTest(func=func, args=args):
self.check_result(result, expected)
def test_vectorcall(self):
- # Test _PyObject_Vectorcall()
+ # Test PyObject_Vectorcall()
for func, args, expected in self.CALLS_POSARGS:
with self.subTest(func=func, args=args):
# 1. vectorcall using PyVectorcall_Call()
# (only for objects that support vectorcall directly)
# 2. normal call
- # 3. vectorcall using _PyObject_Vectorcall()
+ # 3. vectorcall using PyObject_Vectorcall()
# 4. call as bound method
# 5. call using functools.partial
Do this check after 'future_init()'; in case we need to raise
an error, __del__ needs a properly initialized object.
*/
- PyObject *res = _PyObject_CallOneArg(asyncio_iscoroutine_func, coro);
+ PyObject *res = PyObject_CallOneArg(asyncio_iscoroutine_func, coro);
if (res == NULL) {
return -1;
}
}
stack[nargs] = (PyObject *)ctx;
- handle = _PyObject_Vectorcall(callable, stack, nargs, context_kwname);
+ handle = PyObject_Vectorcall(callable, stack, nargs, context_kwname);
Py_DECREF(callable);
}
_asyncio_Future__repr_info_impl(FutureObj *self)
/*[clinic end generated code: output=fa69e901bd176cfb input=f21504d8e2ae1ca2]*/
{
- return _PyObject_CallOneArg(asyncio_future_repr_info_func, (PyObject *)self);
+ return PyObject_CallOneArg(asyncio_future_repr_info_func, (PyObject *)self);
}
static PyObject *
func = _PyObject_GetAttrId(fut->fut_loop, &PyId_call_exception_handler);
if (func != NULL) {
- PyObject *res = _PyObject_CallOneArg(func, context);
+ PyObject *res = PyObject_CallOneArg(func, context);
if (res == NULL) {
PyErr_WriteUnraisable(func);
}
Py_DECREF(current_task_func);
return NULL;
}
- ret = _PyObject_CallOneArg(current_task_func, loop);
+ ret = PyObject_CallOneArg(current_task_func, loop);
Py_DECREF(current_task_func);
Py_DECREF(loop);
return ret;
}
else {
- ret = _PyObject_CallOneArg(current_task_func, loop);
+ ret = PyObject_CallOneArg(current_task_func, loop);
Py_DECREF(current_task_func);
return ret;
}
return NULL;
}
- res = _PyObject_CallOneArg(all_tasks_func, loop);
+ res = PyObject_CallOneArg(all_tasks_func, loop);
Py_DECREF(all_tasks_func);
return res;
}
_asyncio_Task__repr_info_impl(TaskObj *self)
/*[clinic end generated code: output=6a490eb66d5ba34b input=3c6d051ed3ddec8b]*/
{
- return _PyObject_CallOneArg(asyncio_task_repr_info_func, (PyObject *)self);
+ return PyObject_CallOneArg(asyncio_task_repr_info_func, (PyObject *)self);
}
/*[clinic input]
func = _PyObject_GetAttrId(task->task_loop, &PyId_call_exception_handler);
if (func != NULL) {
- PyObject *res = _PyObject_CallOneArg(func, context);
+ PyObject *res = PyObject_CallOneArg(func, context);
if (res == NULL) {
PyErr_WriteUnraisable(func);
}
return NULL;
}
- PyObject *e = _PyObject_CallOneArg(et, msg);
+ PyObject *e = PyObject_CallOneArg(et, msg);
Py_DECREF(msg);
if (e == NULL) {
return NULL;
PyObject *stack[2];
stack[0] = wrapper;
stack[1] = (PyObject *)task->task_context;
- res = _PyObject_Vectorcall(add_cb, stack, 1, context_kwname);
+ res = PyObject_Vectorcall(add_cb, stack, 1, context_kwname);
Py_DECREF(add_cb);
Py_DECREF(wrapper);
if (res == NULL) {
return NULL;
}
if (old_deque->maxlen < 0)
- result = _PyObject_CallOneArg((PyObject *)(Py_TYPE(deque)), deque);
+ result = PyObject_CallOneArg((PyObject *)(Py_TYPE(deque)), deque);
else
result = PyObject_CallFunction((PyObject *)(Py_TYPE(deque)), "Oi",
deque, old_deque->maxlen, NULL);
{
PyObject *type = (PyObject *)&Dialect_Type;
if (dialect_inst) {
- return _PyObject_FastCallDict(type, &dialect_inst, 1, kwargs);
+ return PyObject_VectorcallDict(type, &dialect_inst, 1, kwargs);
}
else {
- return _PyObject_FastCallDict(type, NULL, 0, kwargs);
+ return PyObject_VectorcallDict(type, NULL, 0, kwargs);
}
}
if (line == NULL) {
return NULL;
}
- result = _PyObject_CallOneArg(self->write, line);
+ result = PyObject_CallOneArg(self->write, line);
Py_DECREF(line);
return result;
}
if (!checker || !retval)
return retval;
- v = _PyObject_CallOneArg(checker, retval);
+ v = PyObject_CallOneArg(checker, retval);
if (v == NULL)
_PyTraceback_Add("GetResult", "_ctypes/callproc.c", __LINE__-2);
Py_DECREF(retval);
if (argtypes && argtype_count > i) {
PyObject *v;
converter = PyTuple_GET_ITEM(argtypes, i);
- v = _PyObject_CallOneArg(converter, arg);
+ v = PyObject_CallOneArg(converter, arg);
if (v == NULL) {
_ctypes_extend_error(PyExc_ArgError, "argument %zd: ", i+1);
goto cleanup;
typ = PyDict_GetItemWithError(_ctypes_ptrtype_cache, (PyObject *)Py_TYPE(arg));
if (typ) {
- return _PyObject_CallOneArg(typ, arg);
+ return PyObject_CallOneArg(typ, arg);
}
else if (PyErr_Occurred()) {
return NULL;
typ = POINTER(NULL, (PyObject *)Py_TYPE(arg));
if (typ == NULL)
return NULL;
- result = _PyObject_CallOneArg(typ, arg);
+ result = PyObject_CallOneArg(typ, arg);
Py_DECREF(typ);
return result;
}
PyObject *event = PyTuple_Pack(2, action, node);
if (event == NULL)
return -1;
- res = _PyObject_CallOneArg(self->events_append, event);
+ res = PyObject_CallOneArg(self->events_append, event);
Py_DECREF(event);
if (res == NULL)
return -1;
}
if (self->comment_factory) {
- comment = _PyObject_CallOneArg(self->comment_factory, text);
+ comment = PyObject_CallOneArg(self->comment_factory, text);
if (!comment)
return NULL;
if (errmsg == NULL)
return;
- error = _PyObject_CallOneArg(st->parseerror_obj, errmsg);
+ error = PyObject_CallOneArg(st->parseerror_obj, errmsg);
Py_DECREF(errmsg);
if (!error)
return;
(TreeBuilderObject*) self->target, value
);
else if (self->handle_data)
- res = _PyObject_CallOneArg(self->handle_data, value);
+ res = PyObject_CallOneArg(self->handle_data, value);
else
res = NULL;
Py_XDECREF(res);
/* shortcut */
res = treebuilder_handle_data((TreeBuilderObject*) self->target, data);
else if (self->handle_data)
- res = _PyObject_CallOneArg(self->handle_data, data);
+ res = PyObject_CallOneArg(self->handle_data, data);
else
res = NULL;
else if (self->handle_end) {
tag = makeuniversal(self, tag_in);
if (tag) {
- res = _PyObject_CallOneArg(self->handle_end, tag);
+ res = PyObject_CallOneArg(self->handle_end, tag);
Py_DECREF(tag);
}
}
if (!prefix)
return;
- res = _PyObject_CallOneArg(self->handle_end_ns, prefix);
+ res = PyObject_CallOneArg(self->handle_end_ns, prefix);
Py_DECREF(prefix);
}
if (!comment)
return;
- res = _PyObject_CallOneArg(self->handle_comment, comment);
+ res = PyObject_CallOneArg(self->handle_comment, comment);
Py_XDECREF(res);
Py_DECREF(comment);
}
static void
partial_setvectorcall(partialobject *pto)
{
- if (_PyVectorcall_Function(pto->fn) == NULL) {
+ if (PyVectorcall_Function(pto->fn) == NULL) {
/* Don't use vectorcall if the underlying function doesn't support it */
pto->vectorcall = NULL;
}
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
Py_TPFLAGS_BASETYPE |
- _Py_TPFLAGS_HAVE_VECTORCALL, /* tp_flags */
+ Py_TPFLAGS_HAVE_VECTORCALL, /* tp_flags */
partial_doc, /* tp_doc */
(traverseproc)partial_traverse, /* tp_traverse */
0, /* tp_clear */
buffered_simple_flush(buffered *self, PyObject *args)
{
CHECK_INITIALIZED(self)
- return _PyObject_CallMethodNoArgs(self->raw, _PyIO_str_flush);
+ return PyObject_CallMethodNoArgs(self->raw, _PyIO_str_flush);
}
static int
}
/* flush() will most probably re-take the lock, so drop it first */
LEAVE_BUFFERED(self)
- res = _PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
+ res = PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
if (!ENTER_BUFFERED(self))
return NULL;
if (res == NULL)
else
Py_DECREF(res);
- res = _PyObject_CallMethodNoArgs(self->raw, _PyIO_str_close);
+ res = PyObject_CallMethodNoArgs(self->raw, _PyIO_str_close);
if (self->buffer) {
PyMem_Free(self->buffer);
{
PyObject *raw, *res;
CHECK_INITIALIZED(self)
- res = _PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
+ res = PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
if (res == NULL)
return NULL;
Py_DECREF(res);
buffered_seekable(buffered *self, PyObject *Py_UNUSED(ignored))
{
CHECK_INITIALIZED(self)
- return _PyObject_CallMethodNoArgs(self->raw, _PyIO_str_seekable);
+ return PyObject_CallMethodNoArgs(self->raw, _PyIO_str_seekable);
}
static PyObject *
buffered_readable(buffered *self, PyObject *Py_UNUSED(ignored))
{
CHECK_INITIALIZED(self)
- return _PyObject_CallMethodNoArgs(self->raw, _PyIO_str_readable);
+ return PyObject_CallMethodNoArgs(self->raw, _PyIO_str_readable);
}
static PyObject *
buffered_writable(buffered *self, PyObject *Py_UNUSED(ignored))
{
CHECK_INITIALIZED(self)
- return _PyObject_CallMethodNoArgs(self->raw, _PyIO_str_writable);
+ return PyObject_CallMethodNoArgs(self->raw, _PyIO_str_writable);
}
static PyObject *
buffered_fileno(buffered *self, PyObject *Py_UNUSED(ignored))
{
CHECK_INITIALIZED(self)
- return _PyObject_CallMethodNoArgs(self->raw, _PyIO_str_fileno);
+ return PyObject_CallMethodNoArgs(self->raw, _PyIO_str_fileno);
}
static PyObject *
buffered_isatty(buffered *self, PyObject *Py_UNUSED(ignored))
{
CHECK_INITIALIZED(self)
- return _PyObject_CallMethodNoArgs(self->raw, _PyIO_str_isatty);
+ return PyObject_CallMethodNoArgs(self->raw, _PyIO_str_isatty);
}
/* Forward decls */
{
Py_off_t n;
PyObject *res;
- res = _PyObject_CallMethodNoArgs(self->raw, _PyIO_str_tell);
+ res = PyObject_CallMethodNoArgs(self->raw, _PyIO_str_tell);
if (res == NULL)
return -1;
n = PyNumber_AsOff_t(res, PyExc_ValueError);
goto end;
Py_CLEAR(res);
}
- res = _PyObject_CallMethodOneArg(self->raw, _PyIO_str_truncate, pos);
+ res = PyObject_CallMethodOneArg(self->raw, _PyIO_str_truncate, pos);
if (res == NULL)
goto end;
/* Reset cached position */
line = _buffered_readline(self, -1);
}
else {
- line = _PyObject_CallMethodNoArgs((PyObject *)self,
+ line = PyObject_CallMethodNoArgs((PyObject *)self,
_PyIO_str_readline);
if (line && !PyBytes_Check(line)) {
PyErr_Format(PyExc_OSError,
raised (see issue #10956).
*/
do {
- res = _PyObject_CallMethodOneArg(self->raw, _PyIO_str_readinto, memobj);
+ res = PyObject_CallMethodOneArg(self->raw, _PyIO_str_readinto, memobj);
} while (res == NULL && _PyIO_trap_eintr());
Py_DECREF(memobj);
if (res == NULL)
}
/* Read until EOF or until read() would block. */
- data = _PyObject_CallMethodNoArgs(self->raw, _PyIO_str_read);
+ data = PyObject_CallMethodNoArgs(self->raw, _PyIO_str_read);
if (data == NULL)
goto cleanup;
if (data != Py_None && !PyBytes_Check(data)) {
*/
do {
errno = 0;
- res = _PyObject_CallMethodOneArg(self->raw, _PyIO_str_write, memobj);
+ res = PyObject_CallMethodOneArg(self->raw, _PyIO_str_write, memobj);
errnum = errno;
} while (res == NULL && _PyIO_trap_eintr());
Py_DECREF(memobj);
Py_RETURN_NONE;
}
- res = _PyObject_CallMethodNoArgs(self, _PyIO_str_flush);
+ res = PyObject_CallMethodNoArgs(self, _PyIO_str_flush);
PyErr_Fetch(&exc, &val, &tb);
rc = _PyObject_SetAttrId(self, &PyId___IOBase_closed, Py_True);
finalization process. */
if (_PyObject_SetAttrId(self, &PyId__finalizing, Py_True))
PyErr_Clear();
- res = _PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_close);
+ res = PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_close);
/* Silencing I/O errors is bad, but printing spurious tracebacks is
equally as bad, and potentially more frequent (because of
shutdown issues). */
PyObject *
_PyIOBase_check_seekable(PyObject *self, PyObject *args)
{
- PyObject *res = _PyObject_CallMethodNoArgs(self, _PyIO_str_seekable);
+ PyObject *res = PyObject_CallMethodNoArgs(self, _PyIO_str_seekable);
if (res == NULL)
return NULL;
if (res != Py_True) {
PyObject *
_PyIOBase_check_readable(PyObject *self, PyObject *args)
{
- PyObject *res = _PyObject_CallMethodNoArgs(self, _PyIO_str_readable);
+ PyObject *res = PyObject_CallMethodNoArgs(self, _PyIO_str_readable);
if (res == NULL)
return NULL;
if (res != Py_True) {
PyObject *
_PyIOBase_check_writable(PyObject *self, PyObject *args)
{
- PyObject *res = _PyObject_CallMethodNoArgs(self, _PyIO_str_writable);
+ PyObject *res = PyObject_CallMethodNoArgs(self, _PyIO_str_writable);
if (res == NULL)
return NULL;
if (res != Py_True) {
static PyObject *
iobase_exit(PyObject *self, PyObject *args)
{
- return _PyObject_CallMethodNoArgs(self, _PyIO_str_close);
+ return PyObject_CallMethodNoArgs(self, _PyIO_str_close);
}
/* Lower-level APIs */
PyObject *b;
if (peek != NULL) {
- PyObject *readahead = _PyObject_CallOneArg(peek, _PyLong_One);
+ PyObject *readahead = PyObject_CallOneArg(peek, _PyLong_One);
if (readahead == NULL) {
/* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals()
when EINTR occurs so we needn't do it ourselves. */
static PyObject *
iobase_iternext(PyObject *self)
{
- PyObject *line = _PyObject_CallMethodNoArgs(self, _PyIO_str_readline);
+ PyObject *line = PyObject_CallMethodNoArgs(self, _PyIO_str_readline);
if (line == NULL)
return NULL;
}
else {
/* XXX is subclassing StringIO really supported? */
- line = _PyObject_CallMethodNoArgs((PyObject *)self,
+ line = PyObject_CallMethodNoArgs((PyObject *)self,
_PyIO_str_readline);
if (line && !PyUnicode_Check(line)) {
PyErr_Format(PyExc_OSError,
unsigned long long flag;
if (self->decoder != Py_None) {
- PyObject *state = _PyObject_CallMethodNoArgs(self->decoder,
+ PyObject *state = PyObject_CallMethodNoArgs(self->decoder,
_PyIO_str_getstate);
if (state == NULL)
return NULL;
self->seennl = 0;
self->pendingcr = 0;
if (self->decoder != Py_None)
- return _PyObject_CallMethodNoArgs(self->decoder, _PyIO_str_reset);
+ return PyObject_CallMethodNoArgs(self->decoder, _PyIO_str_reset);
else
Py_RETURN_NONE;
}
self->encoding_start_of_stream = 1;
- PyObject *cookieObj = _PyObject_CallMethodNoArgs(
+ PyObject *cookieObj = PyObject_CallMethodNoArgs(
self->buffer, _PyIO_str_tell);
if (cookieObj == NULL) {
return -1;
if (cmp == 0) {
self->encoding_start_of_stream = 0;
- PyObject *res = _PyObject_CallMethodOneArg(
+ PyObject *res = PyObject_CallMethodOneArg(
self->encoder, _PyIO_str_setstate, _PyLong_Zero);
if (res == NULL) {
return -1;
return NULL;
}
- PyObject *res = _PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
+ PyObject *res = PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
if (res == NULL) {
return NULL;
}
{
PyObject *buffer, *res;
CHECK_ATTACHED(self);
- res = _PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
+ res = PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
if (res == NULL)
return NULL;
Py_DECREF(res);
PyObject *ret;
do {
- ret = _PyObject_CallMethodOneArg(self->buffer, _PyIO_str_write, b);
+ ret = PyObject_CallMethodOneArg(self->buffer, _PyIO_str_write, b);
} while (ret == NULL && _PyIO_trap_eintr());
Py_DECREF(b);
if (ret == NULL)
self->encoding_start_of_stream = 0;
}
else
- b = _PyObject_CallMethodOneArg(self->encoder, _PyIO_str_encode, text);
+ b = PyObject_CallMethodOneArg(self->encoder, _PyIO_str_encode, text);
Py_DECREF(text);
if (b == NULL)
}
if (needflush) {
- ret = _PyObject_CallMethodNoArgs(self->buffer, _PyIO_str_flush);
+ ret = PyObject_CallMethodNoArgs(self->buffer, _PyIO_str_flush);
if (ret == NULL)
return NULL;
Py_DECREF(ret);
/* To prepare for tell(), we need to snapshot a point in the file
* where the decoder's input buffer is empty.
*/
- PyObject *state = _PyObject_CallMethodNoArgs(self->decoder,
+ PyObject *state = PyObject_CallMethodNoArgs(self->decoder,
_PyIO_str_getstate);
if (state == NULL)
return -1;
if (chunk_size == NULL)
goto fail;
- input_chunk = _PyObject_CallMethodOneArg(self->buffer,
+ input_chunk = PyObject_CallMethodOneArg(self->buffer,
(self->has_read1 ? _PyIO_str_read1: _PyIO_str_read),
chunk_size);
Py_DECREF(chunk_size);
utf-16, that we are expecting a BOM).
*/
if (cookie->start_pos == 0 && cookie->dec_flags == 0)
- res = _PyObject_CallMethodNoArgs(self->decoder, _PyIO_str_reset);
+ res = PyObject_CallMethodNoArgs(self->decoder, _PyIO_str_reset);
else
res = _PyObject_CallMethodId(self->decoder, &PyId_setstate,
"((yi))", "", cookie->dec_flags);
{
PyObject *res;
if (start_of_stream) {
- res = _PyObject_CallMethodNoArgs(self->encoder, _PyIO_str_reset);
+ res = PyObject_CallMethodNoArgs(self->encoder, _PyIO_str_reset);
self->encoding_start_of_stream = 1;
}
else {
- res = _PyObject_CallMethodOneArg(self->encoder, _PyIO_str_setstate,
+ res = PyObject_CallMethodOneArg(self->encoder, _PyIO_str_setstate,
_PyLong_Zero);
self->encoding_start_of_stream = 0;
}
goto fail;
}
- res = _PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
+ res = PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
if (res == NULL)
goto fail;
Py_DECREF(res);
posobj = PyLong_FromOff_t(cookie.start_pos);
if (posobj == NULL)
goto fail;
- res = _PyObject_CallMethodOneArg(self->buffer, _PyIO_str_seek, posobj);
+ res = PyObject_CallMethodOneArg(self->buffer, _PyIO_str_seek, posobj);
Py_DECREF(posobj);
if (res == NULL)
goto fail;
chars_to_skip = self->decoded_chars_used;
/* Decoder state will be restored at the end */
- saved_state = _PyObject_CallMethodNoArgs(self->decoder,
+ saved_state = PyObject_CallMethodNoArgs(self->decoder,
_PyIO_str_getstate);
if (saved_state == NULL)
goto fail;
#define DECODER_GETSTATE() do { \
PyObject *dec_buffer; \
- PyObject *_state = _PyObject_CallMethodNoArgs(self->decoder, \
+ PyObject *_state = PyObject_CallMethodNoArgs(self->decoder, \
_PyIO_str_getstate); \
if (_state == NULL) \
goto fail; \
CHECK_ATTACHED(self)
- res = _PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
+ res = PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_flush);
if (res == NULL)
return NULL;
Py_DECREF(res);
- return _PyObject_CallMethodOneArg(self->buffer, _PyIO_str_truncate, pos);
+ return PyObject_CallMethodOneArg(self->buffer, _PyIO_str_truncate, pos);
}
static PyObject *
line = _textiowrapper_readline(self, -1);
}
else {
- line = _PyObject_CallMethodNoArgs((PyObject *)self,
+ line = PyObject_CallMethodNoArgs((PyObject *)self,
_PyIO_str_readline);
if (line && !PyUnicode_Check(line)) {
PyErr_Format(PyExc_OSError,
*next_idx_ptr = idx + 1;
if (has_pairs_hook) {
- val = _PyObject_CallOneArg(s->object_pairs_hook, rval);
+ val = PyObject_CallOneArg(s->object_pairs_hook, rval);
Py_DECREF(rval);
return val;
}
/* if object_hook is not None: rval = object_hook(rval) */
if (s->object_hook != Py_None) {
- val = _PyObject_CallOneArg(s->object_hook, rval);
+ val = PyObject_CallOneArg(s->object_hook, rval);
Py_DECREF(rval);
return val;
}
return NULL;
/* rval = parse_constant(constant) */
- rval = _PyObject_CallOneArg(s->parse_constant, cstr);
+ rval = PyObject_CallOneArg(s->parse_constant, cstr);
idx += PyUnicode_GET_LENGTH(cstr);
Py_DECREF(cstr);
*next_idx_ptr = idx;
idx - start);
if (numstr == NULL)
return NULL;
- rval = _PyObject_CallOneArg(custom_func, numstr);
+ rval = PyObject_CallOneArg(custom_func, numstr);
}
else {
Py_ssize_t i, n;
if (s->fast_encode) {
return s->fast_encode(NULL, obj);
}
- encoded = _PyObject_CallOneArg(s->encoder, obj);
+ encoded = PyObject_CallOneArg(s->encoder, obj);
if (encoded != NULL && !PyUnicode_Check(encoded)) {
PyErr_Format(PyExc_TypeError,
"encoder() must return a string, not %.80s",
return -1;
}
}
- newobj = _PyObject_CallOneArg(s->defaultfn, obj);
+ newobj = PyObject_CallOneArg(s->defaultfn, obj);
if (newobj == NULL) {
Py_XDECREF(ident);
return -1;
newargs[0] = (PyObject *)Py_TYPE(mc);
newargs[1] = mc->name;
- constructor = _PyObject_FastCallDict(partial, newargs, 2, mc->kwds);
+ constructor = PyObject_VectorcallDict(partial, newargs, 2, mc->kwds);
Py_DECREF(partial);
return Py_BuildValue("NO", constructor, mc->args);
{
PyObject *result;
- result = _PyObject_CallOneArg(func, obj);
+ result = PyObject_CallOneArg(func, obj);
Py_DECREF(obj);
return result;
}
return PyObject_CallFunctionObjArgs(func, self, obj, NULL);
}
else {
- return _PyObject_CallOneArg(func, obj);
+ return PyObject_CallOneArg(func, obj);
}
}
return -1;
}
}
- result = _PyObject_CallOneArg(self->write, payload);
+ result = PyObject_CallOneArg(self->write, payload);
Py_XDECREF(mem);
if (result == NULL) {
return -1;
}
int in_band = 1;
if (self->buffer_callback != NULL) {
- PyObject *ret = _PyObject_CallOneArg(self->buffer_callback, obj);
+ PyObject *ret = PyObject_CallOneArg(self->buffer_callback, obj);
if (ret == NULL) {
return -1;
}
* regular reduction mechanism.
*/
if (self->reducer_override != NULL) {
- reduce_value = _PyObject_CallOneArg(self->reducer_override, obj);
+ reduce_value = PyObject_CallOneArg(self->reducer_override, obj);
if (reduce_value == NULL) {
goto error;
}
if (need_to_reenable_gc) {
PyErr_Fetch(&exctype, &val, &tb);
- result = _PyObject_CallMethodNoArgs(
+ result = PyObject_CallMethodNoArgs(
gc_module, _posixsubprocessstate_global->enable);
if (exctype != NULL) {
PyErr_Restore(exctype, val, tb);
gc_module = PyImport_ImportModule("gc");
if (gc_module == NULL)
return NULL;
- result = _PyObject_CallMethodNoArgs(
+ result = PyObject_CallMethodNoArgs(
gc_module, _posixsubprocessstate_global->isenabled);
if (result == NULL) {
Py_DECREF(gc_module);
Py_DECREF(gc_module);
return NULL;
}
- result = _PyObject_CallMethodNoArgs(
+ result = PyObject_CallMethodNoArgs(
gc_module, _posixsubprocessstate_global->disable);
if (result == NULL) {
Py_DECREF(gc_module);
/* Calling int.__abs__() prevents calling arg.__abs__(), which might
return an invalid value. See issue #31478. */
args[0] = arg;
- n = _PyObject_Vectorcall(_randomstate_global->Long___abs__, args, 0,
+ n = PyObject_Vectorcall(_randomstate_global->Long___abs__, args, 0,
NULL);
}
else {
}
}
- /* We cannot replace this by _PyObject_CallOneArg() since
+ /* We cannot replace this by PyObject_CallOneArg() since
* PyObject_CallFunction() has a special case when using a
* single tuple as argument. */
data = PyObject_CallFunction(self->factory, "O", key);
factory = (PyObject*)&pysqlite_CursorType;
}
- cursor = _PyObject_CallOneArg(factory, (PyObject *)self);
+ cursor = PyObject_CallOneArg(factory, (PyObject *)self);
if (cursor == NULL)
return NULL;
if (!PyObject_TypeCheck(cursor, &pysqlite_CursorType)) {
py_statement = PyUnicode_DecodeUTF8(statement_string,
strlen(statement_string), "replace");
if (py_statement) {
- ret = _PyObject_CallOneArg((PyObject*)user_arg, py_statement);
+ ret = PyObject_CallOneArg((PyObject*)user_arg, py_statement);
Py_DECREF(py_statement);
}
goto finally;
}
- retval = _PyObject_CallOneArg(pyfn_iterdump, (PyObject *)self);
+ retval = PyObject_CallOneArg(pyfn_iterdump, (PyObject *)self);
finally:
Py_XDECREF(module);
item = PyBytes_FromStringAndSize(val_str, nbytes);
if (!item)
goto error;
- converted = _PyObject_CallOneArg(converter, item);
+ converted = PyObject_CallOneArg(converter, item);
Py_DECREF(item);
}
} else {
Py_DECREF(key);
if (adapter) {
Py_INCREF(adapter);
- adapted = _PyObject_CallOneArg(adapter, obj);
+ adapted = PyObject_CallOneArg(adapter, obj);
Py_DECREF(adapter);
return adapted;
}
return NULL;
}
if (adapter) {
- adapted = _PyObject_CallOneArg(adapter, obj);
+ adapted = PyObject_CallOneArg(adapter, obj);
Py_DECREF(adapter);
if (adapted == Py_None) {
return NULL;
}
if (adapter) {
- adapted = _PyObject_CallOneArg(adapter, proto);
+ adapted = PyObject_CallOneArg(adapter, proto);
Py_DECREF(adapter);
if (adapted == Py_None) {
match = pattern_new_match(self, &state, 1);
if (!match)
goto error;
- item = _PyObject_CallOneArg(filter, match);
+ item = PyObject_CallOneArg(filter, match);
Py_DECREF(match);
if (!item)
goto error;
return 0;
}
- s_object = _PyObject_CallOneArg(_structmodulestate_global->PyStructType, fmt);
+ s_object = PyObject_CallOneArg(_structmodulestate_global->PyStructType, fmt);
if (s_object != NULL) {
if (PyDict_GET_SIZE(cache) >= MAXCACHE)
PyDict_Clear(cache);
return NULL;
}
- return _PyObject_FastCallDict(func, stack, nargs, kwargs);
+ return PyObject_VectorcallDict(func, stack, nargs, kwargs);
}
PyErr_SetString(PyExc_TypeError, "kwnames must be None or a tuple");
return NULL;
}
- return _PyObject_Vectorcall(func, stack, nargs, kwnames);
+ return PyObject_Vectorcall(func, stack, nargs, kwnames);
}
if (pyargs == NULL) {
return NULL;
}
- PyObject *pykwargs = _PyObject_Vectorcall((PyObject*)&PyDict_Type,
+ PyObject *pykwargs = PyObject_Vectorcall((PyObject*)&PyDict_Type,
args + nargs, 0, kwargs);
return Py_BuildValue("NNN", _null_to_none(self), pyargs, pykwargs);
}
.tp_call = PyVectorcall_Call,
.tp_vectorcall_offset = offsetof(MethodDescriptorObject, vectorcall),
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
- Py_TPFLAGS_METHOD_DESCRIPTOR | _Py_TPFLAGS_HAVE_VECTORCALL,
+ Py_TPFLAGS_METHOD_DESCRIPTOR | Py_TPFLAGS_HAVE_VECTORCALL,
.tp_descr_get = func_descr_get,
};
.tp_new = MethodDescriptor2_new,
.tp_call = PyVectorcall_Call,
.tp_vectorcall_offset = offsetof(MethodDescriptor2Object, vectorcall),
- .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | _Py_TPFLAGS_HAVE_VECTORCALL,
+ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_VECTORCALL,
};
PyDoc_STRVAR(heapgctype__doc__,
if (input_bytes == NULL) {
return 0;
}
- PyObject* parsed = _PyObject_CallOneArg(json_loads_method, input_bytes);
+ PyObject* parsed = PyObject_CallOneArg(json_loads_method, input_bytes);
if (parsed == NULL) {
/* Ignore ValueError as the fuzzer will more than likely
generate some invalid json and values */
PyObject* pattern = compiled_patterns[idx];
PyObject* match_callable = PyObject_GetAttrString(pattern, "match");
- PyObject* matches = _PyObject_CallOneArg(match_callable, to_match);
+ PyObject* matches = PyObject_CallOneArg(match_callable, to_match);
Py_XDECREF(matches);
Py_DECREF(match_callable);
if (codecobj == NULL)
return NULL;
- r = _PyObject_CallOneArg(cofunc, codecobj);
+ r = PyObject_CallOneArg(cofunc, codecobj);
Py_DECREF(codecobj);
return r;
if (cb == NULL)
return NULL;
- r = _PyObject_CallOneArg(cb, exc);
+ r = PyObject_CallOneArg(cb, exc);
Py_DECREF(cb);
return r;
}
_PyObject_ASSERT(op, callback != NULL);
/* copy-paste of weakrefobject.c's handle_callback() */
- temp = _PyObject_CallOneArg(callback, (PyObject *)wr);
+ temp = PyObject_CallOneArg(callback, (PyObject *)wr);
if (temp == NULL)
PyErr_WriteUnraisable(callback);
else
newkey = newvalue;
Py_INCREF(newvalue);
} else {
- newkey = _PyObject_CallOneArg(gbo->keyfunc, newvalue);
+ newkey = PyObject_CallOneArg(gbo->keyfunc, newvalue);
if (newkey == NULL) {
Py_DECREF(newvalue);
return -1;
if (lz->start == 1)
return item;
- good = _PyObject_CallOneArg(lz->func, item);
+ good = PyObject_CallOneArg(lz->func, item);
if (good == NULL) {
Py_DECREF(item);
return NULL;
if (item == NULL)
return NULL;
- good = _PyObject_CallOneArg(lz->func, item);
+ good = PyObject_CallOneArg(lz->func, item);
if (good == NULL) {
Py_DECREF(item);
return NULL;
ok = PyObject_IsTrue(item);
} else {
PyObject *good;
- good = _PyObject_CallOneArg(lz->func, item);
+ good = PyObject_CallOneArg(lz->func, item);
if (good == NULL) {
Py_DECREF(item);
return NULL;
XML_ErrorString(code), lineno, column);
if (buffer == NULL)
return NULL;
- err = _PyObject_CallOneArg(ErrorObject, buffer);
+ err = PyObject_CallOneArg(ErrorObject, buffer);
Py_DECREF(buffer);
if ( err != NULL
&& set_error_attr(err, "code", code)
return NULL;
}
if (meth) {
- result = _PyObject_CallOneArg(meth, key);
+ result = PyObject_CallOneArg(meth, key);
Py_DECREF(meth);
return result;
}
}
/* And call it. */
- result = _PyObject_CallOneArg(meth, format_spec);
+ result = PyObject_CallOneArg(meth, format_spec);
Py_DECREF(meth);
if (result && !PyUnicode_Check(result)) {
return -1;
}
- PyObject *res = _PyObject_CallOneArg(checker, inst);
+ PyObject *res = PyObject_CallOneArg(checker, inst);
_Py_LeaveRecursiveCall(tstate);
Py_DECREF(checker);
Py_DECREF(checker);
return ok;
}
- PyObject *res = _PyObject_CallOneArg(checker, derived);
+ PyObject *res = PyObject_CallOneArg(checker, derived);
_Py_LeaveRecursiveCall(tstate);
Py_DECREF(checker);
if (res != NULL) {
PyObject *
PyByteArray_FromObject(PyObject *input)
{
- return _PyObject_CallOneArg((PyObject *)&PyByteArray_Type, input);
+ return PyObject_CallOneArg((PyObject *)&PyByteArray_Type, input);
}
static PyObject *
{
PyObject *result = _PyBytes_FromHex(string, type == &PyByteArray_Type);
if (type != &PyByteArray_Type && result != NULL) {
- Py_SETREF(result, _PyObject_CallOneArg((PyObject *)type, result));
+ Py_SETREF(result, PyObject_CallOneArg((PyObject *)type, result));
}
return result;
}
{
PyObject *result = _PyBytes_FromHex(string, 0);
if (type != &PyBytes_Type && result != NULL) {
- Py_SETREF(result, _PyObject_CallOneArg((PyObject *)type, result));
+ Py_SETREF(result, PyObject_CallOneArg((PyObject *)type, result));
}
return result;
}
{
assert(callable != NULL);
- /* _PyObject_FastCallDict() must not be called with an exception set,
+ /* PyObject_VectorcallDict() must not be called with an exception set,
because it can clear it (directly or indirectly) and so the
caller loses its exception */
assert(!_PyErr_Occurred(tstate));
assert(nargs == 0 || args != NULL);
assert(kwargs == NULL || PyDict_Check(kwargs));
- vectorcallfunc func = _PyVectorcall_Function(callable);
+ vectorcallfunc func = PyVectorcall_Function(callable);
if (func == NULL) {
/* Use tp_call instead */
return _PyObject_MakeTpCall(tstate, callable, args, nargs, kwargs);
PyObject *
-_PyObject_FastCallDict(PyObject *callable, PyObject *const *args,
+PyObject_VectorcallDict(PyObject *callable, PyObject *const *args,
size_t nargsf, PyObject *kwargs)
{
PyThreadState *tstate = _PyThreadState_GET();
{
PyThreadState *tstate = _PyThreadState_GET();
- /* get vectorcallfunc as in _PyVectorcall_Function, but without
- * the _Py_TPFLAGS_HAVE_VECTORCALL check */
+ /* get vectorcallfunc as in PyVectorcall_Function, but without
+ * the Py_TPFLAGS_HAVE_VECTORCALL check */
Py_ssize_t offset = Py_TYPE(callable)->tp_vectorcall_offset;
if (offset <= 0) {
_PyErr_Format(tstate, PyExc_TypeError,
assert(PyTuple_Check(args));
assert(kwargs == NULL || PyDict_Check(kwargs));
- if (_PyVectorcall_Function(callable) != NULL) {
+ if (PyVectorcall_Function(callable) != NULL) {
return PyVectorcall_Call(callable, args, kwargs);
}
else {
PyObject *
-_PyObject_VectorcallMethod(PyObject *name, PyObject *const *args,
+PyObject_VectorcallMethod(PyObject *name, PyObject *const *args,
size_t nargsf, PyObject *kwnames)
{
assert(name != NULL);
PyObject_GenericSetAttr, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
- _Py_TPFLAGS_HAVE_VECTORCALL, /* tp_flags */
+ Py_TPFLAGS_HAVE_VECTORCALL, /* tp_flags */
method_doc, /* tp_doc */
(traverseproc)method_traverse, /* tp_traverse */
0, /* tp_clear */
if (bound == NULL) {
return NULL;
}
- PyObject *res = _PyObject_FastCallDict(bound, _PyTuple_ITEMS(args)+1,
+ PyObject *res = PyObject_VectorcallDict(bound, _PyTuple_ITEMS(args)+1,
argc-1, kwds);
Py_DECREF(bound);
return res;
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
- _Py_TPFLAGS_HAVE_VECTORCALL |
+ Py_TPFLAGS_HAVE_VECTORCALL |
Py_TPFLAGS_METHOD_DESCRIPTOR, /* tp_flags */
0, /* tp_doc */
descr_traverse, /* tp_traverse */
return NULL;
}
- return _PyObject_CallOneArg(gs->prop_get, obj);
+ return PyObject_CallOneArg(gs->prop_get, obj);
}
static int
return -1;
}
if (value == NULL)
- res = _PyObject_CallOneArg(func, obj);
+ res = PyObject_CallOneArg(func, obj);
else
res = PyObject_CallFunctionObjArgs(func, obj, value, NULL);
if (res == NULL)
_Py_IDENTIFIER(__missing__);
missing = _PyObject_LookupSpecial((PyObject *)mp, &PyId___missing__);
if (missing != NULL) {
- res = _PyObject_CallOneArg(missing, key);
+ res = PyObject_CallOneArg(missing, key);
Py_DECREF(missing);
return res;
}
Py_DECREF(writer);
return -1;
}
- result = _PyObject_CallOneArg(writer, value);
+ result = PyObject_CallOneArg(writer, value);
Py_DECREF(value);
Py_DECREF(writer);
if (result == NULL)
goto parse_error;
result = PyFloat_FromDouble(negate ? -x : x);
if (type != &PyFloat_Type && result != NULL) {
- Py_SETREF(result, _PyObject_CallOneArg((PyObject *)type, result));
+ Py_SETREF(result, PyObject_CallOneArg((PyObject *)type, result));
}
return result;
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
- _Py_TPFLAGS_HAVE_VECTORCALL |
+ Py_TPFLAGS_HAVE_VECTORCALL |
Py_TPFLAGS_METHOD_DESCRIPTOR, /* tp_flags */
func_new__doc__, /* tp_doc */
(traverseproc)func_traverse, /* tp_traverse */
/* Save the current exception, if any. */
PyErr_Fetch(&error_type, &error_value, &error_traceback);
- res = _PyObject_CallOneArg(finalizer, self);
+ res = PyObject_CallOneArg(finalizer, self);
if (res == NULL) {
PyErr_WriteUnraisable(self);
return 0;
}
/* Construct an exception instance manually with
- * _PyObject_CallOneArg and pass it to PyErr_SetObject.
+ * PyObject_CallOneArg and pass it to PyErr_SetObject.
*
* We do this to handle a situation when "value" is a tuple, in which
* case PyErr_SetObject would set the value of StopIteration to
*
* (See PyErr_SetObject/_PyErr_CreateException code for details.)
*/
- e = _PyObject_CallOneArg(PyExc_StopIteration, value);
+ e = PyObject_CallOneArg(PyExc_StopIteration, value);
if (e == NULL) {
return -1;
}
PyObject *res;
Py_INCREF(firstiter);
- res = _PyObject_CallOneArg(firstiter, (PyObject *)o);
+ res = PyObject_CallOneArg(firstiter, (PyObject *)o);
Py_DECREF(firstiter);
if (res == NULL) {
return 1;
}
for (i = 0; i < saved_ob_size ; i++) {
- keys[i] = _PyObject_CallOneArg(keyfunc, saved_ob_item[i]);
+ keys[i] = PyObject_CallOneArg(keyfunc, saved_ob_item[i]);
if (keys[i] == NULL) {
for (i=i-1 ; i>=0 ; i--)
Py_DECREF(keys[i]);
Py_DECREF(bytes);
if (long_obj != NULL && type != &PyLong_Type) {
- Py_SETREF(long_obj, _PyObject_CallOneArg((PyObject *)type, long_obj));
+ Py_SETREF(long_obj, PyObject_CallOneArg((PyObject *)type, long_obj));
}
return long_obj;
if (format == NULL)
goto error;
- structobj = _PyObject_CallOneArg(Struct, format);
+ structobj = PyObject_CallOneArg(Struct, format);
if (structobj == NULL)
goto error;
PyObject *v;
memcpy(x->item, ptr, x->itemsize);
- v = _PyObject_CallOneArg(x->unpack_from, x->mview);
+ v = PyObject_CallOneArg(x->unpack_from, x->mview);
if (v == NULL)
return NULL;
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
- _Py_TPFLAGS_HAVE_VECTORCALL, /* tp_flags */
+ Py_TPFLAGS_HAVE_VECTORCALL, /* tp_flags */
0, /* tp_doc */
(traverseproc)meth_traverse, /* tp_traverse */
0, /* tp_clear */
_Py_IDENTIFIER(__getattr__);
getattr = _PyDict_GetItemId(m->md_dict, &PyId___getattr__);
if (getattr) {
- return _PyObject_CallOneArg(getattr, name);
+ return PyObject_CallOneArg(getattr, name);
}
mod_name = _PyDict_GetItemId(m->md_dict, &PyId___name__);
if (mod_name && PyUnicode_Check(mod_name)) {
call_unbound_noarg(int unbound, PyObject *func, PyObject *self)
{
if (unbound) {
- return _PyObject_CallOneArg(func, self);
+ return PyObject_CallOneArg(func, self);
}
else {
return _PyObject_CallNoArg(func);
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TYPE_SUBCLASS |
- _Py_TPFLAGS_HAVE_VECTORCALL, /* tp_flags */
+ Py_TPFLAGS_HAVE_VECTORCALL, /* tp_flags */
type_doc, /* tp_doc */
(traverseproc)type_traverse, /* tp_traverse */
(inquiry)type_clear, /* tp_clear */
/* tp_hash see tp_richcompare */
{
/* Always inherit tp_vectorcall_offset to support PyVectorcall_Call().
- * If _Py_TPFLAGS_HAVE_VECTORCALL is not inherited, then vectorcall
+ * If Py_TPFLAGS_HAVE_VECTORCALL is not inherited, then vectorcall
* won't be used automatically. */
COPYSLOT(tp_vectorcall_offset);
- /* Inherit _Py_TPFLAGS_HAVE_VECTORCALL for non-heap types
+ /* Inherit Py_TPFLAGS_HAVE_VECTORCALL for non-heap types
* if tp_call is not overridden */
if (!type->tp_call &&
- (base->tp_flags & _Py_TPFLAGS_HAVE_VECTORCALL) &&
+ (base->tp_flags & Py_TPFLAGS_HAVE_VECTORCALL) &&
!(type->tp_flags & Py_TPFLAGS_HEAPTYPE))
{
- type->tp_flags |= _Py_TPFLAGS_HAVE_VECTORCALL;
+ type->tp_flags |= Py_TPFLAGS_HAVE_VECTORCALL;
}
COPYSLOT(tp_call);
}
/* Consistency checks for PEP 590:
* - Py_TPFLAGS_METHOD_DESCRIPTOR requires tp_descr_get
- * - _Py_TPFLAGS_HAVE_VECTORCALL requires tp_call and
+ * - Py_TPFLAGS_HAVE_VECTORCALL requires tp_call and
* tp_vectorcall_offset > 0
* To avoid mistakes, we require this before inheriting.
*/
if (type->tp_flags & Py_TPFLAGS_METHOD_DESCRIPTOR) {
_PyObject_ASSERT((PyObject *)type, type->tp_descr_get != NULL);
}
- if (type->tp_flags & _Py_TPFLAGS_HAVE_VECTORCALL) {
+ if (type->tp_flags & Py_TPFLAGS_HAVE_VECTORCALL) {
_PyObject_ASSERT((PyObject *)type, type->tp_vectorcall_offset > 0);
_PyObject_ASSERT((PyObject *)type, type->tp_call != NULL);
}
else
attr = descr;
}
- res = _PyObject_CallOneArg(attr, name);
+ res = PyObject_CallOneArg(attr, name);
Py_XDECREF(descr);
return res;
}
}
- result = _PyObject_FastCallDict(func, NULL, 0, kwds);
+ result = PyObject_VectorcallDict(func, NULL, 0, kwds);
Py_DECREF(func);
if (result == NULL) {
return -1;
if (*exceptionObject == NULL)
goto onError;
- restuple = _PyObject_CallOneArg(*errorHandler, *exceptionObject);
+ restuple = PyObject_CallOneArg(*errorHandler, *exceptionObject);
if (restuple == NULL)
goto onError;
if (!PyTuple_Check(restuple)) {
if (*exceptionObject == NULL)
goto onError;
- restuple = _PyObject_CallOneArg(*errorHandler, *exceptionObject);
+ restuple = PyObject_CallOneArg(*errorHandler, *exceptionObject);
if (restuple == NULL)
goto onError;
if (!PyTuple_Check(restuple)) {
if (*exceptionObject == NULL)
return NULL;
- restuple = _PyObject_CallOneArg(*errorHandler, *exceptionObject);
+ restuple = PyObject_CallOneArg(*errorHandler, *exceptionObject);
if (restuple == NULL)
return NULL;
if (!PyTuple_Check(restuple)) {
if (*exceptionObject == NULL)
return NULL;
- restuple = _PyObject_CallOneArg(*errorHandler, *exceptionObject);
+ restuple = PyObject_CallOneArg(*errorHandler, *exceptionObject);
if (restuple == NULL)
return NULL;
if (!PyTuple_Check(restuple)) {
static void
handle_callback(PyWeakReference *ref, PyObject *callback)
{
- PyObject *cbresult = _PyObject_CallOneArg(callback, (PyObject *)ref);
+ PyObject *cbresult = PyObject_CallOneArg(callback, (PyObject *)ref);
if (cbresult == NULL)
PyErr_WriteUnraisable(callback);
if (msg == NULL)
goto error;
- res = _PyObject_CallOneArg(show_fn, msg);
+ res = PyObject_CallOneArg(show_fn, msg);
Py_DECREF(show_fn);
Py_DECREF(msg);
}
else {
text = message;
- message = _PyObject_CallOneArg(category, message);
+ message = PyObject_CallOneArg(category, message);
if (message == NULL)
goto cleanup;
}
return NULL;
}
/* Call get_source() to get the source code. */
- source = _PyObject_CallOneArg(get_source, module_name);
+ source = PyObject_CallOneArg(get_source, module_name);
Py_DECREF(get_source);
Py_DECREF(module_name);
if (!source) {
int warned = 0;
PyObject *fn = get_warnings_attr(&PyId__warn_unawaited_coroutine, 1);
if (fn) {
- PyObject *res = _PyObject_CallOneArg(fn, coro);
+ PyObject *res = PyObject_CallOneArg(fn, coro);
Py_DECREF(fn);
if (res || PyErr_ExceptionMatches(PyExc_RuntimeWarning)) {
warned = 1;
}
continue;
}
- new_base = _PyObject_CallOneArg(meth, bases);
+ new_base = PyObject_CallOneArg(meth, bases);
Py_DECREF(meth);
if (!new_base) {
goto error;
}
else {
PyObject *pargs[2] = {name, bases};
- ns = _PyObject_FastCallDict(prep, pargs, 2, mkw);
+ ns = PyObject_VectorcallDict(prep, pargs, 2, mkw);
Py_DECREF(prep);
}
if (ns == NULL) {
}
}
PyObject *margs[3] = {name, bases, ns};
- cls = _PyObject_FastCallDict(meta, margs, 3, mkw);
+ cls = PyObject_VectorcallDict(meta, margs, 3, mkw);
if (cls != NULL && PyType_Check(cls) && PyCell_Check(cell)) {
PyObject *cell_cls = PyCell_GET(cell);
if (cell_cls != cls) {
}
Py_INCREF(hook);
- PyObject *retval = _PyObject_Vectorcall(hook, args, nargs, keywords);
+ PyObject *retval = PyObject_Vectorcall(hook, args, nargs, keywords);
Py_DECREF(hook);
return retval;
}
ok = PyObject_IsTrue(item);
} else {
PyObject *good;
- good = _PyObject_CallOneArg(lz->func, item);
+ good = PyObject_CallOneArg(lz->func, item);
if (good == NULL) {
Py_DECREF(item);
return NULL;
while (( item = PyIter_Next(it) )) {
/* get the value from the key function */
if (keyfunc != NULL) {
- val = _PyObject_CallOneArg(keyfunc, item);
+ val = PyObject_CallOneArg(keyfunc, item);
if (val == NULL)
goto Fail_it_item;
}
if (ndigits == Py_None)
result = _PyObject_CallNoArg(round);
else
- result = _PyObject_CallOneArg(round, ndigits);
+ result = PyObject_CallOneArg(round, ndigits);
Py_DECREF(round);
return result;
}
}
assert(nargs >= 1);
- v = _PyObject_Vectorcall(callable, args + 1, nargs - 1, kwnames);
+ v = PyObject_Vectorcall(callable, args + 1, nargs - 1, kwnames);
Py_DECREF(callable);
if (v == NULL) {
Py_DECREF(newlist);
Py_DECREF(value);
goto error;
}
- res = _PyObject_CallOneArg(hook, value);
+ res = PyObject_CallOneArg(hook, value);
Py_DECREF(value);
if (res == NULL)
goto error;
assert(!PyLong_Check(exc));
exit_func = PEEK(7);
PyObject *stack[4] = {NULL, exc, val, tb};
- res = _PyObject_Vectorcall(exit_func, stack + 1,
+ res = PyObject_Vectorcall(exit_func, stack + 1,
3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
if (res == NULL)
goto error;
{
PyObject *x;
if (PyCFunction_Check(func)) {
- C_TRACE(x, _PyObject_Vectorcall(func, args, nargs, kwnames));
+ C_TRACE(x, PyObject_Vectorcall(func, args, nargs, kwnames));
return x;
}
else if (Py_TYPE(func) == &PyMethodDescr_Type && nargs > 0) {
if (func == NULL) {
return NULL;
}
- C_TRACE(x, _PyObject_Vectorcall(func,
+ C_TRACE(x, PyObject_Vectorcall(func,
args+1, nargs-1,
kwnames));
Py_DECREF(func);
return x;
}
- return _PyObject_Vectorcall(func, args, nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);
+ return PyObject_Vectorcall(func, args, nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);
}
/* Issue #29227: Inline call_function() into _PyEval_EvalFrameDefault()
x = trace_call_function(tstate, func, stack, nargs, kwnames);
}
else {
- x = _PyObject_Vectorcall(func, stack, nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);
+ x = PyObject_Vectorcall(func, stack, nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);
}
assert((x != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
func = PyList_GetItem(interp->codec_search_path, i);
if (func == NULL)
goto onError;
- result = _PyObject_CallOneArg(func, v);
+ result = PyObject_CallOneArg(func, v);
if (result == NULL)
goto onError;
if (result == Py_None) {
if (errors != NULL)
streamcodec = PyObject_CallFunction(codeccls, "Os", stream, errors);
else
- streamcodec = _PyObject_CallOneArg(codeccls, stream);
+ streamcodec = PyObject_CallOneArg(codeccls, stream);
Py_DECREF(codecs);
return streamcodec;
}
return PyObject_Call(exception, value, NULL);
}
else {
- return _PyObject_CallOneArg(exception, value);
+ return PyObject_CallOneArg(exception, value);
}
}
goto done;
}
- error = _PyObject_FastCallDict(exception, &msg, 1, kwargs);
+ error = PyObject_VectorcallDict(exception, &msg, 1, kwargs);
if (error != NULL) {
_PyErr_SetObject(tstate, (PyObject *)Py_TYPE(error), error);
Py_DECREF(error);
goto default_hook;
}
- PyObject *res = _PyObject_CallOneArg(hook, hook_args);
+ PyObject *res = PyObject_CallOneArg(hook, hook_args);
Py_DECREF(hook_args);
if (res != NULL) {
Py_DECREF(res);
PyObject *hook = PyList_GetItem(path_hooks, j);
if (hook == NULL)
return NULL;
- importer = _PyObject_CallOneArg(hook, p);
+ importer = PyObject_CallOneArg(hook, p);
if (importer != NULL)
break;
return NULL;
}
PyMem_RawFree(envar);
- PyObject *retval = _PyObject_Vectorcall(hook, args, nargs, keywords);
+ PyObject *retval = PyObject_Vectorcall(hook, args, nargs, keywords);
Py_DECREF(hook);
return retval;
projects / thirdparty / Python / cpython.git / commitdiff
