Ignore:
Timestamp:
Mar 19, 2014, 11:11:30 AM (11 years ago)
Author:
dmik
Message:

python: Update vendor to 2.7.6.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • python/vendor/current/Objects/funcobject.c

    r2 r388  
    1010PyFunction_New(PyObject *code, PyObject *globals)
    1111{
    12         PyFunctionObject *op = PyObject_GC_New(PyFunctionObject,
    13                                             &PyFunction_Type);
    14         static PyObject *__name__ = 0;
    15         if (op != NULL) {
    16                 PyObject *doc;
    17                 PyObject *consts;
    18                 PyObject *module;
    19                 op->func_weakreflist = NULL;
    20                 Py_INCREF(code);
    21                 op->func_code = code;
    22                 Py_INCREF(globals);
    23                 op->func_globals = globals;
    24                 op->func_name = ((PyCodeObject *)code)->co_name;
    25                 Py_INCREF(op->func_name);
    26                 op->func_defaults = NULL; /* No default arguments */
    27                 op->func_closure = NULL;
    28                 consts = ((PyCodeObject *)code)->co_consts;
    29                 if (PyTuple_Size(consts) >= 1) {
    30                         doc = PyTuple_GetItem(consts, 0);
    31                         if (!PyString_Check(doc) && !PyUnicode_Check(doc))
    32                                 doc = Py_None;
    33                 }
    34                 else
    35                         doc = Py_None;
    36                 Py_INCREF(doc);
    37                 op->func_doc = doc;
    38                 op->func_dict = NULL;
    39                 op->func_module = NULL;
    40 
    41                 /* __module__: If module name is in globals, use it.
    42                    Otherwise, use None.
    43                 */
    44                 if (!__name__) {
    45                         __name__ = PyString_InternFromString("__name__");
    46                         if (!__name__) {
    47                                 Py_DECREF(op);
    48                                 return NULL;
    49                         }
    50                 }
    51                 module = PyDict_GetItem(globals, __name__);
    52                 if (module) {
    53                     Py_INCREF(module);
    54                     op->func_module = module;
    55                 }
    56         }
    57         else
    58                 return NULL;
    59         _PyObject_GC_TRACK(op);
    60         return (PyObject *)op;
     12    PyFunctionObject *op = PyObject_GC_New(PyFunctionObject,
     13                                        &PyFunction_Type);
     14    static PyObject *__name__ = 0;
     15    if (op != NULL) {
     16        PyObject *doc;
     17        PyObject *consts;
     18        PyObject *module;
     19        op->func_weakreflist = NULL;
     20        Py_INCREF(code);
     21        op->func_code = code;
     22        Py_INCREF(globals);
     23        op->func_globals = globals;
     24        op->func_name = ((PyCodeObject *)code)->co_name;
     25        Py_INCREF(op->func_name);
     26        op->func_defaults = NULL; /* No default arguments */
     27        op->func_closure = NULL;
     28        consts = ((PyCodeObject *)code)->co_consts;
     29        if (PyTuple_Size(consts) >= 1) {
     30            doc = PyTuple_GetItem(consts, 0);
     31            if (!PyString_Check(doc) && !PyUnicode_Check(doc))
     32                doc = Py_None;
     33        }
     34        else
     35            doc = Py_None;
     36        Py_INCREF(doc);
     37        op->func_doc = doc;
     38        op->func_dict = NULL;
     39        op->func_module = NULL;
     40
     41        /* __module__: If module name is in globals, use it.
     42           Otherwise, use None.
     43        */
     44        if (!__name__) {
     45            __name__ = PyString_InternFromString("__name__");
     46            if (!__name__) {
     47                Py_DECREF(op);
     48                return NULL;
     49            }
     50        }
     51        module = PyDict_GetItem(globals, __name__);
     52        if (module) {
     53            Py_INCREF(module);
     54            op->func_module = module;
     55        }
     56    }
     57    else
     58        return NULL;
     59    _PyObject_GC_TRACK(op);
     60    return (PyObject *)op;
    6161}
    6262
    … …  
    6464PyFunction_GetCode(PyObject *op)
    6565{
    66         if (!PyFunction_Check(op)) {
    67                 PyErr_BadInternalCall();
    68                 return NULL;
    69         }
    70         return ((PyFunctionObject *) op) -> func_code;
     66    if (!PyFunction_Check(op)) {
     67        PyErr_BadInternalCall();
     68        return NULL;
     69    }
     70    return ((PyFunctionObject *) op) -> func_code;
    7171}
    7272
    … …  
    7474PyFunction_GetGlobals(PyObject *op)
    7575{
    76         if (!PyFunction_Check(op)) {
    77                 PyErr_BadInternalCall();
    78                 return NULL;
    79         }
    80         return ((PyFunctionObject *) op) -> func_globals;
     76    if (!PyFunction_Check(op)) {
     77        PyErr_BadInternalCall();
     78        return NULL;
     79    }
     80    return ((PyFunctionObject *) op) -> func_globals;
    8181}
    8282
    … …  
    8484PyFunction_GetModule(PyObject *op)
    8585{
    86         if (!PyFunction_Check(op)) {
    87                 PyErr_BadInternalCall();
    88                 return NULL;
    89         }
    90         return ((PyFunctionObject *) op) -> func_module;
     86    if (!PyFunction_Check(op)) {
     87        PyErr_BadInternalCall();
     88        return NULL;
     89    }
     90    return ((PyFunctionObject *) op) -> func_module;
    9191}
    9292
    … …  
    9494PyFunction_GetDefaults(PyObject *op)
    9595{
    96         if (!PyFunction_Check(op)) {
    97                 PyErr_BadInternalCall();
    98                 return NULL;
    99         }
    100         return ((PyFunctionObject *) op) -> func_defaults;
     96    if (!PyFunction_Check(op)) {
     97        PyErr_BadInternalCall();
     98        return NULL;
     99    }
     100    return ((PyFunctionObject *) op) -> func_defaults;
    101101}
    102102
    … …  
    104104PyFunction_SetDefaults(PyObject *op, PyObject *defaults)
    105105{
    106         if (!PyFunction_Check(op)) {
    107                 PyErr_BadInternalCall();
    108                 return -1;
    109         }
    110         if (defaults == Py_None)
    111                 defaults = NULL;
    112         else if (defaults && PyTuple_Check(defaults)) {
    113                 Py_INCREF(defaults);
    114         }
    115         else {
    116                 PyErr_SetString(PyExc_SystemError, "non-tuple default args");
    117                 return -1;
    118         }
    119         Py_XDECREF(((PyFunctionObject *) op) -> func_defaults);
    120         ((PyFunctionObject *) op) -> func_defaults = defaults;
    121         return 0;
     106    if (!PyFunction_Check(op)) {
     107        PyErr_BadInternalCall();
     108        return -1;
     109    }
     110    if (defaults == Py_None)
     111        defaults = NULL;
     112    else if (defaults && PyTuple_Check(defaults)) {
     113        Py_INCREF(defaults);
     114    }
     115    else {
     116        PyErr_SetString(PyExc_SystemError, "non-tuple default args");
     117        return -1;
     118    }
     119    Py_XDECREF(((PyFunctionObject *) op) -> func_defaults);
     120    ((PyFunctionObject *) op) -> func_defaults = defaults;
     121    return 0;
    122122}
    123123
    … …  
    125125PyFunction_GetClosure(PyObject *op)
    126126{
    127         if (!PyFunction_Check(op)) {
    128                 PyErr_BadInternalCall();
    129                 return NULL;
    130         }
    131         return ((PyFunctionObject *) op) -> func_closure;
     127    if (!PyFunction_Check(op)) {
     128        PyErr_BadInternalCall();
     129        return NULL;
     130    }
     131    return ((PyFunctionObject *) op) -> func_closure;
    132132}
    133133
    … …  
    135135PyFunction_SetClosure(PyObject *op, PyObject *closure)
    136136{
    137         if (!PyFunction_Check(op)) {
    138                 PyErr_BadInternalCall();
    139                 return -1;
    140         }
    141         if (closure == Py_None)
    142                 closure = NULL;
    143         else if (PyTuple_Check(closure)) {
    144                 Py_INCREF(closure);
    145         }
    146         else {
    147                 PyErr_Format(PyExc_SystemError,
    148                              "expected tuple for closure, got '%.100s'",
    149                              closure->ob_type->tp_name);
    150                 return -1;
    151         }
    152         Py_XDECREF(((PyFunctionObject *) op) -> func_closure);
    153         ((PyFunctionObject *) op) -> func_closure = closure;
    154         return 0;
     137    if (!PyFunction_Check(op)) {
     138        PyErr_BadInternalCall();
     139        return -1;
     140    }
     141    if (closure == Py_None)
     142        closure = NULL;
     143    else if (PyTuple_Check(closure)) {
     144        Py_INCREF(closure);
     145    }
     146    else {
     147        PyErr_Format(PyExc_SystemError,
     148                     "expected tuple for closure, got '%.100s'",
     149                     closure->ob_type->tp_name);
     150        return -1;
     151    }
     152    Py_XDECREF(((PyFunctionObject *) op) -> func_closure);
     153    ((PyFunctionObject *) op) -> func_closure = closure;
     154    return 0;
    155155}
    156156
    … …  
    160160
    161161static PyMemberDef func_memberlist[] = {
    162         {"func_closure",  T_OBJECT,     OFF(func_closure),
    163         RESTRICTED|READONLY},
    164         {"__closure__",  T_OBJECT,      OFF(func_closure),
    165         RESTRICTED|READONLY},
    166         {"func_doc",      T_OBJECT,     OFF(func_doc), PY_WRITE_RESTRICTED},
    167         {"__doc__",       T_OBJECT,     OFF(func_doc), PY_WRITE_RESTRICTED},
    168         {"func_globals",  T_OBJECT,     OFF(func_globals),
    169         RESTRICTED|READONLY},
    170         {"__globals__",  T_OBJECT,      OFF(func_globals),
    171         RESTRICTED|READONLY},
    172         {"__module__",    T_OBJECT,     OFF(func_module), PY_WRITE_RESTRICTED},
    173         {NULL}  /* Sentinel */
     162    {"func_closure",  T_OBJECT,     OFF(func_closure),
     163    RESTRICTED|READONLY},
     164    {"__closure__",  T_OBJECT,      OFF(func_closure),
     165    RESTRICTED|READONLY},
     166    {"func_doc",      T_OBJECT,     OFF(func_doc), PY_WRITE_RESTRICTED},
     167    {"__doc__",       T_OBJECT,     OFF(func_doc), PY_WRITE_RESTRICTED},
     168    {"func_globals",  T_OBJECT,     OFF(func_globals),
     169    RESTRICTED|READONLY},
     170    {"__globals__",  T_OBJECT,      OFF(func_globals),
     171    RESTRICTED|READONLY},
     172    {"__module__",    T_OBJECT,     OFF(func_module), PY_WRITE_RESTRICTED},
     173    {NULL}  /* Sentinel */
    174174};
    175175
    … …  
    177177restricted(void)
    178178{
    179         if (!PyEval_GetRestricted())
    180                 return 0;
    181         PyErr_SetString(PyExc_RuntimeError,
    182                 "function attributes not accessible in restricted mode");
    183         return 1;
     179    if (!PyEval_GetRestricted())
     180        return 0;
     181    PyErr_SetString(PyExc_RuntimeError,
     182        "function attributes not accessible in restricted mode");
     183    return 1;
    184184}
    185185
    … …  
    187187func_get_dict(PyFunctionObject *op)
    188188{
    189         if (restricted())
    190                 return NULL;
    191         if (op->func_dict == NULL) {
    192                 op->func_dict = PyDict_New();
    193                 if (op->func_dict == NULL)
    194                         return NULL;
    195         }
    196         Py_INCREF(op->func_dict);
    197         return op->func_dict;
     189    if (restricted())
     190        return NULL;
     191    if (op->func_dict == NULL) {
     192        op->func_dict = PyDict_New();
     193        if (op->func_dict == NULL)
     194            return NULL;
     195    }
     196    Py_INCREF(op->func_dict);
     197    return op->func_dict;
    198198}
    199199
    … …  
    201201func_set_dict(PyFunctionObject *op, PyObject *value)
    202202{
    203         PyObject *tmp;
    204 
    205         if (restricted())
    206                 return -1;
    207         /* It is illegal to del f.func_dict */
    208         if (value == NULL) {
    209                 PyErr_SetString(PyExc_TypeError,
    210                                 "function's dictionary may not be deleted");
    211                 return -1;
    212         }
    213         /* Can only set func_dict to a dictionary */
    214         if (!PyDict_Check(value)) {
    215                 PyErr_SetString(PyExc_TypeError,
    216                                 "setting function's dictionary to a non-dict");
    217                 return -1;
    218         }
    219         tmp = op->func_dict;
    220         Py_INCREF(value);
    221         op->func_dict = value;
    222         Py_XDECREF(tmp);
    223         return 0;
     203    PyObject *tmp;
     204
     205    if (restricted())
     206        return -1;
     207    /* It is illegal to del f.func_dict */
     208    if (value == NULL) {
     209        PyErr_SetString(PyExc_TypeError,
     210                        "function's dictionary may not be deleted");
     211        return -1;
     212    }
     213    /* Can only set func_dict to a dictionary */
     214    if (!PyDict_Check(value)) {
     215        PyErr_SetString(PyExc_TypeError,
     216                        "setting function's dictionary to a non-dict");
     217        return -1;
     218    }
     219    tmp = op->func_dict;
     220    Py_INCREF(value);
     221    op->func_dict = value;
     222    Py_XDECREF(tmp);
     223    return 0;
    224224}
    225225
    … …  
    227227func_get_code(PyFunctionObject *op)
    228228{
    229         if (restricted())
    230                 return NULL;
    231         Py_INCREF(op->func_code);
    232         return op->func_code;
     229    if (restricted())
     230        return NULL;
     231    Py_INCREF(op->func_code);
     232    return op->func_code;
    233233}
    234234
    … …  
    236236func_set_code(PyFunctionObject *op, PyObject *value)
    237237{
    238         PyObject *tmp;
    239         Py_ssize_t nfree, nclosure;
    240 
    241         if (restricted())
    242                 return -1;
    243         /* Not legal to del f.func_code or to set it to anything
    244         * other than a code object. */
    245         if (value == NULL || !PyCode_Check(value)) {
    246                 PyErr_SetString(PyExc_TypeError,
    247                                 "__code__ must be set to a code object");
    248                 return -1;
    249         }
    250         nfree = PyCode_GetNumFree((PyCodeObject *)value);
    251         nclosure = (op->func_closure == NULL ? 0 :
    252                     PyTuple_GET_SIZE(op->func_closure));
    253         if (nclosure != nfree) {
    254                 PyErr_Format(PyExc_ValueError,
    255                              "%s() requires a code object with %zd free vars,"
    256                              " not %zd",
    257                              PyString_AsString(op->func_name),
    258                              nclosure, nfree);
    259                 return -1;
    260         }
    261         tmp = op->func_code;
    262         Py_INCREF(value);
    263         op->func_code = value;
    264         Py_DECREF(tmp);
    265         return 0;
     238    PyObject *tmp;
     239    Py_ssize_t nfree, nclosure;
     240
     241    if (restricted())
     242        return -1;
     243    /* Not legal to del f.func_code or to set it to anything
     244    * other than a code object. */
     245    if (value == NULL || !PyCode_Check(value)) {
     246        PyErr_SetString(PyExc_TypeError,
     247                        "__code__ must be set to a code object");
     248        return -1;
     249    }
     250    nfree = PyCode_GetNumFree((PyCodeObject *)value);
     251    nclosure = (op->func_closure == NULL ? 0 :
     252            PyTuple_GET_SIZE(op->func_closure));
     253    if (nclosure != nfree) {
     254        PyErr_Format(PyExc_ValueError,
     255                     "%s() requires a code object with %zd free vars,"
     256                     " not %zd",
     257                     PyString_AsString(op->func_name),
     258                     nclosure, nfree);
     259        return -1;
     260    }
     261    tmp = op->func_code;
     262    Py_INCREF(value);
     263    op->func_code = value;
     264    Py_DECREF(tmp);
     265    return 0;
    266266}
    267267
    … …  
    269269func_get_name(PyFunctionObject *op)
    270270{
    271         Py_INCREF(op->func_name);
    272         return op->func_name;
     271    Py_INCREF(op->func_name);
     272    return op->func_name;
    273273}
    274274
    … …  
    276276func_set_name(PyFunctionObject *op, PyObject *value)
    277277{
    278         PyObject *tmp;
    279 
    280         if (restricted())
    281                 return -1;
    282         /* Not legal to del f.func_name or to set it to anything
    283         * other than a string object. */
    284         if (value == NULL || !PyString_Check(value)) {
    285                 PyErr_SetString(PyExc_TypeError,
    286                                 "__name__ must be set to a string object");
    287                 return -1;
    288         }
    289         tmp = op->func_name;
    290         Py_INCREF(value);
    291         op->func_name = value;
    292         Py_DECREF(tmp);
    293         return 0;
     278    PyObject *tmp;
     279
     280    if (restricted())
     281        return -1;
     282    /* Not legal to del f.func_name or to set it to anything
     283    * other than a string object. */
     284    if (value == NULL || !PyString_Check(value)) {
     285        PyErr_SetString(PyExc_TypeError,
     286                        "__name__ must be set to a string object");
     287        return -1;
     288    }
     289    tmp = op->func_name;
     290    Py_INCREF(value);
     291    op->func_name = value;
     292    Py_DECREF(tmp);
     293    return 0;
    294294}
    295295
    … …  
    297297func_get_defaults(PyFunctionObject *op)
    298298{
    299         if (restricted())
    300                 return NULL;
    301         if (op->func_defaults == NULL) {
    302                 Py_INCREF(Py_None);
    303                 return Py_None;
    304         }
    305         Py_INCREF(op->func_defaults);
    306         return op->func_defaults;
     299    if (restricted())
     300        return NULL;
     301    if (op->func_defaults == NULL) {
     302        Py_INCREF(Py_None);
     303        return Py_None;
     304    }
     305    Py_INCREF(op->func_defaults);
     306    return op->func_defaults;
    307307}
    308308
    … …  
    310310func_set_defaults(PyFunctionObject *op, PyObject *value)
    311311{
    312         PyObject *tmp;
    313 
    314         if (restricted())
    315                 return -1;
    316         /* Legal to del f.func_defaults.
    317         * Can only set func_defaults to NULL or a tuple. */
    318         if (value == Py_None)
    319                 value = NULL;
    320         if (value != NULL && !PyTuple_Check(value)) {
    321                 PyErr_SetString(PyExc_TypeError,
    322                                 "__defaults__ must be set to a tuple object");
    323                 return -1;
    324         }
    325         tmp = op->func_defaults;
    326         Py_XINCREF(value);
    327         op->func_defaults = value;
    328         Py_XDECREF(tmp);
    329         return 0;
     312    PyObject *tmp;
     313
     314    if (restricted())
     315        return -1;
     316    /* Legal to del f.func_defaults.
     317    * Can only set func_defaults to NULL or a tuple. */
     318    if (value == Py_None)
     319        value = NULL;
     320    if (value != NULL && !PyTuple_Check(value)) {
     321        PyErr_SetString(PyExc_TypeError,
     322                        "__defaults__ must be set to a tuple object");
     323        return -1;
     324    }
     325    tmp = op->func_defaults;
     326    Py_XINCREF(value);
     327    op->func_defaults = value;
     328    Py_XDECREF(tmp);
     329    return 0;
    330330}
    331331
    332332static PyGetSetDef func_getsetlist[] = {
    333         {"func_code", (getter)func_get_code, (setter)func_set_code},
    334         {"__code__", (getter)func_get_code, (setter)func_set_code},
    335         {"func_defaults", (getter)func_get_defaults,
    336         (setter)func_set_defaults},
    337         {"__defaults__", (getter)func_get_defaults,
    338         (setter)func_set_defaults},
    339         {"func_dict", (getter)func_get_dict, (setter)func_set_dict},
    340         {"__dict__", (getter)func_get_dict, (setter)func_set_dict},
    341         {"func_name", (getter)func_get_name, (setter)func_set_name},
    342         {"__name__", (getter)func_get_name, (setter)func_set_name},
    343         {NULL} /* Sentinel */
     333    {"func_code", (getter)func_get_code, (setter)func_set_code},
     334    {"__code__", (getter)func_get_code, (setter)func_set_code},
     335    {"func_defaults", (getter)func_get_defaults,
     336    (setter)func_set_defaults},
     337    {"__defaults__", (getter)func_get_defaults,
     338    (setter)func_set_defaults},
     339    {"func_dict", (getter)func_get_dict, (setter)func_set_dict},
     340    {"__dict__", (getter)func_get_dict, (setter)func_set_dict},
     341    {"func_name", (getter)func_get_name, (setter)func_set_name},
     342    {"__name__", (getter)func_get_name, (setter)func_set_name},
     343    {NULL} /* Sentinel */
    344344};
    345345
    … …  
    354354/* func_new() maintains the following invariants for closures.  The
    355355   closure must correspond to the free variables of the code object.
    356    
    357    if len(code.co_freevars) == 0: 
    358            closure = NULL
     356
     357   if len(code.co_freevars) == 0:
     358       closure = NULL
    359359   else:
    360            len(closure) == len(code.co_freevars)
     360       len(closure) == len(code.co_freevars)
    361361   for every elt in closure, type(elt) == cell
    362362*/
    … …  
    365365func_new(PyTypeObject* type, PyObject* args, PyObject* kw)
    366366{
    367         PyCodeObject *code;
    368         PyObject *globals;
    369         PyObject *name = Py_None;
    370         PyObject *defaults = Py_None;
    371         PyObject *closure = Py_None;
    372         PyFunctionObject *newfunc;
    373         Py_ssize_t nfree, nclosure;
    374         static char *kwlist[] = {"code", "globals", "name",
    375                                 "argdefs", "closure", 0};
    376 
    377         if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!|OOO:function",
    378                               kwlist,
    379                               &PyCode_Type, &code,
    380                               &PyDict_Type, &globals,
    381                               &name, &defaults, &closure))
    382                 return NULL;
    383         if (name != Py_None && !PyString_Check(name)) {
    384                 PyErr_SetString(PyExc_TypeError,
    385                                 "arg 3 (name) must be None or string");
    386                 return NULL;
    387         }
    388         if (defaults != Py_None && !PyTuple_Check(defaults)) {
    389                 PyErr_SetString(PyExc_TypeError,
    390                                 "arg 4 (defaults) must be None or tuple");
    391                 return NULL;
    392         }
    393         nfree = PyTuple_GET_SIZE(code->co_freevars);
    394         if (!PyTuple_Check(closure)) {
    395                 if (nfree && closure == Py_None) {
    396                         PyErr_SetString(PyExc_TypeError,
    397                                         "arg 5 (closure) must be tuple");
    398                         return NULL;
    399                 }
    400                 else if (closure != Py_None) {
    401                         PyErr_SetString(PyExc_TypeError,
    402                                 "arg 5 (closure) must be None or tuple");
    403                         return NULL;
    404                 }
    405         }
    406 
    407         /* check that the closure is well-formed */
    408         nclosure = closure == Py_None ? 0 : PyTuple_GET_SIZE(closure);
    409         if (nfree != nclosure)
    410                 return PyErr_Format(PyExc_ValueError,
    411                                     "%s requires closure of length %zd, not %zd",
    412                                     PyString_AS_STRING(code->co_name),
    413                                     nfree, nclosure);
    414         if (nclosure) {
    415                 Py_ssize_t i;
    416                 for (i = 0; i < nclosure; i++) {
    417                         PyObject *o = PyTuple_GET_ITEM(closure, i);
    418                         if (!PyCell_Check(o)) {
    419                                 return PyErr_Format(PyExc_TypeError,
    420                                     "arg 5 (closure) expected cell, found %s",
    421                                                     o->ob_type->tp_name);
    422                         }
    423                 }
    424         }
    425        
    426         newfunc = (PyFunctionObject *)PyFunction_New((PyObject *)code,
    427                                                      globals);
    428         if (newfunc == NULL)
    429                 return NULL;
    430        
    431         if (name != Py_None) {
    432                 Py_INCREF(name);
    433                 Py_DECREF(newfunc->func_name);
    434                 newfunc->func_name = name;
    435         }
    436         if (defaults != Py_None) {
    437                 Py_INCREF(defaults);
    438                 newfunc->func_defaults  = defaults;
    439         }
    440         if (closure != Py_None) {
    441                 Py_INCREF(closure);
    442                 newfunc->func_closure = closure;
    443         }
    444 
    445         return (PyObject *)newfunc;
     367    PyCodeObject *code;
     368    PyObject *globals;
     369    PyObject *name = Py_None;
     370    PyObject *defaults = Py_None;
     371    PyObject *closure = Py_None;
     372    PyFunctionObject *newfunc;
     373    Py_ssize_t nfree, nclosure;
     374    static char *kwlist[] = {"code", "globals", "name",
     375                            "argdefs", "closure", 0};
     376
     377    if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!|OOO:function",
     378                          kwlist,
     379                          &PyCode_Type, &code,
     380                          &PyDict_Type, &globals,
     381                          &name, &defaults, &closure))
     382        return NULL;
     383    if (name != Py_None && !PyString_Check(name)) {
     384        PyErr_SetString(PyExc_TypeError,
     385                        "arg 3 (name) must be None or string");
     386        return NULL;
     387    }
     388    if (defaults != Py_None && !PyTuple_Check(defaults)) {
     389        PyErr_SetString(PyExc_TypeError,
     390                        "arg 4 (defaults) must be None or tuple");
     391        return NULL;
     392    }
     393    nfree = PyTuple_GET_SIZE(code->co_freevars);
     394    if (!PyTuple_Check(closure)) {
     395        if (nfree && closure == Py_None) {
     396            PyErr_SetString(PyExc_TypeError,
     397                            "arg 5 (closure) must be tuple");
     398            return NULL;
     399        }
     400        else if (closure != Py_None) {
     401            PyErr_SetString(PyExc_TypeError,
     402                "arg 5 (closure) must be None or tuple");
     403            return NULL;
     404        }
     405    }
     406
     407    /* check that the closure is well-formed */
     408    nclosure = closure == Py_None ? 0 : PyTuple_GET_SIZE(closure);
     409    if (nfree != nclosure)
     410        return PyErr_Format(PyExc_ValueError,
     411                            "%s requires closure of length %zd, not %zd",
     412                            PyString_AS_STRING(code->co_name),
     413                            nfree, nclosure);
     414    if (nclosure) {
     415        Py_ssize_t i;
     416        for (i = 0; i < nclosure; i++) {
     417            PyObject *o = PyTuple_GET_ITEM(closure, i);
     418            if (!PyCell_Check(o)) {
     419                return PyErr_Format(PyExc_TypeError,
     420                    "arg 5 (closure) expected cell, found %s",
     421                                    o->ob_type->tp_name);
     422            }
     423        }
     424    }
     425
     426    newfunc = (PyFunctionObject *)PyFunction_New((PyObject *)code,
     427                                                 globals);
     428    if (newfunc == NULL)
     429        return NULL;
     430
     431    if (name != Py_None) {
     432        Py_INCREF(name);
     433        Py_DECREF(newfunc->func_name);
     434        newfunc->func_name = name;
     435    }
     436    if (defaults != Py_None) {
     437        Py_INCREF(defaults);
     438        newfunc->func_defaults  = defaults;
     439    }
     440    if (closure != Py_None) {
     441        Py_INCREF(closure);
     442        newfunc->func_closure = closure;
     443    }
     444
     445    return (PyObject *)newfunc;
    446446}
    447447
    … …  
    449449func_dealloc(PyFunctionObject *op)
    450450{
    451         _PyObject_GC_UNTRACK(op);
    452         if (op->func_weakreflist != NULL)
    453                 PyObject_ClearWeakRefs((PyObject *) op);
    454         Py_DECREF(op->func_code);
    455         Py_DECREF(op->func_globals);
    456         Py_XDECREF(op->func_module);
    457         Py_DECREF(op->func_name);
    458         Py_XDECREF(op->func_defaults);
    459         Py_XDECREF(op->func_doc);
    460         Py_XDECREF(op->func_dict);
    461         Py_XDECREF(op->func_closure);
    462         PyObject_GC_Del(op);
     451    _PyObject_GC_UNTRACK(op);
     452    if (op->func_weakreflist != NULL)
     453        PyObject_ClearWeakRefs((PyObject *) op);
     454    Py_DECREF(op->func_code);
     455    Py_DECREF(op->func_globals);
     456    Py_XDECREF(op->func_module);
     457    Py_DECREF(op->func_name);
     458    Py_XDECREF(op->func_defaults);
     459    Py_XDECREF(op->func_doc);
     460    Py_XDECREF(op->func_dict);
     461    Py_XDECREF(op->func_closure);
     462    PyObject_GC_Del(op);
    463463}
    464464
    … …  
    466466func_repr(PyFunctionObject *op)
    467467{
    468         return PyString_FromFormat("<function %s at %p>",
    469                                    PyString_AsString(op->func_name),
    470                                    op);
     468    return PyString_FromFormat("<function %s at %p>",
     469                               PyString_AsString(op->func_name),
     470                               op);
    471471}
    472472
    … …  
    474474func_traverse(PyFunctionObject *f, visitproc visit, void *arg)
    475475{
    476         Py_VISIT(f->func_code);
    477         Py_VISIT(f->func_globals);
    478         Py_VISIT(f->func_module);
    479         Py_VISIT(f->func_defaults);
    480         Py_VISIT(f->func_doc);
    481         Py_VISIT(f->func_name);
    482         Py_VISIT(f->func_dict);
    483         Py_VISIT(f->func_closure);
    484         return 0;
     476    Py_VISIT(f->func_code);
     477    Py_VISIT(f->func_globals);
     478    Py_VISIT(f->func_module);
     479    Py_VISIT(f->func_defaults);
     480    Py_VISIT(f->func_doc);
     481    Py_VISIT(f->func_name);
     482    Py_VISIT(f->func_dict);
     483    Py_VISIT(f->func_closure);
     484    return 0;
    485485}
    486486
    … …  
    488488function_call(PyObject *func, PyObject *arg, PyObject *kw)
    489489{
    490         PyObject *result;
    491         PyObject *argdefs;
    492         PyObject **d, **k;
    493         Py_ssize_t nk, nd;
    494 
    495         argdefs = PyFunction_GET_DEFAULTS(func);
    496         if (argdefs != NULL && PyTuple_Check(argdefs)) {
    497                 d = &PyTuple_GET_ITEM((PyTupleObject *)argdefs, 0);
    498                 nd = PyTuple_Size(argdefs);
    499         }
    500         else {
    501                 d = NULL;
    502                 nd = 0;
    503         }
    504 
    505         if (kw != NULL && PyDict_Check(kw)) {
    506                 Py_ssize_t pos, i;
    507                 nk = PyDict_Size(kw);
    508                 k = PyMem_NEW(PyObject *, 2*nk);
    509                 if (k == NULL) {
    510                         PyErr_NoMemory();
    511                         return NULL;
    512                 }
    513                 pos = i = 0;
    514                 while (PyDict_Next(kw, &pos, &k[i], &k[i+1]))
    515                         i += 2;
    516                 nk = i/2;
    517                 /* XXX This is broken if the caller deletes dict items! */
    518         }
    519         else {
    520                 k = NULL;
    521                 nk = 0;
    522         }
    523 
    524         result = PyEval_EvalCodeEx(
    525                 (PyCodeObject *)PyFunction_GET_CODE(func),
    526                 PyFunction_GET_GLOBALS(func), (PyObject *)NULL,
    527                 &PyTuple_GET_ITEM(arg, 0), PyTuple_Size(arg),
    528                 k, nk, d, nd,
    529                 PyFunction_GET_CLOSURE(func));
    530 
    531         if (k != NULL)
    532                 PyMem_DEL(k);
    533 
    534         return result;
     490    PyObject *result;
     491    PyObject *argdefs;
     492    PyObject *kwtuple = NULL;
     493    PyObject **d, **k;
     494    Py_ssize_t nk, nd;
     495
     496    argdefs = PyFunction_GET_DEFAULTS(func);
     497    if (argdefs != NULL && PyTuple_Check(argdefs)) {
     498        d = &PyTuple_GET_ITEM((PyTupleObject *)argdefs, 0);
     499        nd = PyTuple_GET_SIZE(argdefs);
     500    }
     501    else {
     502        d = NULL;
     503        nd = 0;
     504    }
     505
     506    if (kw != NULL && PyDict_Check(kw)) {
     507        Py_ssize_t pos, i;
     508        nk = PyDict_Size(kw);
     509        kwtuple = PyTuple_New(2*nk);
     510        if (kwtuple == NULL)
     511            return NULL;
     512        k = &PyTuple_GET_ITEM(kwtuple, 0);
     513        pos = i = 0;
     514        while (PyDict_Next(kw, &pos, &k[i], &k[i+1])) {
     515            Py_INCREF(k[i]);
     516            Py_INCREF(k[i+1]);
     517            i += 2;
     518        }
     519        nk = i/2;
     520    }
     521    else {
     522        k = NULL;
     523        nk = 0;
     524    }
     525
     526    result = PyEval_EvalCodeEx(
     527        (PyCodeObject *)PyFunction_GET_CODE(func),
     528        PyFunction_GET_GLOBALS(func), (PyObject *)NULL,
     529        &PyTuple_GET_ITEM(arg, 0), PyTuple_GET_SIZE(arg),
     530        k, nk, d, nd,
     531        PyFunction_GET_CLOSURE(func));
     532
     533    Py_XDECREF(kwtuple);
     534
     535    return result;
    535536}
    536537
    … …  
    539540func_descr_get(PyObject *func, PyObject *obj, PyObject *type)
    540541{
    541         if (obj == Py_None)
    542                 obj = NULL;
    543         return PyMethod_New(func, obj, type);
     542    if (obj == Py_None)
     543        obj = NULL;
     544    return PyMethod_New(func, obj, type);
    544545}
    545546
    546547PyTypeObject PyFunction_Type = {
    547         PyVarObject_HEAD_INIT(&PyType_Type, 0)
    548         "function",
    549         sizeof(PyFunctionObject),
    550         0,
    551         (destructor)func_dealloc,               /* tp_dealloc */
    552         0,                                      /* tp_print */
    553         0,                                      /* tp_getattr */
    554         0,                                      /* tp_setattr */
    555         0,                                      /* tp_compare */
    556         (reprfunc)func_repr,                    /* tp_repr */
    557         0,                                      /* tp_as_number */
    558         0,                                      /* tp_as_sequence */
    559         0,                                      /* tp_as_mapping */
    560         0,                                      /* tp_hash */
    561         function_call,                          /* tp_call */
    562         0,                                      /* tp_str */
    563         PyObject_GenericGetAttr,                /* tp_getattro */
    564         PyObject_GenericSetAttr,                /* tp_setattro */
    565         0,                                      /* tp_as_buffer */
    566         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
    567         func_doc,                               /* tp_doc */
    568         (traverseproc)func_traverse,            /* tp_traverse */
    569         0,                                      /* tp_clear */
    570         0,                                      /* tp_richcompare */
    571         offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */
    572         0,                                      /* tp_iter */
    573         0,                                      /* tp_iternext */
    574         0,                                      /* tp_methods */
    575         func_memberlist,                        /* tp_members */
    576         func_getsetlist,                        /* tp_getset */
    577         0,                                      /* tp_base */
    578         0,                                      /* tp_dict */
    579         func_descr_get,                         /* tp_descr_get */
    580         0,                                      /* tp_descr_set */
    581         offsetof(PyFunctionObject, func_dict),  /* tp_dictoffset */
    582         0,                                      /* tp_init */
    583         0,                                      /* tp_alloc */
    584         func_new,                               /* tp_new */
     548    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     549    "function",
     550    sizeof(PyFunctionObject),
     551    0,
     552    (destructor)func_dealloc,                   /* tp_dealloc */
     553    0,                                          /* tp_print */
     554    0,                                          /* tp_getattr */
     555    0,                                          /* tp_setattr */
     556    0,                                          /* tp_compare */
     557    (reprfunc)func_repr,                        /* tp_repr */
     558    0,                                          /* tp_as_number */
     559    0,                                          /* tp_as_sequence */
     560    0,                                          /* tp_as_mapping */
     561    0,                                          /* tp_hash */
     562    function_call,                              /* tp_call */
     563    0,                                          /* tp_str */
     564    PyObject_GenericGetAttr,                    /* tp_getattro */
     565    PyObject_GenericSetAttr,                    /* tp_setattro */
     566    0,                                          /* tp_as_buffer */
     567    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
     568    func_doc,                                   /* tp_doc */
     569    (traverseproc)func_traverse,                /* tp_traverse */
     570    0,                                          /* tp_clear */
     571    0,                                          /* tp_richcompare */
     572    offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */
     573    0,                                          /* tp_iter */
     574    0,                                          /* tp_iternext */
     575    0,                                          /* tp_methods */
     576    func_memberlist,                            /* tp_members */
     577    func_getsetlist,                            /* tp_getset */
     578    0,                                          /* tp_base */
     579    0,                                          /* tp_dict */
     580    func_descr_get,                             /* tp_descr_get */
     581    0,                                          /* tp_descr_set */
     582    offsetof(PyFunctionObject, func_dict),      /* tp_dictoffset */
     583    0,                                          /* tp_init */
     584    0,                                          /* tp_alloc */
     585    func_new,                                   /* tp_new */
    585586};
    586587
    … …  
    593594
    594595     class C:
    595          def f(cls, arg1, arg2, ...): ...
    596         f = classmethod(f)
    597    
     596     def f(cls, arg1, arg2, ...): ...
     597    f = classmethod(f)
     598
    598599   It can be called either on the class (e.g. C.f()) or on an instance
    599600   (e.g. C().f()); the instance is ignored except for its class.
    … …  
    606607
    607608typedef struct {
    608         PyObject_HEAD
    609         PyObject *cm_callable;
     609    PyObject_HEAD
     610    PyObject *cm_callable;
    610611} classmethod;
    611612
    … …  
    613614cm_dealloc(classmethod *cm)
    614615{
    615         _PyObject_GC_UNTRACK((PyObject *)cm);
    616         Py_XDECREF(cm->cm_callable);
    617         Py_TYPE(cm)->tp_free((PyObject *)cm);
     616    _PyObject_GC_UNTRACK((PyObject *)cm);
     617    Py_XDECREF(cm->cm_callable);
     618    Py_TYPE(cm)->tp_free((PyObject *)cm);
    618619}
    619620
    … …  
    621622cm_traverse(classmethod *cm, visitproc visit, void *arg)
    622623{
    623         Py_VISIT(cm->cm_callable);
    624         return 0;
     624    Py_VISIT(cm->cm_callable);
     625    return 0;
    625626}
    626627
    … …  
    628629cm_clear(classmethod *cm)
    629630{
    630         Py_CLEAR(cm->cm_callable);
    631         return 0;
     631    Py_CLEAR(cm->cm_callable);
     632    return 0;
    632633}
    633634
    … …  
    636637cm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
    637638{
    638         classmethod *cm = (classmethod *)self;
    639 
    640         if (cm->cm_callable == NULL) {
    641                 PyErr_SetString(PyExc_RuntimeError,
    642                                 "uninitialized classmethod object");
    643                 return NULL;
    644         }
    645         if (type == NULL)
    646                 type = (PyObject *)(Py_TYPE(obj));
    647         return PyMethod_New(cm->cm_callable,
    648                             type, (PyObject *)(Py_TYPE(type)));
     639    classmethod *cm = (classmethod *)self;
     640
     641    if (cm->cm_callable == NULL) {
     642        PyErr_SetString(PyExc_RuntimeError,
     643                        "uninitialized classmethod object");
     644        return NULL;
     645    }
     646    if (type == NULL)
     647        type = (PyObject *)(Py_TYPE(obj));
     648    return PyMethod_New(cm->cm_callable,
     649                        type, (PyObject *)(Py_TYPE(type)));
    649650}
    650651
    … …  
    652653cm_init(PyObject *self, PyObject *args, PyObject *kwds)
    653654{
    654         classmethod *cm = (classmethod *)self;
    655         PyObject *callable;
    656 
    657         if (!PyArg_UnpackTuple(args, "classmethod", 1, 1, &callable))
    658                 return -1;
    659         if (!_PyArg_NoKeywords("classmethod", kwds))
    660                 return -1;
    661         if (!PyCallable_Check(callable)) {
    662                 PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
    663                      callable->ob_type->tp_name);
    664                 return -1;
    665         }
    666        
    667         Py_INCREF(callable);
    668         cm->cm_callable = callable;
    669         return 0;
    670 }
     655    classmethod *cm = (classmethod *)self;
     656    PyObject *callable;
     657
     658    if (!PyArg_UnpackTuple(args, "classmethod", 1, 1, &callable))
     659        return -1;
     660    if (!_PyArg_NoKeywords("classmethod", kwds))
     661        return -1;
     662    Py_INCREF(callable);
     663    cm->cm_callable = callable;
     664    return 0;
     665}
     666
     667static PyMemberDef cm_memberlist[] = {
     668    {"__func__", T_OBJECT, offsetof(classmethod, cm_callable), READONLY},
     669    {NULL}  /* Sentinel */
     670};
    671671
    672672PyDoc_STRVAR(classmethod_doc,
    … …  
    692692
    693693PyTypeObject PyClassMethod_Type = {
    694         PyVarObject_HEAD_INIT(&PyType_Type, 0)
    695         "classmethod",
    696         sizeof(classmethod),
    697         0,
    698         (destructor)cm_dealloc,                 /* tp_dealloc */
    699         0,                                      /* tp_print */
    700         0,                                      /* tp_getattr */
    701         0,                                      /* tp_setattr */
    702         0,                                      /* tp_compare */
    703         0,                                      /* tp_repr */
    704         0,                                      /* tp_as_number */
    705         0,                                      /* tp_as_sequence */
    706         0,                                      /* tp_as_mapping */
    707         0,                                      /* tp_hash */
    708         0,                                      /* tp_call */
    709         0,                                      /* tp_str */
    710         PyObject_GenericGetAttr,                /* tp_getattro */
    711         0,                                      /* tp_setattro */
    712         0,                                      /* tp_as_buffer */
    713         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
    714         classmethod_doc,                        /* tp_doc */
    715         (traverseproc)cm_traverse,              /* tp_traverse */
    716         (inquiry)cm_clear,                      /* tp_clear */
    717         0,                                      /* tp_richcompare */
    718         0,                                      /* tp_weaklistoffset */
    719         0,                                      /* tp_iter */
    720         0,                                      /* tp_iternext */
    721         0,                                      /* tp_methods */
    722         0,                                      /* tp_members */
    723         0,                                      /* tp_getset */
    724         0,                                      /* tp_base */
    725         0,                                      /* tp_dict */
    726         cm_descr_get,                           /* tp_descr_get */
    727         0,                                      /* tp_descr_set */
    728         0,                                      /* tp_dictoffset */
    729         cm_init,                                /* tp_init */
    730         PyType_GenericAlloc,                    /* tp_alloc */
    731         PyType_GenericNew,                      /* tp_new */
    732         PyObject_GC_Del,                        /* tp_free */
     694    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     695    "classmethod",
     696    sizeof(classmethod),
     697    0,
     698    (destructor)cm_dealloc,                     /* tp_dealloc */
     699    0,                                          /* tp_print */
     700    0,                                          /* tp_getattr */
     701    0,                                          /* tp_setattr */
     702    0,                                          /* tp_compare */
     703    0,                                          /* tp_repr */
     704    0,                                          /* tp_as_number */
     705    0,                                          /* tp_as_sequence */
     706    0,                                          /* tp_as_mapping */
     707    0,                                          /* tp_hash */
     708    0,                                          /* tp_call */
     709    0,                                          /* tp_str */
     710    PyObject_GenericGetAttr,                    /* tp_getattro */
     711    0,                                          /* tp_setattro */
     712    0,                                          /* tp_as_buffer */
     713    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
     714    classmethod_doc,                            /* tp_doc */
     715    (traverseproc)cm_traverse,                  /* tp_traverse */
     716    (inquiry)cm_clear,                          /* tp_clear */
     717    0,                                          /* tp_richcompare */
     718    0,                                          /* tp_weaklistoffset */
     719    0,                                          /* tp_iter */
     720    0,                                          /* tp_iternext */
     721    0,                                          /* tp_methods */
     722    cm_memberlist,              /* tp_members */
     723    0,                                          /* tp_getset */
     724    0,                                          /* tp_base */
     725    0,                                          /* tp_dict */
     726    cm_descr_get,                               /* tp_descr_get */
     727    0,                                          /* tp_descr_set */
     728    0,                                          /* tp_dictoffset */
     729    cm_init,                                    /* tp_init */
     730    PyType_GenericAlloc,                        /* tp_alloc */
     731    PyType_GenericNew,                          /* tp_new */
     732    PyObject_GC_Del,                            /* tp_free */
    733733};
    734734
    … …  
    736736PyClassMethod_New(PyObject *callable)
    737737{
    738         classmethod *cm = (classmethod *)
    739                 PyType_GenericAlloc(&PyClassMethod_Type, 0);
    740         if (cm != NULL) {
    741                 Py_INCREF(callable);
    742                 cm->cm_callable = callable;
    743         }
    744         return (PyObject *)cm;
     738    classmethod *cm = (classmethod *)
     739        PyType_GenericAlloc(&PyClassMethod_Type, 0);
     740    if (cm != NULL) {
     741        Py_INCREF(callable);
     742        cm->cm_callable = callable;
     743    }
     744    return (PyObject *)cm;
    745745}
    746746
    … …  
    752752
    753753     class C:
    754          def f(arg1, arg2, ...): ...
    755         f = staticmethod(f)
     754     def f(arg1, arg2, ...): ...
     755    f = staticmethod(f)
    756756
    757757   It can be called either on the class (e.g. C.f()) or on an instance
    … …  
    763763
    764764typedef struct {
    765         PyObject_HEAD
    766         PyObject *sm_callable;
     765    PyObject_HEAD
     766    PyObject *sm_callable;
    767767} staticmethod;
    768768
    … …  
    770770sm_dealloc(staticmethod *sm)
    771771{
    772         _PyObject_GC_UNTRACK((PyObject *)sm);
    773         Py_XDECREF(sm->sm_callable);
    774         Py_TYPE(sm)->tp_free((PyObject *)sm);
     772    _PyObject_GC_UNTRACK((PyObject *)sm);
     773    Py_XDECREF(sm->sm_callable);
     774    Py_TYPE(sm)->tp_free((PyObject *)sm);
    775775}
    776776
    … …  
    778778sm_traverse(staticmethod *sm, visitproc visit, void *arg)
    779779{
    780         Py_VISIT(sm->sm_callable);
    781         return 0;
     780    Py_VISIT(sm->sm_callable);
     781    return 0;
    782782}
    783783
    … …  
    785785sm_clear(staticmethod *sm)
    786786{
    787         Py_XDECREF(sm->sm_callable);
    788         sm->sm_callable = NULL;
    789 
    790         return 0;
     787    Py_CLEAR(sm->sm_callable);
     788    return 0;
    791789}
    792790
    … …  
    794792sm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
    795793{
    796         staticmethod *sm = (staticmethod *)self;
    797 
    798         if (sm->sm_callable == NULL) {
    799                 PyErr_SetString(PyExc_RuntimeError,
    800                                 "uninitialized staticmethod object");
    801                 return NULL;
    802         }
    803         Py_INCREF(sm->sm_callable);
    804         return sm->sm_callable;
     794    staticmethod *sm = (staticmethod *)self;
     795
     796    if (sm->sm_callable == NULL) {
     797        PyErr_SetString(PyExc_RuntimeError,
     798                        "uninitialized staticmethod object");
     799        return NULL;
     800    }
     801    Py_INCREF(sm->sm_callable);
     802    return sm->sm_callable;
    805803}
    806804
    … …  
    808806sm_init(PyObject *self, PyObject *args, PyObject *kwds)
    809807{
    810         staticmethod *sm = (staticmethod *)self;
    811         PyObject *callable;
    812 
    813         if (!PyArg_UnpackTuple(args, "staticmethod", 1, 1, &callable))
    814                 return -1;
    815         if (!_PyArg_NoKeywords("staticmethod", kwds))
    816                 return -1;
    817         Py_INCREF(callable);
    818         sm->sm_callable = callable;
    819         return 0;
    820 }
     808    staticmethod *sm = (staticmethod *)self;
     809    PyObject *callable;
     810
     811    if (!PyArg_UnpackTuple(args, "staticmethod", 1, 1, &callable))
     812        return -1;
     813    if (!_PyArg_NoKeywords("staticmethod", kwds))
     814        return -1;
     815    Py_INCREF(callable);
     816    sm->sm_callable = callable;
     817    return 0;
     818}
     819
     820static PyMemberDef sm_memberlist[] = {
     821    {"__func__", T_OBJECT, offsetof(staticmethod, sm_callable), READONLY},
     822    {NULL}  /* Sentinel */
     823};
    821824
    822825PyDoc_STRVAR(staticmethod_doc,
    … …  
    829832\n\
    830833     class C:\n\
    831          def f(arg1, arg2, ...): ...\n\
    832         f = staticmethod(f)\n\
     834     def f(arg1, arg2, ...): ...\n\
     835    f = staticmethod(f)\n\
    833836\n\
    834837It can be called either on the class (e.g. C.f()) or on an instance\n\
    … …  
    839842
    840843PyTypeObject PyStaticMethod_Type = {
    841         PyVarObject_HEAD_INIT(&PyType_Type, 0)
    842         "staticmethod",
    843         sizeof(staticmethod),
    844         0,
    845         (destructor)sm_dealloc,                 /* tp_dealloc */
    846         0,                                      /* tp_print */
    847         0,                                      /* tp_getattr */
    848         0,                                      /* tp_setattr */
    849         0,                                      /* tp_compare */
    850         0,                                      /* tp_repr */
    851         0,                                      /* tp_as_number */
    852         0,                                      /* tp_as_sequence */
    853         0,                                      /* tp_as_mapping */
    854         0,                                      /* tp_hash */
    855         0,                                      /* tp_call */
    856         0,                                      /* tp_str */
    857         PyObject_GenericGetAttr,                /* tp_getattro */
    858         0,                                      /* tp_setattro */
    859         0,                                      /* tp_as_buffer */
    860         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
    861         staticmethod_doc,                       /* tp_doc */
    862         (traverseproc)sm_traverse,              /* tp_traverse */
    863         (inquiry)sm_clear,                      /* tp_clear */
    864         0,                                      /* tp_richcompare */
    865         0,                                      /* tp_weaklistoffset */
    866         0,                                      /* tp_iter */
    867         0,                                      /* tp_iternext */
    868         0,                                      /* tp_methods */
    869         0,                                      /* tp_members */
    870         0,                                      /* tp_getset */
    871         0,                                      /* tp_base */
    872         0,                                      /* tp_dict */
    873         sm_descr_get,                           /* tp_descr_get */
    874         0,                                      /* tp_descr_set */
    875         0,                                      /* tp_dictoffset */
    876         sm_init,                                /* tp_init */
    877         PyType_GenericAlloc,                    /* tp_alloc */
    878         PyType_GenericNew,                      /* tp_new */
    879         PyObject_GC_Del,                        /* tp_free */
     844    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     845    "staticmethod",
     846    sizeof(staticmethod),
     847    0,
     848    (destructor)sm_dealloc,                     /* tp_dealloc */
     849    0,                                          /* tp_print */
     850    0,                                          /* tp_getattr */
     851    0,                                          /* tp_setattr */
     852    0,                                          /* tp_compare */
     853    0,                                          /* tp_repr */
     854    0,                                          /* tp_as_number */
     855    0,                                          /* tp_as_sequence */
     856    0,                                          /* tp_as_mapping */
     857    0,                                          /* tp_hash */
     858    0,                                          /* tp_call */
     859    0,                                          /* tp_str */
     860    PyObject_GenericGetAttr,                    /* tp_getattro */
     861    0,                                          /* tp_setattro */
     862    0,                                          /* tp_as_buffer */
     863    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
     864    staticmethod_doc,                           /* tp_doc */
     865    (traverseproc)sm_traverse,                  /* tp_traverse */
     866    (inquiry)sm_clear,                          /* tp_clear */
     867    0,                                          /* tp_richcompare */
     868    0,                                          /* tp_weaklistoffset */
     869    0,                                          /* tp_iter */
     870    0,                                          /* tp_iternext */
     871    0,                                          /* tp_methods */
     872    sm_memberlist,              /* tp_members */
     873    0,                                          /* tp_getset */
     874    0,                                          /* tp_base */
     875    0,                                          /* tp_dict */
     876    sm_descr_get,                               /* tp_descr_get */
     877    0,                                          /* tp_descr_set */
     878    0,                                          /* tp_dictoffset */
     879    sm_init,                                    /* tp_init */
     880    PyType_GenericAlloc,                        /* tp_alloc */
     881    PyType_GenericNew,                          /* tp_new */
     882    PyObject_GC_Del,                            /* tp_free */
    880883};
    881884
    … …  
    883886PyStaticMethod_New(PyObject *callable)
    884887{
    885         staticmethod *sm = (staticmethod *)
    886                 PyType_GenericAlloc(&PyStaticMethod_Type, 0);
    887         if (sm != NULL) {
    888                 Py_INCREF(callable);
    889                 sm->sm_callable = callable;
    890         }
    891         return (PyObject *)sm;
    892 }
     888    staticmethod *sm = (staticmethod *)
     889        PyType_GenericAlloc(&PyStaticMethod_Type, 0);
     890    if (sm != NULL) {
     891        Py_INCREF(callable);
     892        sm->sm_callable = callable;
     893    }
     894    return (PyObject *)sm;
     895}
Note: See TracChangeset for help on using the changeset viewer.