Python/structmember.c

   1
   2 /* Map C struct members to Python object attributes */
   3
   4 #include "Python.h"
   5
   6 #include "structmember.h"
   7
   8 static PyObject *
   9 listmembers(struct memberlist *mlist)
  10 {
  11         int i, n;
  12         PyObject *v;
  13         for (n = 0; mlist[n].name != NULL; n++)
  14                 ;
  15         v = PyList_New(n);
  16         if (v != NULL) {
  17                 for (i = 0; i < n; i++)
  18                         PyList_SetItem(v, i,
  19                                        PyString_FromString(mlist[i].name));
  20                 if (PyErr_Occurred()) {
  21                         Py_DECREF(v);
  22                         v = NULL;
  23                 }
  24                 else {
  25                         PyList_Sort(v);
  26                 }
  27         }
  28         return v;
  29 }
  30
  31 PyObject *
  32 PyMember_Get(char *addr, struct memberlist *mlist, char *name)
  33 {
  34         struct memberlist *l;
  35
  36         if (strcmp(name, "__members__") == 0)
  37                 return listmembers(mlist);
  38         for (l = mlist; l->name != NULL; l++) {
  39                 if (strcmp(l->name, name) == 0) {
  40                         PyMemberDef copy;
  41                         copy.name = l->name;
  42                         copy.type = l->type;
  43                         copy.offset = l->offset;
  44                         copy.flags = l->flags;
  45                         copy.doc = NULL;
  46                         return PyMember_GetOne(addr, &copy);
  47                 }
  48         }
  49         PyErr_SetString(PyExc_AttributeError, name);
  50         return NULL;
  51 }
  52
  53 PyObject *
  54 PyMember_GetOne(char *addr, PyMemberDef *l)
  55 {
  56         PyObject *v;
  57         if ((l->flags & READ_RESTRICTED) &&
  58             PyEval_GetRestricted()) {
  59                 PyErr_SetString(PyExc_RuntimeError, "restricted attribute");
  60                 return NULL;
  61         }
  62         addr += l->offset;
  63         switch (l->type) {
  64         case T_BYTE:
  65                 v = PyInt_FromLong(
  66                         (long) (((*(char*)addr & 0xff) ^ 0x80) - 0x80));
  67                 break;
  68         case T_UBYTE:
  69                 v = PyInt_FromLong((long) *(char*)addr & 0xff);
  70                 break;
  71         case T_SHORT:
  72                 v = PyInt_FromLong((long) *(short*)addr);
  73                 break;
  74         case T_USHORT:
  75                 v = PyInt_FromLong((long) *(unsigned short*)addr);
  76                 break;
  77         case T_INT:
  78                 v = PyInt_FromLong((long) *(int*)addr);
  79                 break;
  80         case T_UINT:
  81                 v = PyInt_FromLong((long) *(unsigned int*)addr);
  82                 break;
  83         case T_LONG:
  84                 v = PyInt_FromLong(*(long*)addr);
  85                 break;
  86         case T_ULONG:
  87                 v = PyLong_FromDouble((double) *(unsigned long*)addr);
  88                 break;
  89         case T_FLOAT:
  90                 v = PyFloat_FromDouble((double)*(float*)addr);
  91                 break;
  92         case T_DOUBLE:
  93                 v = PyFloat_FromDouble(*(double*)addr);
  94                 break;
  95         case T_STRING:
  96                 if (*(char**)addr == NULL) {
  97                         Py_INCREF(Py_None);
  98                         v = Py_None;
  99                 }
 100                 else
 101                         v = PyString_FromString(*(char**)addr);
 102                 break;
 103         case T_STRING_INPLACE:
 104                 v = PyString_FromString((char*)addr);
 105                 break;
 106 #ifdef macintosh
 107         case T_PSTRING:
 108                 if (*(char**)addr == NULL) {
 109                         Py_INCREF(Py_None);
 110                         v = Py_None;
 111                 }
 112                 else
 113                         v = PyString_FromStringAndSize(
 114                                 (*(char**)addr)+1,
 115                                 **(unsigned char**)addr);
 116                 break;
 117         case T_PSTRING_INPLACE:
 118                 v = PyString_FromStringAndSize(
 119                         ((char*)addr)+1,
 120                         *(unsigned char*)addr);
 121                 break;
 122 #endif /* macintosh */
 123         case T_CHAR:
 124                 v = PyString_FromStringAndSize((char*)addr, 1);
 125                 break;
 126         case T_OBJECT:
 127                 v = *(PyObject **)addr;
 128                 if (v == NULL)
 129                         v = Py_None;
 130                 Py_INCREF(v);
 131                 break;
 132         default:
 133                 PyErr_SetString(PyExc_SystemError, "bad memberdescr type");
 134                 v = NULL;
 135         }
 136         return v;
 137 }
 138
 139 int
 140 PyMember_Set(char *addr, struct memberlist *mlist, char *name, PyObject *v)
 141 {
 142         struct memberlist *l;
 143
 144         for (l = mlist; l->name != NULL; l++) {
 145                 if (strcmp(l->name, name) == 0) {
 146                         PyMemberDef copy;
 147                         copy.name = l->name;
 148                         copy.type = l->type;
 149                         copy.offset = l->offset;
 150                         copy.flags = l->flags;
 151                         copy.doc = NULL;
 152                         return PyMember_SetOne(addr, &copy, v);
 153                 }
 154         }
 155
 156         PyErr_SetString(PyExc_AttributeError, name);
 157         return -1;
 158 }
 159
 160 int
 161 PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v)
 162 {
 163         PyObject *oldv;
 164
 165         if ((l->flags & READONLY) || l->type == T_STRING
 166 #ifdef macintosh
 167             || l->type == T_PSTRING
 168 #endif
 169                 )
 170         {
 171                 PyErr_SetString(PyExc_TypeError, "readonly attribute");
 172                 return -1;
 173         }
 174         if ((l->flags & WRITE_RESTRICTED) && PyEval_GetRestricted()) {
 175                 PyErr_SetString(PyExc_RuntimeError, "restricted attribute");
 176                 return -1;
 177         }
 178         if (v == NULL && l->type != T_OBJECT) {
 179                 PyErr_SetString(PyExc_TypeError,
 180                                 "can't delete numeric/char attribute");
 181                 return -1;
 182         }
 183         addr += l->offset;
 184         switch (l->type) {
 185         case T_BYTE:
 186         case T_UBYTE:
 187                 if (!PyInt_Check(v)) {
 188                         PyErr_BadArgument();
 189                         return -1;
 190                 }
 191                 *(char*)addr = (char) PyInt_AsLong(v);
 192                 break;
 193         case T_SHORT:
 194         case T_USHORT:
 195                 if (!PyInt_Check(v)) {
 196                         PyErr_BadArgument();
 197                         return -1;
 198                 }
 199                 *(short*)addr = (short) PyInt_AsLong(v);
 200                 break;
 201         case T_UINT:
 202         case T_INT:
 203                 if (!PyInt_Check(v)) {
 204                         PyErr_BadArgument();
 205                         return -1;
 206                 }
 207                 *(int*)addr = (int) PyInt_AsLong(v);
 208                 break;
 209         case T_LONG:
 210                 if (!PyInt_Check(v)) {
 211                         PyErr_BadArgument();
 212                         return -1;
 213                 }
 214                 *(long*)addr = PyInt_AsLong(v);
 215                 break;
 216         case T_ULONG:
 217                 if (PyInt_Check(v))
 218                         *(long*)addr = PyInt_AsLong(v);
 219                 else if (PyLong_Check(v))
 220                         *(long*)addr = PyLong_AsLong(v);
 221                 else {
 222                         PyErr_BadArgument();
 223                         return -1;
 224                 }
 225                 break;
 226         case T_FLOAT:
 227                 if (PyInt_Check(v))
 228                         *(float*)addr =
 229                                 (float) PyInt_AsLong(v);
 230                 else if (PyFloat_Check(v))
 231                         *(float*)addr =
 232                                 (float) PyFloat_AsDouble(v);
 233                 else {
 234                         PyErr_BadArgument();
 235                         return -1;
 236                 }
 237                 break;
 238         case T_DOUBLE:
 239                 if (PyInt_Check(v))
 240                         *(double*)addr = (double) PyInt_AsLong(v);
 241                 else if (PyFloat_Check(v))
 242                         *(double*)addr = PyFloat_AsDouble(v);
 243                 else {
 244                         PyErr_BadArgument();
 245                         return -1;
 246                 }
 247                 break;
 248         case T_OBJECT:
 249                 Py_XINCREF(v);
 250                 oldv = *(PyObject **)addr;
 251                 *(PyObject **)addr = v;
 252                 Py_XDECREF(oldv);
 253                 break;
 254         case T_CHAR:
 255                 if (PyString_Check(v) && PyString_Size(v) == 1) {
 256                         *(char*)addr = PyString_AsString(v)[0];
 257                 }
 258                 else {
 259                         PyErr_BadArgument();
 260                         return -1;
 261                 }
 262                 break;
 263         default:
 264                 PyErr_SetString(PyExc_SystemError, "bad memberdescr type");
 265                 return -1;
 266         }
 267         return 0;
 268 }