Mirrors
/
cpython
mirror of https://github.com/python/cpython
3
0
Fork 0
Code Releases Activity
Browse Source

Backed out changeset 7efddbf1aa70

pull/2/head
Victor Stinner 9 years ago
parent
ebea9988e0
commit
8be1c39eb3
4 changed files with 90 additions and 93 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 40
      Include/abstract.h
  2. 4
      Include/ceval.h
  3. 122
      Objects/abstract.c
  4. 17
      Objects/typeobject.c

40
Include/abstract.h
View File

@ -257,15 +257,15 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
/* Declared elsewhere
PyAPI_FUNC(int) PyCallable_Check(PyObject *obj);
PyAPI_FUNC(int) PyCallable_Check(PyObject *o);
Determine if the object, obj, is callable. Return 1 if the
Determine if the object, o, is callable. Return 1 if the
object is callable and 0 otherwise.
This function always succeeds.
*/
PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *func,
PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable_object,
PyObject *args, PyObject *kwargs);
#ifndef Py_LIMITED_API
@ -344,7 +344,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
_PyObject_FastCall((func), &(arg), 1)
PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend(PyObject *func,
PyObject *arg0, PyObject *args,
PyObject *obj, PyObject *args,
PyObject *kwargs);
PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult(PyObject *func,
@ -353,27 +353,27 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
#endif /* Py_LIMITED_API */
/*
Call a callable Python object, func, with
Call a callable Python object, callable_object, with
arguments and keywords arguments. The 'args' argument can not be
NULL.
*/
PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *func,
PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable_object,
PyObject *args);
/*
Call a callable Python object, func, with
Call a callable Python object, callable_object, with
arguments given by the tuple, args. If no arguments are
needed, then args may be NULL. Returns the result of the
call on success, or NULL on failure. This is the equivalent
of the Python expression: o(*args).
*/
PyAPI_FUNC(PyObject *) PyObject_CallFunction(PyObject *func,
PyAPI_FUNC(PyObject *) PyObject_CallFunction(PyObject *callable_object,
const char *format, ...);
/*
Call a callable Python object, func, with a
Call a callable Python object, callable_object, with a
variable number of C arguments. The C arguments are described
using a mkvalue-style format string. The format may be NULL,
indicating that no arguments are provided. Returns the
@ -382,7 +382,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/
PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *obj,
PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *o,
const char *method,
const char *format, ...);
@ -396,7 +396,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/
#ifndef Py_LIMITED_API
PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *obj,
PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *o,
_Py_Identifier *method,
const char *format, ...);
@ -406,25 +406,25 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/
#endif /* !Py_LIMITED_API */
PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *func,
PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable,
const char *format,
...);
PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *obj,
const char *method,
PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *o,
const char *name,
const char *format,
...);
#ifndef Py_LIMITED_API
PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *obj,
_Py_Identifier *method,
PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *o,
_Py_Identifier *name,
const char *format,
...);
#endif /* !Py_LIMITED_API */
PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *func,
PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *callable,
...);
/*
Call a callable Python object, func, with a
Call a callable Python object, callable_object, with a
variable number of C arguments. The C arguments are provided
as PyObject * values, terminated by a NULL. Returns the
result of the call on success, or NULL on failure. This is
@ -432,10 +432,10 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/
PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs(PyObject *obj,
PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs(PyObject *o,
PyObject *method, ...);
#ifndef Py_LIMITED_API
PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs(PyObject *obj,
PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs(PyObject *o,
struct _Py_Identifier *method,
...);
#endif /* !Py_LIMITED_API */

4
Include/ceval.h
View File

@ -14,10 +14,10 @@ PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(
#define PyEval_CallObject(func,arg) \
PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *func,
PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *obj,
const char *format, ...);
PyAPI_FUNC(PyObject *) PyEval_CallMethod(PyObject *obj,
const char *method,
const char *methodname,
const char *format, ...);
#ifndef Py_LIMITED_API

