← Back to branch summary

~ubuntu-branches/ubuntu/natty/python3.1/natty-security

« back to all changes in this revision

Viewing changes to Objects/methodobject.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2010-07-06 16:52:42 UTC
  • mfrom: (1.2.1 upstream) (2.1.11 sid)
  • Revision ID: james.westby@ubuntu.com-20100706165242-2xv4i019r3et6c0j
Tags: 3.1.2+20100706-1ubuntu1
* Merge with Debian; remaining changes:
  - Regenerate the control file.
  - Add debian/patches/overwrite-semaphore-check for Lucid buildds.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Objects/methodobject.c
16
16
PyObject *
17
17
PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module)
18
18
{
19
 
        PyCFunctionObject *op;
20
 
        op = free_list;
21
 
        if (op != NULL) {
22
 
                free_list = (PyCFunctionObject *)(op->m_self);
23
 
                PyObject_INIT(op, &PyCFunction_Type);
24
 
                numfree--;
25
 
        }
26
 
        else {
27
 
                op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
28
 
                if (op == NULL)
29
 
                        return NULL;
30
 
        }
31
 
        op->m_ml = ml;
32
 
        Py_XINCREF(self);
33
 
        op->m_self = self;
34
 
        Py_XINCREF(module);
35
 
        op->m_module = module;
36
 
        _PyObject_GC_TRACK(op);
37
 
        return (PyObject *)op;
 
19
    PyCFunctionObject *op;
 
20
    op = free_list;
 
21
    if (op != NULL) {
 
22
        free_list = (PyCFunctionObject *)(op->m_self);
 
23
        PyObject_INIT(op, &PyCFunction_Type);
 
24
        numfree--;
 
25
    }
 
26
    else {
 
27
        op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
 
28
        if (op == NULL)
 
29
            return NULL;
 
30
    }
 
31
    op->m_ml = ml;
 
32
    Py_XINCREF(self);
 
33
    op->m_self = self;
 
34
    Py_XINCREF(module);
 
35
    op->m_module = module;
 
36
    _PyObject_GC_TRACK(op);
 
37
    return (PyObject *)op;
38
38
}
39
39
 
40
40
PyCFunction
41
41
PyCFunction_GetFunction(PyObject *op)
42
42
{
43
 
        if (!PyCFunction_Check(op)) {
44
 
                PyErr_BadInternalCall();
45
 
                return NULL;
46
 
        }
47
 
        return ((PyCFunctionObject *)op) -> m_ml -> ml_meth;
 
43
    if (!PyCFunction_Check(op)) {
 
44
        PyErr_BadInternalCall();
 
45
        return NULL;
 
46
    }
 
47
    return ((PyCFunctionObject *)op) -> m_ml -> ml_meth;
48
48
}
49
49
 
50
50
PyObject *
51
51
PyCFunction_GetSelf(PyObject *op)
52
52
{
53
 
        if (!PyCFunction_Check(op)) {
54
 
                PyErr_BadInternalCall();
55
 
                return NULL;
56
 
        }
57
 
        return ((PyCFunctionObject *)op) -> m_self;
 
53
    if (!PyCFunction_Check(op)) {
 
54
        PyErr_BadInternalCall();
 
55
        return NULL;
 
56
    }
 
57
    return ((PyCFunctionObject *)op) -> m_self;
58
58
}
59
59
 
60
60
int
61
61
PyCFunction_GetFlags(PyObject *op)
62
62
{
63
 
        if (!PyCFunction_Check(op)) {
64
 
                PyErr_BadInternalCall();
65
 
                return -1;
66
 
        }
67
 
        return ((PyCFunctionObject *)op) -> m_ml -> ml_flags;
 
63
    if (!PyCFunction_Check(op)) {
 
64
        PyErr_BadInternalCall();
 
65
        return -1;
 
66
    }
 
67
    return ((PyCFunctionObject *)op) -> m_ml -> ml_flags;
68
68
}
69
69
 
