Objects/funcobject.c

   1
   2 /* Function object implementation */
   3
   4 #include "Python.h"
   5 #include "compile.h"
   6 #include "structmember.h"
   7
   8 PyObject *
   9 PyFunction_New(PyObject *code, PyObject *globals)
  10 {
  11         PyFunctionObject *op = PyObject_NEW(PyFunctionObject,
  12                                             &PyFunction_Type);
  13         if (op != NULL) {
  14                 PyObject *doc;
  15                 PyObject *consts;
  16                 Py_INCREF(code);
  17                 op->func_code = code;
  18                 Py_INCREF(globals);
  19                 op->func_globals = globals;
  20                 op->func_name = ((PyCodeObject *)code)->co_name;
  21                 Py_INCREF(op->func_name);
  22                 op->func_defaults = NULL; /* No default arguments */
  23                 op->func_closure = NULL;
  24                 consts = ((PyCodeObject *)code)->co_consts;
  25                 if (PyTuple_Size(consts) >= 1) {
  26                         doc = PyTuple_GetItem(consts, 0);
  27                         if (!PyString_Check(doc) && !PyUnicode_Check(doc))
  28                                 doc = Py_None;
  29                 }
  30                 else
  31                         doc = Py_None;
  32                 Py_INCREF(doc);
  33                 op->func_doc = doc;
  34                 op->func_dict = NULL;
  35         }
  36         else
  37                 return NULL;
  38         PyObject_GC_Init(op);
  39         return (PyObject *)op;
  40 }
  41
  42 PyObject *
  43 PyFunction_GetCode(PyObject *op)
  44 {
  45         if (!PyFunction_Check(op)) {
  46                 PyErr_BadInternalCall();
  47                 return NULL;
  48         }
  49         return ((PyFunctionObject *) op) -> func_code;
  50 }
  51
  52 PyObject *
  53 PyFunction_GetGlobals(PyObject *op)
  54 {
  55         if (!PyFunction_Check(op)) {
  56                 PyErr_BadInternalCall();
  57                 return NULL;
  58         }
  59         return ((PyFunctionObject *) op) -> func_globals;
  60 }
  61
  62 PyObject *
  63 PyFunction_GetDefaults(PyObject *op)
  64 {
  65         if (!PyFunction_Check(op)) {
  66                 PyErr_BadInternalCall();
  67                 return NULL;
  68         }
  69         return ((PyFunctionObject *) op) -> func_defaults;
  70 }
  71
  72 int
  73 PyFunction_SetDefaults(PyObject *op, PyObject *defaults)
  74 {
  75         if (!PyFunction_Check(op)) {
  76                 PyErr_BadInternalCall();
  77                 return -1;
  78         }
  79         if (defaults == Py_None)
  80                 defaults = NULL;
  81         else if (PyTuple_Check(defaults)) {
  82                 Py_XINCREF(defaults);
  83         }
  84         else {
  85                 PyErr_SetString(PyExc_SystemError, "non-tuple default args");
  86                 return -1;
  87         }
  88         Py_XDECREF(((PyFunctionObject *) op) -> func_defaults);
  89         ((PyFunctionObject *) op) -> func_defaults = defaults;
  90         return 0;
  91 }
  92
  93 PyObject *
  94 PyFunction_GetClosure(PyObject *op)
  95 {
  96         if (!PyFunction_Check(op)) {
  97                 PyErr_BadInternalCall();
  98                 return NULL;
  99         }
 100         return ((PyFunctionObject *) op) -> func_closure;
 101 }
 102
 103 int
 104 PyFunction_SetClosure(PyObject *op, PyObject *closure)
 105 {
 106         if (!PyFunction_Check(op)) {
 107                 PyErr_BadInternalCall();
 108                 return -1;
 109         }
 110         if (closure == Py_None)
 111                 closure = NULL;
 112         else if (PyTuple_Check(closure)) {
 113                 Py_XINCREF(closure);
 114         }
 115         else {
 116                 PyErr_SetString(PyExc_SystemError, "non-tuple closure");
 117                 return -1;
 118         }
 119         Py_XDECREF(((PyFunctionObject *) op) -> func_closure);
 120         ((PyFunctionObject *) op) -> func_closure = closure;
 121         return 0;
 122 }
 123
 124 /* Methods */
 125
 126 #define OFF(x) offsetof(PyFunctionObject, x)
 127
 128 static struct memberlist func_memberlist[] = {
 129         {"func_code",     T_OBJECT,     OFF(func_code)},
 130         {"func_globals",  T_OBJECT,     OFF(func_globals),      READONLY},
 131         {"func_name",     T_OBJECT,     OFF(func_name),         READONLY},
 132         {"__name__",      T_OBJECT,     OFF(func_name),         READONLY},
 133         {"func_closure",  T_OBJECT,     OFF(func_closure)},
 134         {"func_defaults", T_OBJECT,     OFF(func_defaults)},
 135         {"func_doc",      T_OBJECT,     OFF(func_doc)},
 136         {"__doc__",       T_OBJECT,     OFF(func_doc)},
 137         {"func_dict",     T_OBJECT,     OFF(func_dict)},
 138         {"__dict__",      T_OBJECT,     OFF(func_dict)},
 139         {NULL}  /* Sentinel */
 140 };
 141
 142 static PyObject *
 143 func_getattro(PyFunctionObject *op, PyObject *name)
 144 {
 145         PyObject *rtn;
 146         char *sname = PyString_AsString(name);
 147
 148         if (sname[0] != '_' && PyEval_GetRestricted()) {
 149                 PyErr_SetString(PyExc_RuntimeError,
 150                   "function attributes not accessible in restricted mode");
 151                 return NULL;
 152         }
 153
 154         /* no API for PyMember_HasAttr() */
 155         rtn = PyMember_Get((char *)op, func_memberlist, sname);
 156
 157         if (rtn == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
 158                 PyErr_Clear();
 159                 if (op->func_dict != NULL) {
 160                         rtn = PyDict_GetItem(op->func_dict, name);
 161                         Py_XINCREF(rtn);
 162                 }
 163                 if (rtn == NULL)
 164                         PyErr_SetObject(PyExc_AttributeError, name);
 165         }
 166         return rtn;
 167 }
 168
 169 static int
 170 func_setattro(PyFunctionObject *op, PyObject *name, PyObject *value)
 171 {
 172         int rtn;
 173         char *sname = PyString_AsString(name);
 174
 175         if (PyEval_GetRestricted()) {
 176                 PyErr_SetString(PyExc_RuntimeError,
 177                   "function attributes not settable in restricted mode");
 178                 return -1;
 179         }
 180         if (strcmp(sname, "func_code") == 0) {
 181                 /* not legal to del f.func_code or to set it to anything
 182                  * other than a code object.
 183                  */
 184                 if (value == NULL || !PyCode_Check(value)) {
 185                         PyErr_SetString(
 186                                 PyExc_TypeError,
 187                                 "func_code must be set to a code object");
 188                         return -1;
 189                 }
 190         }
 191         else if (strcmp(sname, "func_defaults") == 0) {
 192                 /* legal to del f.func_defaults.  Can only set
 193                  * func_defaults to NULL or a tuple.
 194                  */
 195                 if (value == Py_None)
 196                         value = NULL;
 197                 if (value != NULL && !PyTuple_Check(value)) {
 198                         PyErr_SetString(
 199                                 PyExc_TypeError,
 200                                 "func_defaults must be set to a tuple object");
 201                         return -1;
 202                 }
 203         }
 204         else if (!strcmp(sname, "func_dict") || !strcmp(sname, "__dict__")) {
 205                 /* legal to del f.func_dict.  Can only set func_dict to
 206                  * NULL or a dictionary.
 207                  */
 208                 if (value == Py_None)
 209                         value = NULL;
 210                 if (value != NULL && !PyDict_Check(value)) {
 211                         PyErr_SetString(
 212                                 PyExc_TypeError,
 213                                 "func_dict must be set to a dict object");
 214                         return -1;
 215                 }
 216         }
 217
 218         rtn = PyMember_Set((char *)op, func_memberlist, sname, value);
 219         if (rtn < 0 && PyErr_ExceptionMatches(PyExc_AttributeError)) {
 220                 PyErr_Clear();
 221                 if (op->func_dict == NULL) {
 222                         /* don't create the dict if we're deleting an
 223                          * attribute.  In that case, we know we'll get an
 224                          * AttributeError.
 225                          */
 226                         if (value == NULL) {
 227                                 PyErr_SetString(PyExc_AttributeError, sname);
 228                                 return -1;
 229                         }
 230                         op->func_dict = PyDict_New();
 231                         if (op->func_dict == NULL)
 232                                 return -1;
 233                 }
 234                 if (value == NULL)
 235                         rtn = PyDict_DelItem(op->func_dict, name);
 236                 else
 237                         rtn = PyDict_SetItem(op->func_dict, name, value);
 238                 /* transform KeyError into AttributeError */
 239                 if (rtn < 0 && PyErr_ExceptionMatches(PyExc_KeyError))
 240                         PyErr_SetString(PyExc_AttributeError, sname);
 241         }
 242         return rtn;
 243 }
 244
 245 static void
 246 func_dealloc(PyFunctionObject *op)
 247 {
 248         PyObject_GC_Fini(op);
 249         Py_DECREF(op->func_code);
 250         Py_DECREF(op->func_globals);
 251         Py_DECREF(op->func_name);
 252         Py_XDECREF(op->func_defaults);
 253         Py_XDECREF(op->func_doc);
 254         Py_XDECREF(op->func_dict);
 255         op = (PyFunctionObject *) PyObject_AS_GC(op);
 256         PyObject_DEL(op);
 257 }
 258
 259 static PyObject*
 260 func_repr(PyFunctionObject *op)
 261 {
 262         char buf[140];
 263         if (op->func_name == Py_None)
 264                 sprintf(buf, "<anonymous function at %p>", op);
 265         else
 266                 sprintf(buf, "<function %.100s at %p>",
 267                         PyString_AsString(op->func_name),
 268                         op);
 269         return PyString_FromString(buf);
 270 }
 271
 272 static int
 273 func_traverse(PyFunctionObject *f, visitproc visit, void *arg)
 274 {
 275         int err;
 276         if (f->func_code) {
 277                 err = visit(f->func_code, arg);
 278                 if (err)
 279                         return err;
 280         }
 281         if (f->func_globals) {
 282                 err = visit(f->func_globals, arg);
 283                 if (err)
 284                         return err;
 285         }
 286         if (f->func_defaults) {
 287                 err = visit(f->func_defaults, arg);
 288                 if (err)
 289                         return err;
 290         }
 291         if (f->func_doc) {
 292                 err = visit(f->func_doc, arg);
 293                 if (err)
 294                         return err;
 295         }
 296         if (f->func_name) {
 297                 err = visit(f->func_name, arg);
 298                 if (err)
 299                         return err;
 300         }
 301         if (f->func_dict) {
 302                 err = visit(f->func_dict, arg);
 303                 if (err)
 304                         return err;
 305         }
 306         return 0;
 307 }
 308
 309 PyTypeObject PyFunction_Type = {
 310         PyObject_HEAD_INIT(&PyType_Type)
 311         0,
 312         "function",
 313         sizeof(PyFunctionObject) + PyGC_HEAD_SIZE,
 314         0,
 315         (destructor)func_dealloc, /*tp_dealloc*/
 316         0,              /*tp_print*/
 317         0, /*tp_getattr*/
 318         0, /*tp_setattr*/
 319         0, /*tp_compare*/
 320         (reprfunc)func_repr, /*tp_repr*/
 321         0,              /*tp_as_number*/
 322         0,              /*tp_as_sequence*/
 323         0,              /*tp_as_mapping*/
 324         0, /*tp_hash*/
 325         0,              /*tp_call*/
 326         0,              /*tp_str*/
 327         (getattrofunc)func_getattro,         /*tp_getattro*/
 328         (setattrofunc)func_setattro,         /*tp_setattro*/
 329         0,              /* tp_as_buffer */
 330         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_GC, /*tp_flags*/
 331         0,              /* tp_doc */
 332         (traverseproc)func_traverse,    /* tp_traverse */
 333 };