122
Objects/abstract.c
View File

@ -2173,9 +2173,9 @@ PyMapping_Values(PyObject *o)
/* XXX PyCallable_Check() is in object.c */
PyObject *
PyObject_CallObject(PyObject *func, PyObject *args)
PyObject_CallObject(PyObject *o, PyObject *a)
{
return PyEval_CallObjectWithKeywords(func, args, NULL);
return PyEval_CallObjectWithKeywords(o, a, NULL);
}
PyObject*
@ -2331,10 +2331,10 @@ exit:
return result;
}
/* Positional arguments are arg0 followed args: [arg0, *args]. */
/* Positional arguments are obj followed args. */
PyObject *
_PyObject_Call_Prepend(PyObject *func,
PyObject *arg0, PyObject *args, PyObject *kwargs)
PyObject *obj, PyObject *args, PyObject *kwargs)
{
PyObject *small_stack[8];
PyObject **stack;
@ -2356,7 +2356,7 @@ _PyObject_Call_Prepend(PyObject *func,
}
/* use borrowed references */
stack[0] = arg0;
stack[0] = obj;
memcpy(&stack[1],
&PyTuple_GET_ITEM(args, 0),
argcount * sizeof(PyObject *));
@ -2489,34 +2489,34 @@ _PyObject_FastCallKeywords(PyObject *func, PyObject **stack, Py_ssize_t nargs,
}
static PyObject*
call_function_tail(PyObject *func, PyObject *args)
call_function_tail(PyObject *callable, PyObject *args)
{
PyObject *result;
assert(args != NULL);
if (!PyTuple_Check(args)) {
result = _PyObject_CallArg1(func, args);
result = _PyObject_CallArg1(callable, args);
}
else {
result = PyObject_Call(func, args, NULL);
result = PyObject_Call(callable, args, NULL);
}
return result;
}
PyObject *
PyObject_CallFunction(PyObject *func, const char *format, ...)
PyObject_CallFunction(PyObject *callable, const char *format, ...)
{
va_list va;
PyObject *args, *result;
if (func == NULL) {
if (callable == NULL) {
return null_error();
}
if (!format || !*format) {
return _PyObject_CallNoArg(func);
return _PyObject_CallNoArg(callable);
}
va_start(va, format);
@ -2526,23 +2526,23 @@ PyObject_CallFunction(PyObject *func, const char *format, ...)
return NULL;
}
result = call_function_tail(func, args);
result = call_function_tail(callable, args);
Py_DECREF(args);
return result;
}
PyObject *
_PyObject_CallFunction_SizeT(PyObject *func, const char *format, ...)
_PyObject_CallFunction_SizeT(PyObject *callable, const char *format, ...)
{
va_list va;
PyObject *args, *result;
if (func == NULL) {
if (callable == NULL) {
return null_error();
}
if (!format || !*format) {
return _PyObject_CallNoArg(func);
return _PyObject_CallNoArg(callable);
}
va_start(va, format);
@ -2552,7 +2552,7 @@ _PyObject_CallFunction_SizeT(PyObject *func, const char *format, ...)
return NULL;
}
result = call_function_tail(func, args);
result = call_function_tail(callable, args);
Py_DECREF(args);
return result;
}
@ -2589,20 +2589,19 @@ callmethod(PyObject* func, const char *format, va_list va, int is_size_t)
}
PyObject *
PyObject_CallMethod(PyObject *obj, const char *method, const char *format, ...)
PyObject_CallMethod(PyObject *o, const char *name, const char *format, ...)
{
va_list va;
PyObject *func = NULL;
PyObject *retval = NULL;
if (obj == NULL || method == NULL) {
if (o == NULL || name == NULL) {
return null_error();
}
func = PyObject_GetAttrString(obj, method);
if (func == NULL) {
func = PyObject_GetAttrString(o, name);
if (func == NULL)
return NULL;
}
va_start(va, format);
retval = callmethod(func, format, va, 0);
@ -2612,20 +2611,20 @@ PyObject_CallMethod(PyObject *obj, const char *method, const char *format, ...)
}
PyObject *
_PyObject_CallMethodId(PyObject *obj, _Py_Identifier *method,
_PyObject_CallMethodId(PyObject *o, _Py_Identifier *name,
const char *format, ...)
{
va_list va;
PyObject *func, *retval;
PyObject *func = NULL;
PyObject *retval = NULL;
if (obj == NULL || method == NULL) {
if (o == NULL || name == NULL) {
return null_error();
}
func = _PyObject_GetAttrId(obj, method);
if (func == NULL) {
func = _PyObject_GetAttrId(o, name);
if (func == NULL)
return NULL;
}
va_start(va, format);
retval = callmethod(func, format, va, 0);
@ -2635,21 +2634,20 @@ _PyObject_CallMethodId(PyObject *obj, _Py_Identifier *method,
}
PyObject *
_PyObject_CallMethod_SizeT(PyObject *obj, const char *method,
_PyObject_CallMethod_SizeT(PyObject *o, const char *name,
const char *format, ...)
{
va_list va;
PyObject *func, *retval;
PyObject *func = NULL;
PyObject *retval;
if (obj == NULL || method == NULL) {
if (o == NULL || name == NULL) {
return null_error();
}
func = PyObject_GetAttrString(obj, method);
if (func == NULL) {
func = PyObject_GetAttrString(o, name);
if (func == NULL)
return NULL;
}
va_start(va, format);
retval = callmethod(func, format, va, 1);
va_end(va);
@ -2658,21 +2656,21 @@ _PyObject_CallMethod_SizeT(PyObject *obj, const char *method,
}
PyObject *
_PyObject_CallMethodId_SizeT(PyObject *obj, _Py_Identifier *method,
_PyObject_CallMethodId_SizeT(PyObject *o, _Py_Identifier *name,
const char *format, ...)
{
va_list va;
PyObject *func, *retval;
PyObject *func = NULL;
PyObject *retval;
if (obj == NULL || method == NULL) {
if (o == NULL || name == NULL) {
return null_error();
}
func = _PyObject_GetAttrId(obj, method);
func = _PyObject_GetAttrId(o, name);
if (func == NULL) {
return NULL;
}
va_start(va, format);
retval = callmethod(func, format, va, 1);
va_end(va);
@ -2722,34 +2720,34 @@ objargs_mkstack(PyObject **small_stack, Py_ssize_t small_stack_size,
}
PyObject *
PyObject_CallMethodObjArgs(PyObject *obj, PyObject *method, ...)
PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...)
{
PyObject *small_stack[5];
PyObject **stack;
Py_ssize_t nargs;
PyObject *func, *result;
PyObject *result;
va_list vargs;
if (obj == NULL || method == NULL) {
if (callable == NULL || name == NULL) {
return null_error();
}
func = PyObject_GetAttr(obj, method);
if (func == NULL)
callable = PyObject_GetAttr(callable, name);
if (callable == NULL)
return NULL;
/* count the args */
va_start(vargs, method);
va_start(vargs, name);
stack = objargs_mkstack(small_stack, Py_ARRAY_LENGTH(small_stack),
vargs, &nargs);
va_end(vargs);
if (stack == NULL) {
Py_DECREF(func);
Py_DECREF(callable);
return NULL;
}
result = _PyObject_FastCall(func, stack, nargs);
Py_DECREF(func);
result = _PyObject_FastCall(callable, stack, nargs);
Py_DECREF(callable);
if (stack != small_stack) {
PyMem_Free(stack);
}
@ -2758,35 +2756,35 @@ PyObject_CallMethodObjArgs(PyObject *obj, PyObject *method, ...)
}
PyObject *
_PyObject_CallMethodIdObjArgs(PyObject *obj,
struct _Py_Identifier *method, ...)
_PyObject_CallMethodIdObjArgs(PyObject *callable,
struct _Py_Identifier *name, ...)
{
PyObject *small_stack[5];
PyObject **stack;
Py_ssize_t nargs;
PyObject *func, *result;
PyObject *result;
va_list vargs;
if (obj == NULL || method == NULL) {
if (callable == NULL || name == NULL) {
return null_error();
}
func = _PyObject_GetAttrId(obj, method);
if (func == NULL)
callable = _PyObject_GetAttrId(callable, name);
if (callable == NULL)
return NULL;
/* count the args */
va_start(vargs, method);
va_start(vargs, name);
stack = objargs_mkstack(small_stack, Py_ARRAY_LENGTH(small_stack),
vargs, &nargs);
va_end(vargs);
if (stack == NULL) {
Py_DECREF(func);
Py_DECREF(callable);
return NULL;
}
result = _PyObject_FastCall(func, stack, nargs);
Py_DECREF(func);
result = _PyObject_FastCall(callable, stack, nargs);
Py_DECREF(callable);
if (stack != small_stack) {
PyMem_Free(stack);
}
@ -2795,7 +2793,7 @@ _PyObject_CallMethodIdObjArgs(PyObject *obj,
}
PyObject *
PyObject_CallFunctionObjArgs(PyObject *func, ...)
PyObject_CallFunctionObjArgs(PyObject *callable, ...)
{
PyObject *small_stack[5];
PyObject **stack;
@ -2803,12 +2801,12 @@ PyObject_CallFunctionObjArgs(PyObject *func, ...)
PyObject *result;
va_list vargs;
if (func == NULL) {
if (callable == NULL) {
return null_error();
}
/* count the args */
va_start(vargs, func);
va_start(vargs, callable);
stack = objargs_mkstack(small_stack, Py_ARRAY_LENGTH(small_stack),
vargs, &nargs);
va_end(vargs);
@ -2816,7 +2814,7 @@ PyObject_CallFunctionObjArgs(PyObject *func, ...)
return NULL;
}
result = _PyObject_FastCall(func, stack, nargs);
result = _PyObject_FastCall(callable, stack, nargs);
if (stack != small_stack) {
PyMem_Free(stack);
}

17
Objects/typeobject.c
View File

@ -1425,16 +1425,15 @@ _PyObject_LookupSpecial(PyObject *self, _Py_Identifier *attrid)
as lookup_method to cache the interned name string object. */
static PyObject *
call_method(PyObject *obj, _Py_Identifier *method, const char *format, ...)
call_method(PyObject *o, _Py_Identifier *nameid, const char *format, ...)
{
va_list va;
PyObject *func, *retval;
PyObject *func = NULL, *retval;
func = lookup_maybe(obj, method);
func = lookup_maybe(o, nameid);
if (func == NULL) {
if (!PyErr_Occurred()) {
PyErr_SetObject(PyExc_AttributeError, method->object);
}
if (!PyErr_Occurred())
PyErr_SetObject(PyExc_AttributeError, nameid->object);
return NULL;
}
@ -1466,12 +1465,12 @@ call_method(PyObject *obj, _Py_Identifier *method, const char *format, ...)
/* Clone of call_method() that returns NotImplemented when the lookup fails. */
static PyObject *
call_maybe(PyObject *obj, _Py_Identifier *method, const char *format, ...)
call_maybe(PyObject *o, _Py_Identifier *nameid, const char *format, ...)
{
va_list va;
PyObject *func, *retval;
PyObject *func = NULL, *retval;
func = lookup_maybe(obj, method);
func = lookup_maybe(o, nameid);
if (func == NULL) {
if (!PyErr_Occurred())
Py_RETURN_NOTIMPLEMENTED;

Write Preview
Loading…
Cancel
Save