70
70
PyObject *
71
71
PyCFunction_Call(PyObject *func, PyObject *arg, PyObject *kw)
72
72
{
73
 
        PyCFunctionObject* f = (PyCFunctionObject*)func;
74
 
        PyCFunction meth = PyCFunction_GET_FUNCTION(func);
75
 
        PyObject *self = PyCFunction_GET_SELF(func);
76
 
        Py_ssize_t size;
77
 
 
78
 
        switch (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)) {
79
 
        case METH_VARARGS:
80
 
                if (kw == NULL || PyDict_Size(kw) == 0)
81
 
                        return (*meth)(self, arg);
82
 
                break;
83
 
        case METH_VARARGS | METH_KEYWORDS:
84
 
                return (*(PyCFunctionWithKeywords)meth)(self, arg, kw);
85
 
        case METH_NOARGS:
86
 
                if (kw == NULL || PyDict_Size(kw) == 0) {
87
 
                        size = PyTuple_GET_SIZE(arg);
88
 
                        if (size == 0)
89
 
                                return (*meth)(self, NULL);
90
 
                        PyErr_Format(PyExc_TypeError,
91
 
                            "%.200s() takes no arguments (%zd given)",
92
 
                            f->m_ml->ml_name, size);
93
 
                        return NULL;
94
 
                }
95
 
                break;
96
 
        case METH_O:
97
 
                if (kw == NULL || PyDict_Size(kw) == 0) {
98
 
                        size = PyTuple_GET_SIZE(arg);
99
 
                        if (size == 1)
100
 
                                return (*meth)(self, PyTuple_GET_ITEM(arg, 0));
101
 
                        PyErr_Format(PyExc_TypeError,
102
 
                            "%.200s() takes exactly one argument (%zd given)",
103
 
                            f->m_ml->ml_name, size);
104
 
                        return NULL;
105
 
                }
106
 
                break;
107
 
        default:
108
 
                PyErr_SetString(PyExc_SystemError, "Bad call flags in "
109
 
                                "PyCFunction_Call. METH_OLDARGS is no "
110
 
                                "longer supported!");
111
 
                        
112
 
                return NULL;
113
 
        }
114
 
        PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
115
 
                     f->m_ml->ml_name);
116
 
        return NULL;
 
73
    PyCFunctionObject* f = (PyCFunctionObject*)func;
 
74
    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
 
75
    PyObject *self = PyCFunction_GET_SELF(func);
 
76
    Py_ssize_t size;
 
77
 
 
78
    switch (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)) {
 
79
    case METH_VARARGS:
 
80
        if (kw == NULL || PyDict_Size(kw) == 0)
 
81
            return (*meth)(self, arg);
 
82
        break;
 
83
    case METH_VARARGS | METH_KEYWORDS:
 
84
        return (*(PyCFunctionWithKeywords)meth)(self, arg, kw);
 
85
    case METH_NOARGS:
 
86
        if (kw == NULL || PyDict_Size(kw) == 0) {
 
87
            size = PyTuple_GET_SIZE(arg);
 
88
            if (size == 0)
 
89
                return (*meth)(self, NULL);
 
90
            PyErr_Format(PyExc_TypeError,
 
91
                "%.200s() takes no arguments (%zd given)",
 
92
                f->m_ml->ml_name, size);
 
93
            return NULL;
 
94
        }
 
95
        break;
 
96
    case METH_O:
 
97
        if (kw == NULL || PyDict_Size(kw) == 0) {
 
98
            size = PyTuple_GET_SIZE(arg);
 
99
            if (size == 1)
 
100
                return (*meth)(self, PyTuple_GET_ITEM(arg, 0));
 
101
            PyErr_Format(PyExc_TypeError,
 
102
                "%.200s() takes exactly one argument (%zd given)",
 
103
                f->m_ml->ml_name, size);
 
104
            return NULL;
 
105
        }
 
106
        break;
 
107
    default:
 
108
        PyErr_SetString(PyExc_SystemError, "Bad call flags in "
 
109
                        "PyCFunction_Call. METH_OLDARGS is no "
 
110
                        "longer supported!");
 
111
 
 
112
        return NULL;
 
113
    }
 
114
    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
 
115
                 f->m_ml->ml_name);
 
116
    return NULL;
117
117
}
118
118
 
119
119
/* Methods (the standard built-in methods, that is) */
121
121
static void
122
122
meth_dealloc(PyCFunctionObject *m)
123
123
{
124
 
        _PyObject_GC_UNTRACK(m);
125
 
        Py_XDECREF(m->m_self);
126
 
        Py_XDECREF(m->m_module);
127
 
        if (numfree < PyCFunction_MAXFREELIST) {
128
 
                m->m_self = (PyObject *)free_list;
129
 
                free_list = m;
130
 
                numfree++;
131
 
        }
132
 
        else {
133
 
                PyObject_GC_Del(m);
134
 
        }
 
124
    _PyObject_GC_UNTRACK(m);
 
125
    Py_XDECREF(m->m_self);
 
126
    Py_XDECREF(m->m_module);
 
127
    if (numfree < PyCFunction_MAXFREELIST) {
 
128
        m->m_self = (PyObject *)free_list;
 
129
        free_list = m;
 
130
        numfree++;
 
131
    }
 
132
    else {
 
133
        PyObject_GC_Del(m);
 
134
    }
135
135
}
136
136
 
137
137
static PyObject *
138
138
meth_get__doc__(PyCFunctionObject *m, void *closure)
139
139
{
140
 
        const char *doc = m->m_ml->ml_doc;
 
140
    const char *doc = m->m_ml->ml_doc;
141
141
 
142
 
        if (doc != NULL)
143
 
                return PyUnicode_FromString(doc);
144
 
        Py_INCREF(Py_None);
145
 
        return Py_None;
 
142
    if (doc != NULL)
 
143
        return PyUnicode_FromString(doc);
 
144
    Py_INCREF(Py_None);
 
145
    return Py_None;
146
146
}
147
147
 
148
148
static PyObject *
149
149
meth_get__name__(PyCFunctionObject *m, void *closure)
150
150
{
151
 
        return PyUnicode_FromString(m->m_ml->ml_name);
 
151
    return PyUnicode_FromString(m->m_ml->ml_name);
152
152
}
153
153
 
154
154
static int
155
155
meth_traverse(PyCFunctionObject *m, visitproc visit, void *arg)
156
156
{
157
 
        Py_VISIT(m->m_self);
158
 
        Py_VISIT(m->m_module);
159
 
        return 0;
 
157
    Py_VISIT(m->m_self);
 
158
    Py_VISIT(m->m_module);
 
159
    return 0;
160
160
}
161
161
 
162
162
static PyObject *
163
163
meth_get__self__(PyCFunctionObject *m, void *closure)
164
164
{
165
 
        PyObject *self;
 
165
    PyObject *self;
166
166
 
167
 
        self = m->m_self;
168
 
        if (self == NULL)
169
 
                self = Py_None;
170
 
        Py_INCREF(self);
171
 
        return self;
 
167
    self = m->m_self;
 
168
    if (self == NULL)
 
169
        self = Py_None;
 
170
    Py_INCREF(self);
 
171
    return self;
172
172
}
173
173
 
174
174
static PyGetSetDef meth_getsets [] = {
175
 
        {"__doc__",  (getter)meth_get__doc__,  NULL, NULL},
176
 
        {"__name__", (getter)meth_get__name__, NULL, NULL},
177
 
        {"__self__", (getter)meth_get__self__, NULL, NULL},
178
 
        {0}
 
175
    {"__doc__",  (getter)meth_get__doc__,  NULL, NULL},
 
176
    {"__name__", (getter)meth_get__name__, NULL, NULL},
 
177
    {"__self__", (getter)meth_get__self__, NULL, NULL},
 
178
    {0}
179
179
};
180
180
 
181
181
#define OFF(x) offsetof(PyCFunctionObject, x)
182
182
 
183
183
static PyMemberDef meth_members[] = {
184
 
        {"__module__",    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
185
 
        {NULL}
 
184
    {"__module__",    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
 
185
    {NULL}
186
186
};
187
187
 
188
188
static PyObject *
189
189
meth_repr(PyCFunctionObject *m)
190
190
{
191
 
        if (m->m_self == NULL || PyModule_Check(m->m_self))
192
 
                return PyUnicode_FromFormat("<built-in function %s>",
193
 
                                           m->m_ml->ml_name);
194
 
        return PyUnicode_FromFormat("<built-in method %s of %s object at %p>",
195
 
                                   m->m_ml->ml_name,
196
 
                                   m->m_self->ob_type->tp_name,
197
 
                                   m->m_self);
 
191
    if (m->m_self == NULL || PyModule_Check(m->m_self))
 
192
        return PyUnicode_FromFormat("<built-in function %s>",
 
193
                                   m->m_ml->ml_name);
 
194
    return PyUnicode_FromFormat("<built-in method %s of %s object at %p>",
 
195
                               m->m_ml->ml_name,
 
196
                               m->m_self->ob_type->tp_name,
 
197
                               m->m_self);
198
198
}
199
199
 
200
200
static PyObject *
201
201
meth_richcompare(PyObject *self, PyObject *other, int op)
202
202
{
203
 
        PyCFunctionObject *a, *b;
204
 
        PyObject *res;
205
 
        int eq;
 
203
    PyCFunctionObject *a, *b;
 
204
    PyObject *res;
 
205
    int eq;
206
206
 
207
 
        if ((op != Py_EQ && op != Py_NE) ||
208
 
            !PyCFunction_Check(self) ||
209
 
            !PyCFunction_Check(other))
210
 
        {
211
 
                Py_INCREF(Py_NotImplemented);
212
 
                return Py_NotImplemented;
213
 
        }
214
 
        a = (PyCFunctionObject *)self;
215
 
        b = (PyCFunctionObject *)other;
216
 
        eq = a->m_self == b->m_self;
217
 
        if (eq)
218
 
                eq = a->m_ml->ml_meth == b->m_ml->ml_meth;
219
 
        if (op == Py_EQ)
220
 
                res = eq ? Py_True : Py_False;
221
 
        else
222
 
                res = eq ? Py_False : Py_True;
223
 
        Py_INCREF(res);
224
 
        return res;
 
207
    if ((op != Py_EQ && op != Py_NE) ||
 
208
        !PyCFunction_Check(self) ||
 
209
        !PyCFunction_Check(other))
 
210
    {
 
211
        Py_INCREF(Py_NotImplemented);
 
212
        return Py_NotImplemented;
 
213
    }
 
214
    a = (PyCFunctionObject *)self;
 
215
    b = (PyCFunctionObject *)other;
 
216
    eq = a->m_self == b->m_self;
 
217
    if (eq)
 
218
        eq = a->m_ml->ml_meth == b->m_ml->ml_meth;
 
219
    if (op == Py_EQ)
 
220
        res = eq ? Py_True : Py_False;
 
221
    else
 
222
        res = eq ? Py_False : Py_True;
 
223
    Py_INCREF(res);
 
224
    return res;
225
225
}
226
226
 
227
227
static long
228
228
meth_hash(PyCFunctionObject *a)
229
229
{
230
 
        long x,y;
231
 
        if (a->m_self == NULL)
232
 
                x = 0;
233
 
        else {
234
 
                x = PyObject_Hash(a->m_self);
235
 
                if (x == -1)
236
 
                        return -1;
237
 
        }
238
 
        y = _Py_HashPointer((void*)(a->m_ml->ml_meth));
239
 
        if (y == -1)
240
 
                return -1;
241
 
        x ^= y;
242
 
        if (x == -1)
243
 
                x = -2;
244
 
        return x;
 
230
    long x,y;
 
231
    if (a->m_self == NULL)
 
232
        x = 0;
 
233
    else {
 
234
        x = PyObject_Hash(a->m_self);
 
235
        if (x == -1)
 
236
            return -1;
 
237
    }
 
238
    y = _Py_HashPointer((void*)(a->m_ml->ml_meth));
 
239
    if (y == -1)
 
240
        return -1;
 
241
    x ^= y;
 
242
    if (x == -1)
 
243
        x = -2;
 
244
    return x;
245
245
}
246
246
 
247
247
 
248
248
PyTypeObject PyCFunction_Type = {
249
 
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
250
 
        "builtin_function_or_method",
251
 
        sizeof(PyCFunctionObject),
252
 
        0,
253
 
        (destructor)meth_dealloc,               /* tp_dealloc */
254
 
        0,                                      /* tp_print */
255
 
        0,                                      /* tp_getattr */
256
 
        0,                                      /* tp_setattr */
257
 
        0,                                      /* tp_reserved */
258
 
        (reprfunc)meth_repr,                    /* tp_repr */
259
 
        0,                                      /* tp_as_number */
260
 
        0,                                      /* tp_as_sequence */
261
 
        0,                                      /* tp_as_mapping */
262
 
        (hashfunc)meth_hash,                    /* tp_hash */
263
 
        PyCFunction_Call,                       /* tp_call */
264
 
        0,                                      /* tp_str */
265
 
        PyObject_GenericGetAttr,                /* tp_getattro */
266
 
        0,                                      /* tp_setattro */
267
 
        0,                                      /* tp_as_buffer */
268
 
        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
269
 
        0,                                      /* tp_doc */
270
 
        (traverseproc)meth_traverse,            /* tp_traverse */
271
 
        0,                                      /* tp_clear */
272
 
        meth_richcompare,                       /* tp_richcompare */
273
 
        0,                                      /* tp_weaklistoffset */
274
 
        0,                                      /* tp_iter */
275
 
        0,                                      /* tp_iternext */
276
 
        0,                                      /* tp_methods */
277
 
        meth_members,                           /* tp_members */
278
 
        meth_getsets,                           /* tp_getset */
279
 
        0,                                      /* tp_base */
280
 
        0,                                      /* tp_dict */
 
249
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
 
250
    "builtin_function_or_method",
 
251
    sizeof(PyCFunctionObject),
 
252
    0,
 
253
    (destructor)meth_dealloc,                   /* tp_dealloc */
 
254
    0,                                          /* tp_print */
 
255
    0,                                          /* tp_getattr */
 
256
    0,                                          /* tp_setattr */
 
257
    0,                                          /* tp_reserved */
 
258
    (reprfunc)meth_repr,                        /* tp_repr */
 
259
    0,                                          /* tp_as_number */
 
260
    0,                                          /* tp_as_sequence */
 
261
    0,                                          /* tp_as_mapping */
 
262
    (hashfunc)meth_hash,                        /* tp_hash */
 
263
    PyCFunction_Call,                           /* tp_call */
 
264
    0,                                          /* tp_str */
 
265
    PyObject_GenericGetAttr,                    /* tp_getattro */
 
266
    0,                                          /* tp_setattro */
 
267
    0,                                          /* tp_as_buffer */
 
268
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
 
269
    0,                                          /* tp_doc */
 
270
    (traverseproc)meth_traverse,                /* tp_traverse */
 
271
    0,                                          /* tp_clear */
 
272
    meth_richcompare,                           /* tp_richcompare */
 
273
    0,                                          /* tp_weaklistoffset */
 
274
    0,                                          /* tp_iter */
 
275
    0,                                          /* tp_iternext */
 
276
    0,                                          /* tp_methods */
 
277
    meth_members,                               /* tp_members */
 
278
    meth_getsets,                               /* tp_getset */
 
279
    0,                                          /* tp_base */
 
280
    0,                                          /* tp_dict */
281
281
};
282
282
 
283
283
/* Clear out the free list */
285
285
int
286
286
PyCFunction_ClearFreeList(void)
287
287
{
288
 
        int freelist_size = numfree;
289
 
        
290
 
        while (free_list) {
291
 
                PyCFunctionObject *v = free_list;
292
 
                free_list = (PyCFunctionObject *)(v->m_self);
293
 
                PyObject_GC_Del(v);
294
 
                numfree--;
295
 
        }
296
 
        assert(numfree == 0);
297
 
        return freelist_size;
 
288
    int freelist_size = numfree;
 
289
 
 
290
    while (free_list) {
 
291
        PyCFunctionObject *v = free_list;
 
292
        free_list = (PyCFunctionObject *)(v->m_self);
 
293
        PyObject_GC_Del(v);
 
294
        numfree--;
 
295
    }
 
296
    assert(numfree == 0);
 
297
    return freelist_size;
298
298
}
299
299
 
300
300
void
301
301
PyCFunction_Fini(void)
302
302
{
303
 
        (void)PyCFunction_ClearFreeList();
 
303
    (void)PyCFunction_ClearFreeList();
304
304
}
305
305
 
306
306
/* PyCFunction_New() is now just a macro that calls PyCFunction_NewEx(),
314
314
PyObject *
315
315
PyCFunction_New(PyMethodDef *ml, PyObject *self)
316
316
{
317
 
        return PyCFunction_NewEx(ml, self, NULL);
 
317
    return PyCFunction_NewEx(ml, self, NULL);
318
318
}