static PyObject *getattro(PyObject *self, PyObject *obname) {
char *name=PYWIN_ATTR_CONVERT(obname);
if (name==NULL)
return NULL;
if (strcmp(name, "__members__")==0) {
PyObject *ret = PyList_New(4);
if (ret) {
PyList_SET_ITEM(ret, 0, PyString_FromString("AttrName"));
PyList_SET_ITEM(ret, 1, PyString_FromString("ControlCode"));
PyList_SET_ITEM(ret, 2, PyString_FromString("ADsType"));
PyList_SET_ITEM(ret, 3, PyString_FromString("Values"));
}
return ret;
}
if (strcmp(name, "Values")==0) {
PyObject *ret = ((PyADS_ATTR_INFO *)self)->obValues ?
((PyADS_ATTR_INFO *)self)->obValues :
Py_None;
Py_INCREF(ret);
return ret;
}
return PyObject_GenericGetAttr(self, obname);
}
/**
* @brief This function implements the generic attribute getting that
* allows to perform complex member resolution (not merely direct
* member access).
*/
PyObject * py_axl_doc_get_attr (PyObject *o, PyObject *attr_name) {
const char * attr = NULL;
PyObject * result;
PyAxlDoc * self = (PyAxlDoc *) o;
/* now implement other attributes */
if (! PyArg_Parse (attr_name, "s", &attr))
return NULL;
__axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "received request to report doc attr name %s (self: %p)",
attr, o);
if (axl_cmp (attr, "encoding")) {
/* encoding */
return Py_BuildValue ("s", axl_doc_get_encoding (self->doc));
} else if (axl_cmp (attr, "standalone") || axl_cmp (attr, "stand_alone")) {
/* standalone */
return Py_BuildValue ("i", axl_doc_get_standalone (self->doc));
} else if (axl_cmp (attr, "root")) {
if (axl_doc_get_root (self->doc) == NULL) {
Py_INCREF (Py_None);
return Py_None;
}
/* return root axl node: signaling to not finish the
* internal copy once it is collected the reference */
__axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "reporting root node (doc ref: %p, ref count: %d)",
self, self->ob_refcnt);
return py_axl_node_create (axl_doc_get_root (self->doc), axl_false, o);
}
/* first implement generic attr already defined */
result = PyObject_GenericGetAttr (o, attr_name);
if (result)
return result;
return NULL;
}
static PyObject*
module_getattro(PyModuleObject *m, PyObject *name)
{
PyObject *attr, *mod_name;
attr = PyObject_GenericGetAttr((PyObject *)m, name);
if (attr || !PyErr_ExceptionMatches(PyExc_AttributeError))
return attr;
PyErr_Clear();
if (m->md_dict) {
_Py_IDENTIFIER(__name__);
mod_name = _PyDict_GetItemId(m->md_dict, &PyId___name__);
if (mod_name) {
PyErr_Format(PyExc_AttributeError,
"module '%U' has no attribute '%U'", mod_name, name);
return NULL;
}
else if (PyErr_Occurred()) {
PyErr_Clear();
}
}
PyErr_Format(PyExc_AttributeError,
"module has no attribute '%U'", name);
return NULL;
}
bool fillQtProperties(PyObject* qObj, const QMetaObject* metaObj, PyObject* kwds, const char** blackList, unsigned int blackListSize)
{
PyObject *key, *value;
Py_ssize_t pos = 0;
while (PyDict_Next(kwds, &pos, &key, &value)) {
if (!blackListSize || !std::binary_search(blackList, blackList + blackListSize, std::string(Shiboken::String::toCString(key)))) {
QByteArray propName(Shiboken::String::toCString(key));
if (metaObj->indexOfProperty(propName) != -1) {
propName[0] = std::toupper(propName[0]);
propName.prepend("set");
Shiboken::AutoDecRef propSetter(PyObject_GetAttrString(qObj, propName.constData()));
if (!propSetter.isNull()) {
Shiboken::AutoDecRef args(PyTuple_Pack(1, value));
Shiboken::AutoDecRef retval(PyObject_CallObject(propSetter, args));
} else {
PyObject* attr = PyObject_GenericGetAttr(qObj, key);
if (PySide::Property::checkType(attr))
PySide::Property::setValue(reinterpret_cast<PySideProperty*>(attr), qObj, value);
}
} else {
propName.append("()");
if (metaObj->indexOfSignal(propName) != -1) {
propName.prepend('2');
PySide::Signal::connect(qObj, propName, value);
} else {
PyErr_Format(PyExc_AttributeError, "'%s' is not a Qt property or a signal", propName.constData());
return false;
};
}
}
}
return true;
}
static PyObject *
oss_getattro(oss_audio_t *self, PyObject *nameobj)
{
char *name = "";
PyObject * rval = NULL;
if (PyUnicode_Check(nameobj))
name = _PyUnicode_AsString(nameobj);
if (strcmp(name, "closed") == 0) {
rval = (self->fd == -1) ? Py_True : Py_False;
Py_INCREF(rval);
}
else if (strcmp(name, "name") == 0) {
rval = PyUnicode_FromString(self->devicename);
}
else if (strcmp(name, "mode") == 0) {
/* No need for a "default" in this switch: from newossobject(),
self->mode can only be one of these three values. */
switch(self->mode) {
case O_RDONLY:
rval = PyUnicode_FromString("r");
break;
case O_RDWR:
rval = PyUnicode_FromString("rw");
break;
case O_WRONLY:
rval = PyUnicode_FromString("w");
break;
}
}
else {
rval = PyObject_GenericGetAttr((PyObject *)self, nameobj);
}
return rval;
}
static PyObject *
BaseRowProxy_getattro(BaseRowProxy *self, PyObject *name)
{
PyObject *tmp;
if (!(tmp = PyObject_GenericGetAttr((PyObject *)self, name))) {
if (!PyErr_ExceptionMatches(PyExc_AttributeError))
return NULL;
PyErr_Clear();
}
else
return tmp;
tmp = BaseRowProxy_subscript(self, name);
if (tmp == NULL && PyErr_ExceptionMatches(PyExc_KeyError)) {
PyErr_Format(
PyExc_AttributeError,
"Could not locate column in row for column '%.200s'",
PyString_AsString(name)
);
return NULL;
}
return tmp;
}
static PyObject*
Per_getattro(cPersistentObject *self, PyObject *name)
{
PyObject *result = NULL; /* guilty until proved innocent */
PyObject *converted;
char *s;
converted = convert_name(name);
if (!converted)
goto Done;
s = PyBytes_AS_STRING(converted);
if (unghost_getattr(s))
{
if (unghostify(self) < 0)
goto Done;
accessed(self);
}
result = PyObject_GenericGetAttr((PyObject *)self, name);
Done:
Py_XDECREF(converted);
return result;
}
static PyObject * rpmfi_getattro(PyObject * o, PyObject * n)
/*@*/
{
return PyObject_GenericGetAttr(o, n);
}
static PyObject * Match_getattro(
PyObject *self,
PyObject *name)
{
return PyObject_GenericGetAttr(self, name);
}
static PyObject *
fortran_getattr(PyFortranObject *fp, char *name) {
int i,j,k,flag;
if (fp->dict != NULL) {
PyObject *v = PyDict_GetItemString(fp->dict, name);
if (v != NULL) {
Py_INCREF(v);
return v;
}
}
for (i=0,j=1;i<fp->len && (j=strcmp(name,fp->defs[i].name));i++);
if (j==0)
if (fp->defs[i].rank!=-1) { /* F90 allocatable array */
if (fp->defs[i].func==NULL) return NULL;
for(k=0;k<fp->defs[i].rank;++k)
fp->defs[i].dims.d[k]=-1;
save_def = &fp->defs[i];
(*(fp->defs[i].func))(&fp->defs[i].rank,fp->defs[i].dims.d,set_data,&flag);
if (flag==2)
k = fp->defs[i].rank + 1;
else
k = fp->defs[i].rank;
if (fp->defs[i].data !=NULL) { /* array is allocated */
PyObject *v = PyArray_New(&PyArray_Type, k, fp->defs[i].dims.d,
fp->defs[i].type, NULL, fp->defs[i].data, 0, NPY_FARRAY,
NULL);
if (v==NULL) return NULL;
/* Py_INCREF(v); */
return v;
} else { /* array is not allocated */
Py_INCREF(Py_None);
return Py_None;
}
}
if (strcmp(name,"__dict__")==0) {
Py_INCREF(fp->dict);
return fp->dict;
}
if (strcmp(name,"__doc__")==0) {
#if PY_VERSION_HEX >= 0x03000000
PyObject *s = PyUnicode_FromString(""), *s2, *s3;
for (i=0;i<fp->len;i++) {
s2 = fortran_doc(fp->defs[i]);
s3 = PyUnicode_Concat(s, s2);
Py_DECREF(s2);
Py_DECREF(s);
s = s3;
}
#else
PyObject *s = PyString_FromString("");
for (i=0;i<fp->len;i++)
PyString_ConcatAndDel(&s,fortran_doc(fp->defs[i]));
#endif
if (PyDict_SetItemString(fp->dict, name, s))
return NULL;
return s;
}
if ((strcmp(name,"_cpointer")==0) && (fp->len==1)) {
PyObject *cobj = F2PyCapsule_FromVoidPtr((void *)(fp->defs[0].data),NULL);
if (PyDict_SetItemString(fp->dict, name, cobj))
return NULL;
return cobj;
}
#if PY_VERSION_HEX >= 0x03000000
if (1) {
PyObject *str, *ret;
str = PyUnicode_FromString(name);
ret = PyObject_GenericGetAttr((PyObject *)fp, str);
Py_DECREF(str);
return ret;
}
#else
return Py_FindMethod(fortran_methods, (PyObject *)fp, name);
#endif
}
PyObject *PySTGMEDIUM::getattro(PyObject *self, PyObject *obname)
{
char *name=PYWIN_ATTR_CONVERT(obname);
if (name==NULL)
return NULL;
PySTGMEDIUM *ps = (PySTGMEDIUM *)self;
// @prop int|tymed|An integer indicating the type of data in the stgmedium
if (strcmp(name, "tymed")==0)
return PyInt_FromLong(ps->medium.tymed);
// @prop object|data|The data in the stgmedium.
// The result depends on the value of the 'tymed' property of the <o PySTGMEDIUM> object.
// @flagh tymed|Result Type
if (strcmp(name, "data")==0) {
switch (ps->medium.tymed) {
// @flag TYMED_GDI|An integer GDI handle
case TYMED_GDI:
return PyLong_FromVoidPtr(ps->medium.hBitmap);
// @flag TYMED_MFPICT|An integer METAFILE handle
case TYMED_MFPICT:
return PyLong_FromVoidPtr(ps->medium.hMetaFilePict);
// @flag TYMED_ENHMF|An integer ENHMETAFILE handle
case TYMED_ENHMF:
return PyLong_FromVoidPtr(ps->medium.hEnhMetaFile);
// @flag TYMED_HGLOBAL|A string with the bytes of the global memory object.
case TYMED_HGLOBAL: {
PyObject *ret;
void *p = GlobalLock(ps->medium.hGlobal);
if (p) {
ret = PyString_FromStringAndSize( (char *)p, GlobalSize(ps->medium.hGlobal));
GlobalUnlock(ps->medium.hGlobal);
} else {
ret = Py_None;
Py_INCREF(Py_None);
}
return ret;
}
// @flag TYMED_FILE|A string/unicode filename
case TYMED_FILE:
return PyWinObject_FromWCHAR(ps->medium.lpszFileName);
// @flag TYMED_ISTREAM|A <o PyIStream> object
case TYMED_ISTREAM:
// @flag TYMED_ISTORAGE|A <o PyIStorage> object
return PyCom_PyObjectFromIUnknown(ps->medium.pstm, IID_IStream, TRUE);
case TYMED_ISTORAGE:
return PyCom_PyObjectFromIUnknown(ps->medium.pstg, IID_IStorage, TRUE);
case TYMED_NULL:
PyErr_SetString(PyExc_ValueError, "This STGMEDIUM has no data");
return NULL;
default:
PyErr_SetString(PyExc_RuntimeError, "Unknown tymed");
return NULL;
}
}
// @prop int|data_handle|The raw 'integer' representation of the data.
// For TYMED_HGLOBAL, this is the handle rather than the string data.
// For the string and interface types, this is an integer holding the pointer.
if (strcmp(name, "data_handle")==0) {
switch (ps->medium.tymed) {
case TYMED_GDI:
return PyLong_FromVoidPtr(ps->medium.hBitmap);
case TYMED_MFPICT:
return PyLong_FromVoidPtr(ps->medium.hMetaFilePict);
case TYMED_ENHMF:
return PyLong_FromVoidPtr(ps->medium.hEnhMetaFile);
case TYMED_HGLOBAL:
return PyLong_FromVoidPtr(ps->medium.hGlobal);
// and may as well hand out the pointers for these.
// We are all consenting adults :)
case TYMED_FILE:
return PyLong_FromVoidPtr(ps->medium.lpszFileName);
case TYMED_ISTREAM:
return PyLong_FromVoidPtr(ps->medium.pstm);
case TYMED_ISTORAGE:
return PyLong_FromVoidPtr(ps->medium.pstg);
case TYMED_NULL:
PyErr_SetString(PyExc_ValueError, "This STGMEDIUM has no data");
return NULL;
default:
PyErr_SetString(PyExc_RuntimeError, "Unknown tymed");
return NULL;
}
}
return PyObject_GenericGetAttr(self, obname);
}
static PyObject * rpmal_getattro(PyObject * o, PyObject * n)
{
return PyObject_GenericGetAttr(o, n);
}
static PyObject *PySilcUser_GetAttr(PyObject *self, PyObject *name)
{
// expose the following attributes as readonly
// - char *nickname
// - char *username
// - char *hostname
// - char *server
// - char *realname
// - unsigned char *fingerprint;
// SilcUInt32 finderprint_len;
//
// - 64/160 bit user id
// - unsigned int mode
// - (TODO) attrs;
// - (TODO) public_key;
// - int status
// - (TODO) channels
// - int resolve_cmd_ident;
int result;
PyObject *temp = NULL, *value = NULL;
PySilcUser *pyuser = (PySilcUser *)self;
if (!pyuser->silcobj)
goto cleanup;
// check for nickname
temp = PyString_FromString("nickname");
if (PyObject_Cmp(temp, name, &result) == -1)
goto cleanup;
if (result == 0) {
if (pyuser->silcobj->nickname)
value = PyString_FromString(pyuser->silcobj->nickname);
else {
value = Py_None;
Py_INCREF(value);
}
goto cleanup;
}
// check for username
Py_DECREF(temp);
temp = PyString_FromString("username");
if (PyObject_Cmp(temp, name, &result) == -1)
goto cleanup;
if (result == 0) {
if (pyuser->silcobj->username)
value = PyString_FromString(pyuser->silcobj->username);
else {
value = Py_None;
Py_INCREF(value);
}
goto cleanup;
}
// check for hostname
Py_DECREF(temp);
temp = PyString_FromString("hostname");
if (PyObject_Cmp(temp, name, &result) == -1)
goto cleanup;
if (result == 0) {
if (pyuser->silcobj->hostname)
value = PyString_FromString(pyuser->silcobj->hostname);
else {
value = Py_None;
Py_INCREF(value);
}
goto cleanup;
}
// check for server
Py_DECREF(temp);
temp = PyString_FromString("server");
if (PyObject_Cmp(temp, name, &result) == -1)
goto cleanup;
if (result == 0) {
if (pyuser->silcobj->server)
value = PyString_FromString(pyuser->silcobj->server);
else {
value = Py_None;
Py_INCREF(value);
}
goto cleanup;
}
// check for realname
Py_DECREF(temp);
temp = PyString_FromString("realname");
if (PyObject_Cmp(temp, name, &result) == -1)
goto cleanup;
if (result == 0) {
if (pyuser->silcobj->realname)
value = PyString_FromString(pyuser->silcobj->realname);
else {
value = Py_None;
Py_INCREF(value);
}
goto cleanup;
}
// check for fingerprint
Py_DECREF(temp);
temp = PyString_FromString("fingerprint");
if (PyObject_Cmp(temp, name, &result) == -1)
goto cleanup;
if (result == 0) {
if (pyuser->silcobj->fingerprint)
value = PyString_FromStringAndSize(pyuser->silcobj->fingerprint, pyuser->silcobj->fingerprint_len);
else {
value = Py_None;
Py_INCREF(value);
}
goto cleanup;
}
// check for user id
Py_DECREF(temp);
temp = PyString_FromString("user_id");
if (PyObject_Cmp(temp, name, &result) == -1)
goto cleanup;
if (result == 0) {
char buf[224];
memcpy(&buf, (pyuser->silcobj->id), 224);
value = PyString_FromStringAndSize(buf, 224);
goto cleanup;
}
// check for mode
Py_DECREF(temp);
temp = PyString_FromString("mode");
if (PyObject_Cmp(temp, name, &result) == -1)
goto cleanup;
if (result == 0) {
value = PyInt_FromLong(pyuser->silcobj->mode);
goto cleanup;
}
// check for status
Py_DECREF(temp);
temp = PyString_FromString("status");
if (PyObject_Cmp(temp, name, &result) == -1)
goto cleanup;
if (result == 0) {
value = PyInt_FromLong(pyuser->silcobj->status);
goto cleanup;
}
// check for resolve_cmd_ident
Py_DECREF(temp);
temp = PyString_FromString("resolve_cmd_ident");
if (PyObject_Cmp(temp, name, &result) == -1)
goto cleanup;
if (result == 0) {
value = PyInt_FromLong(pyuser->silcobj->resolve_cmd_ident);
goto cleanup;
}
cleanup:
Py_XDECREF(temp);
if (value)
return value;
else
return PyObject_GenericGetAttr(self, name);
}
static PyObject *
potential_getattro(potential_t *self, PyObject *pyname)
{
char *name;
property_t *p;
PyObject *r = NULL;
PyArrayObject *arr;
npy_intp dims[3];
double *data;
PyObject **odata;
int i, j, k;
name = PyString_AsString(pyname);
if (!name)
return NULL;
p = self->f90members->first_property;
while (p != NULL && strcmp(p->name, name)) {
p = p->next;
}
if (p) {
r = NULL;
switch (p->kind) {
case PK_INT:
r = PyInt_FromLong(*((int*) p->ptr));
break;
case PK_DOUBLE:
r = PyFloat_FromDouble(*((double*) p->ptr));
break;
case PK_BOOL:
r = PyBool_FromLong(*((BOOL*) p->ptr));
break;
case PK_LIST:
if (*p->tag5 == 1) {
r = PyFloat_FromDouble(*((double*) p->ptr));
} else {
dims[0] = *p->tag5;
arr = (PyArrayObject*) PyArray_SimpleNew(1, (npy_intp*) dims,
NPY_DOUBLE);
data = (double *) PyArray_DATA(arr);
for (i = 0; i < *p->tag5; i++) {
data[i] = ((double*) p->ptr)[i];
}
r = (PyObject*) arr;
}
break;
case PK_FORTRAN_STRING_LIST:
if (*p->tag5 == 1) {
r = fstring_to_pystring((char*) p->ptr, p->tag);
} else {
dims[0] = *p->tag5;
arr = (PyArrayObject*) PyArray_SimpleNew(1, (npy_intp*) dims,
NPY_OBJECT);
odata = (PyObject **) PyArray_DATA(arr);
for (i = 0; i < *p->tag5; i++) {
odata[i] = fstring_to_pystring(((char*) p->ptr + i*p->tag), p->tag);
}
r = (PyObject*) arr;
}
break;
case PK_ARRAY2D:
dims[0] = p->tag;
dims[1] = p->tag2;
arr = (PyArrayObject*) PyArray_SimpleNew(2, (npy_intp*) dims, NPY_DOUBLE);
data = (double *) PyArray_DATA(arr);
for (i = 0; i < p->tag; i++) {
for (j = 0; j < p->tag2; j++) {
data[j + i*p->tag2] = ((double*) p->ptr)[i + j*p->tag];
}
}
// memcpy(data, p->ptr, p->tag*p->tag2*sizeof(double));
r = (PyObject*) arr;
break;
case PK_ARRAY3D:
dims[0] = p->tag;
dims[1] = p->tag2;
dims[2] = p->tag3;
arr = (PyArrayObject*) PyArray_SimpleNew(3, (npy_intp*) dims, NPY_DOUBLE);
data = (double *) PyArray_DATA(arr);
for (i = 0; i < p->tag; i++) {
for (j = 0; j < p->tag2; j++) {
for (k = 0; k < p->tag3; k++) {
data[k + (j + i*p->tag2)*p->tag3] =
((double*) p->ptr)[i + (j + k*p->tag2)*p->tag];
}
}
}
// memcpy(data, p->ptr, p->tag*p->tag2*p->tag3*sizeof(double));
r = (PyObject*) arr;
break;
default:
PyErr_SetString(PyExc_TypeError, "Internal error: Unknown type encountered in section.");
break;
}
} else {
r = PyObject_GenericGetAttr((PyObject *) self, pyname);
// Py_FindMethod(self->ob_type->tp_methods, (PyObject *) self, name);
}
return r;
}
static PyObject *
keymap_getattr(PyKeyMapObject *self, PyObject *name)
{
return PyObject_GenericGetAttr((PyObject *)self, name);
}
static void initialize_bin_for_strictypes(AerospikeClient *self, as_error *err, PyObject *py_value, as_binop *binop, char *bin, as_static_pool *static_pool) {
as_bin *binop_bin = &binop->bin;
if (PyInt_Check(py_value)) {
int val = PyInt_AsLong(py_value);
as_integer_init((as_integer *) &binop_bin->value, val);
binop_bin->valuep = &binop_bin->value;
} else if (PyLong_Check(py_value)) {
long val = PyLong_AsLong(py_value);
as_integer_init((as_integer *) &binop_bin->value, val);
binop_bin->valuep = &binop_bin->value;
} else if (PyString_Check(py_value)) {
char * val = PyString_AsString(py_value);
as_string_init((as_string *) &binop_bin->value, val, false);
binop_bin->valuep = &binop_bin->value;
} else if (PyUnicode_Check(py_value)) {
PyObject *py_ustr1 = PyUnicode_AsUTF8String(py_value);
char * val = PyString_AsString(py_ustr1);
as_string_init((as_string *) &binop_bin->value, val, false);
binop_bin->valuep = &binop_bin->value;
} else if (PyFloat_Check(py_value)) {
int64_t val = PyFloat_AsDouble(py_value);
if (aerospike_has_double(self->as)) {
as_double_init((as_double *) &binop_bin->value, val);
binop_bin->valuep = &binop_bin->value;
} else {
as_bytes *bytes;
GET_BYTES_POOL(bytes, static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_value, err);
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) bytes;
}
} else if (PyList_Check(py_value)) {
as_list * list = NULL;
pyobject_to_list(self, err, py_value, &list, static_pool, SERIALIZER_PYTHON);
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) list;
} else if (PyDict_Check(py_value)) {
as_map * map = NULL;
pyobject_to_map(self, err, py_value, &map, static_pool, SERIALIZER_PYTHON);
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) map;
} else if (!strcmp(py_value->ob_type->tp_name, "aerospike.Geospatial")) {
PyObject* py_data = PyObject_GenericGetAttr(py_value, PyString_FromString("geo_data"));
char *geo_value = PyString_AsString(AerospikeGeospatial_DoDumps(py_data, err));
if (aerospike_has_geo(self->as)) {
as_geojson_init((as_geojson *) &binop_bin->value, geo_value, false);
binop_bin->valuep = &binop_bin->value;
} else {
as_bytes *bytes;
GET_BYTES_POOL(bytes, static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_data, err);
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) bytes;
}
} else if (!strcmp(py_value->ob_type->tp_name, "aerospike.null")) {
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) &as_nil;
} else if (PyByteArray_Check(py_value)) {
as_bytes *bytes;
GET_BYTES_POOL(bytes, static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_value, err);
as_bytes_init_wrap((as_bytes *) &binop_bin->value, bytes->value, bytes->size, false);
binop_bin->valuep = &binop_bin->value;
} else {
as_bytes *bytes;
GET_BYTES_POOL(bytes, static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_value, err);
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) bytes;
}
strcpy(binop_bin->name, bin);
}
static PyObject* segment_getattro(NPySegObj* self, PyObject* name) {
Symbol* sym;
Py_INCREF(name);
char* n = PyString_AsString(name);
//printf("segment_getattr %s\n", n);
PyObject* result = 0;
PyObject* otype;
PyObject* rv;
if (strcmp(n, "v") == 0) {
Node* nd = node_exact(self->pysec_->sec_, self->x_);
result = Py_BuildValue("d", NODEV(nd));
}else if ((otype = PyDict_GetItemString(pmech_types, n)) != NULL) {
int type = PyInt_AsLong(otype);
//printf("segment_getattr type=%d\n", type);
Node* nd = node_exact(self->pysec_->sec_, self->x_);
Prop* p = nrn_mechanism(type, nd);
if (!p) {
rv_noexist(self->pysec_->sec_, n, self->x_, 1);
Py_DECREF(name);
return NULL;
}
NPyMechObj* m = PyObject_New(NPyMechObj, pmech_generic_type);
if (m == NULL) {
Py_DECREF(name);
return NULL;
}
m->pyseg_ = self;
m->prop_ = p;
Py_INCREF(m->pyseg_);
result = (PyObject*)m;
}else if ((rv = PyDict_GetItemString(rangevars_, n)) != NULL) {
sym = ((NPyRangeVar*)rv)->sym_;
if (ISARRAY(sym)) {
NPyRangeVar* r = PyObject_New(NPyRangeVar, range_type);
r->pyseg_ = self;
Py_INCREF(r->pyseg_);
r->sym_ = sym;
r->isptr_ = 0;
result = (PyObject*)r;
}else{
int err;
double* d = nrnpy_rangepointer(self->pysec_->sec_, sym, self->x_, &err);
if (!d) {
rv_noexist(self->pysec_->sec_, n, self->x_, err);
result = NULL;
}else{
result = Py_BuildValue("d", *d);
}
}
}else if (strncmp(n, "_ref_", 5) == 0) {
if (strcmp(n+5, "v") == 0) {
Node* nd = node_exact(self->pysec_->sec_, self->x_);
result = nrn_hocobj_ptr(&(NODEV(nd)));
}else if ((sym = hoc_table_lookup(n+5, hoc_built_in_symlist)) != 0 && sym->type == RANGEVAR) {
if (ISARRAY(sym)) {
NPyRangeVar* r = PyObject_New(NPyRangeVar, range_type);
r->pyseg_ = self;
Py_INCREF(r->pyseg_);
r->sym_ = sym;
r->isptr_ = 1;
result = (PyObject*)r;
}else{
int err;
double* d = nrnpy_rangepointer(self->pysec_->sec_, sym, self->x_, &err);
if (!d) {
rv_noexist(self->pysec_->sec_, n+5, self->x_, err);
result = NULL;
}else{
result = nrn_hocobj_ptr(d);
}
}
}else{
rv_noexist(self->pysec_->sec_, n, self->x_, 2);
result = NULL;
}
}else if (strcmp(n, "__dict__") == 0) {
Node* nd = node_exact(self->pysec_->sec_, self->x_);
result = PyDict_New();
assert(PyDict_SetItemString(result, "v", Py_None) == 0);
assert(PyDict_SetItemString(result, "diam", Py_None) == 0);
assert(PyDict_SetItemString(result, "cm", Py_None) == 0);
for (Prop* p = nd->prop; p ; p = p->next) {
if (p->type > CAP && !memb_func[p->type].is_point){
char* pn = memb_func[p->type].sym->name;
assert(PyDict_SetItemString(result, pn, Py_None) == 0);
}
}
}else{
result = PyObject_GenericGetAttr((PyObject*)self, name);
}
Py_DECREF(name);
return result;
}
CounterLEObject_getattr(PyObject *s, char *name)
#endif
{
PCT_CounterObject *self = (PCT_CounterObject *)s;
#ifdef IS_PY3K
if (!PyUnicode_Check(attr))
goto generic;
if (PyUnicode_CompareWithASCIIString(attr, "carry") == 0) {
#else
if (strcmp(name, "carry") == 0) {
#endif
return PyLong_FromLong((long)self->carry);
#ifdef IS_PY3K
} else if (!self->shortcut_disabled && PyUnicode_CompareWithASCIIString(attr, "__PCT_CTR_SHORTCUT__") == 0) {
#else
} else if (!self->shortcut_disabled && strcmp(name, "__PCT_CTR_SHORTCUT__") == 0) {
#endif
/* Shortcut hack - See block_template.c */
Py_INCREF(Py_True);
return Py_True;
}
#ifdef IS_PY3K
generic:
return PyObject_GenericGetAttr(s, attr);
#else
return Py_FindMethod(CounterLEObject_methods, (PyObject *)self, name);
#endif
}
static PyObject *
#ifdef IS_PY3K
CounterBEObject_getattro(PyObject *s, PyObject *attr)
#else
CounterBEObject_getattr(PyObject *s, char *name)
#endif
{
PCT_CounterObject *self = (PCT_CounterObject *)s;
#ifdef IS_PY3K
if (!PyUnicode_Check(attr))
goto generic;
if (PyUnicode_CompareWithASCIIString(attr, "carry") == 0) {
#else
if (strcmp(name, "carry") == 0) {
#endif
return PyLong_FromLong((long)self->carry);
#ifdef IS_PY3K
} else if (!self->shortcut_disabled && PyUnicode_CompareWithASCIIString(attr, "__PCT_CTR_SHORTCUT__") == 0) {
#else
} else if (!self->shortcut_disabled && strcmp(name, "__PCT_CTR_SHORTCUT__") == 0) {
#endif
/* Shortcut hack - See block_template.c */
Py_INCREF(Py_True);
return Py_True;
}
#ifdef IS_PY3K
generic:
return PyObject_GenericGetAttr(s, attr);
#else
return Py_FindMethod(CounterBEObject_methods, (PyObject *)self, name);
#endif
}
static PyTypeObject
my_CounterLEType = {
#ifdef IS_PY3K
PyVarObject_HEAD_INIT(NULL, 0) /* deferred type init for compilation on Windows, type will be filled in at runtime */
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"_counter.CounterLE", /* tp_name */
sizeof(PCT_CounterObject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)CounterObject_dealloc, /* tp_dealloc */
0, /* tp_print */
#ifdef IS_PY3K
0, /* tp_getattr */
#else
CounterLEObject_getattr, /* tp_getattr */
#endif
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
(ternaryfunc)CounterObject_call, /* tp_call */
0, /* tp_str */
#ifdef IS_PY3K
CounterLEObject_getattro, /* tp_getattro */
#else
0, /* tp_getattro */
#endif
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
"Counter (little endian)", /* tp_doc */
#ifdef IS_PY3K
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
CounterLEObject_methods, /*tp_methods*/
#endif
};
static PyTypeObject
my_CounterBEType = {
#ifdef IS_PY3K
PyVarObject_HEAD_INIT(NULL, 0) /* deferred type init for compilation on Windows, type will be filled in at runtime */
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"_counter.CounterBE", /* tp_name */
sizeof(PCT_CounterObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)CounterObject_dealloc, /* tp_dealloc */
0, /* tp_print */
#ifdef IS_PY3K
0, /* tp_getattr */
#else
CounterBEObject_getattr, /* tp_getattr */
#endif
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
(ternaryfunc)CounterObject_call, /* tp_call */
0, /* tp_str */
#ifdef IS_PY3K
CounterBEObject_getattro, /* tp_getattro */
#else
0, /* tp_getattro */
#endif
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
"Counter (big endian)", /* tp_doc */
#ifdef IS_PY3K
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
CounterBEObject_methods, /*tp_methods*/
#endif
};
/*
* Python 2.1 doesn't seem to allow a C equivalent of the __init__ method, so
* we use the module-level functions newLE and newBE here.
*/
static PyObject *
CounterLE_new(PyObject *self, PyObject *args, PyObject *kwargs)
{
PCT_CounterObject *obj = NULL;
/* Create the new object */
obj = PyObject_New(PCT_CounterObject, &my_CounterLEType);
if (obj == NULL) {
return NULL;
}
/* Zero the custom portion of the structure */
memset(&obj->prefix, 0, sizeof(PCT_CounterObject) - offsetof(PCT_CounterObject, prefix));
/* Call the object's initializer. Delete the object if this fails. */
if (CounterObject_init(obj, args, kwargs) != 0) {
return NULL;
}
/* Set the inc_func pointer */
obj->inc_func = (void (*)(void *))CounterLEObject_increment;
/* Return the object */
return (PyObject *)obj;
}
PyObject *PyRecord::getattro(PyObject *self, PyObject *obname)
{
PyObject *res;
PyRecord *pyrec = (PyRecord *)self;
char *name=PYWIN_ATTR_CONVERT(obname);
if (name==NULL)
return NULL;
if (strcmp(name, "__members__")==0) {
ULONG cnames = 0;
HRESULT hr = pyrec->pri->GetFieldNames(&cnames, NULL);
if (FAILED(hr))
return PyCom_BuildPyException(hr, pyrec->pri, IID_IRecordInfo);
BSTR *strs = (BSTR *)malloc(sizeof(BSTR) * cnames);
if (strs==NULL)
return PyErr_NoMemory();
hr = pyrec->pri->GetFieldNames(&cnames, strs);
if (FAILED(hr)) {
free(strs);
return PyCom_BuildPyException(hr, pyrec->pri, IID_IRecordInfo);
}
res = PyList_New(cnames);
for (ULONG i=0;i<cnames && res != NULL;i++) {
PyObject *item = PyWinCoreString_FromString(strs[i]);
SysFreeString(strs[i]);
if (item==NULL) {
Py_DECREF(res);
res = NULL;
} else
PyList_SET_ITEM(res, i, item); // ref count swallowed.
}
free(strs);
return res;
}
res = PyObject_GenericGetAttr(self, obname);
if (res != NULL)
return res;
PyErr_Clear();
WCHAR *wname;
if (!PyWinObject_AsWCHAR(obname, &wname))
return NULL;
VARIANT vret;
VariantInit(&vret);
void *sub_data = NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = pyrec->pri->GetFieldNoCopy(pyrec->pdata, wname, &vret, &sub_data);
PyWinObject_FreeWCHAR(wname);
PY_INTERFACE_POSTCALL;
if (FAILED(hr)) {
if (hr == TYPE_E_FIELDNOTFOUND){
// This is slightly suspect - throwing a unicode
// object for an AttributeError in py2k - but this
// is the value we asked COM for, so it makes sense...
// (and PyErr_Format doesn't handle unicode in py2x)
PyErr_SetObject(PyExc_AttributeError, obname);
return NULL;
}
return PyCom_BuildPyException(hr, pyrec->pri, IID_IRecordInfo);
}
// Short-circuit sub-structs and arrays here, so we dont allocate a new chunk
// of memory and copy it - we need sub-structs to persist.
if (V_VT(&vret)==(VT_BYREF | VT_RECORD))
return new PyRecord(V_RECORDINFO(&vret), V_RECORD(&vret), pyrec->owner);
else if (V_VT(&vret)==(VT_BYREF | VT_ARRAY | VT_RECORD)) {
SAFEARRAY *psa = *V_ARRAYREF(&vret);
int d = SafeArrayGetDim(psa);
if (sub_data==NULL)
return PyErr_Format(PyExc_RuntimeError, "Did not get a buffer for the array!");
if (SafeArrayGetDim(psa) != 1)
return PyErr_Format(PyExc_TypeError, "Only support single dimensional arrays of records");
IRecordInfo *sub = NULL;
long ubound, lbound, nelems;
int i;
BYTE *this_data;
PyObject *ret_tuple = NULL;
ULONG element_size = 0;
hr = SafeArrayGetUBound(psa, 1, &ubound);
if (FAILED(hr)) goto array_end;
hr = SafeArrayGetLBound(psa, 1, &lbound);
if (FAILED(hr)) goto array_end;
hr = SafeArrayGetRecordInfo(psa, &sub);
if (FAILED(hr)) goto array_end;
hr = sub->GetSize(&element_size);
if (FAILED(hr)) goto array_end;
nelems = ubound-lbound;
ret_tuple = PyTuple_New(nelems);
if (ret_tuple==NULL) goto array_end;
this_data = (BYTE *)sub_data;
for (i=0;i<nelems;i++) {
PyTuple_SET_ITEM(ret_tuple, i, new PyRecord(sub, this_data, pyrec->owner));
this_data += element_size;
}
array_end:
if (sub)
sub->Release();
if (FAILED(hr))
return PyCom_BuildPyException(hr, pyrec->pri, IID_IRecordInfo);
return ret_tuple;
}
// This default conversion we use is a little slow (but it will do!)
// For arrays, the pparray->pvData member is *not* set, since the actual data
// pointer from the record is returned in sub_data, so set it here.
if (V_ISARRAY(&vret) && V_ISBYREF(&vret))
(*V_ARRAYREF(&vret))->pvData = sub_data;
PyObject *ret = PyCom_PyObjectFromVariant(&vret);
// VariantClear(&vret);
return ret;
}
Box* superGetattribute(Box* _s, Box* _attr) {
RELEASE_ASSERT(_s->cls == super_cls, "");
BoxedSuper* s = static_cast<BoxedSuper*>(_s);
RELEASE_ASSERT(_attr->cls == str_cls, "");
BoxedString* attr = static_cast<BoxedString*>(_attr);
bool skip = s->obj_type == NULL;
if (!skip) {
// Looks like __class__ is supposed to be "super", not the class of the the proxied object.
skip = (attr->s() == class_str);
}
if (!skip) {
PyObject* mro, *res, *tmp, *dict;
PyTypeObject* starttype;
descrgetfunc f;
Py_ssize_t i, n;
starttype = s->obj_type;
mro = starttype->tp_mro;
if (mro == NULL)
n = 0;
else {
assert(PyTuple_Check(mro));
n = PyTuple_GET_SIZE(mro);
}
for (i = 0; i < n; i++) {
if ((PyObject*)(s->type) == PyTuple_GET_ITEM(mro, i))
break;
}
i++;
res = NULL;
for (; i < n; i++) {
tmp = PyTuple_GET_ITEM(mro, i);
// Pyston change:
#if 0
if (PyType_Check(tmp))
dict = ((PyTypeObject *)tmp)->tp_dict;
else if (PyClass_Check(tmp))
dict = ((PyClassObject *)tmp)->cl_dict;
else
continue;
res = PyDict_GetItem(dict, name);
#endif
res = tmp->getattr(attr);
if (res != NULL) {
// Pyston change:
#if 0
Py_INCREF(res);
f = Py_TYPE(res)->tp_descr_get;
if (f != NULL) {
tmp = f(res,
/* Only pass 'obj' param if
this is instance-mode sper
(See SF ID #743627)
*/
(s->obj == (PyObject *)
s->obj_type
? (PyObject *)NULL
: s->obj),
(PyObject *)starttype);
Py_DECREF(res);
res = tmp;
}
#endif
return processDescriptor(res, (s->obj == s->obj_type ? None : s->obj), s->obj_type);
}
}
}
Box* rtn = PyObject_GenericGetAttr(s, attr);
if (!rtn)
throwCAPIException();
return rtn;
}
static PyObject *
pygvfinfo_getattr(PyGnomeVFSFileInfo *self, const gchar *attr)
{
GnomeVFSFileInfo *finfo;
finfo = self->finfo;
if (!strcmp(attr, "__members__")) {
return Py_BuildValue("[ssssssssssssssssss]", "atime", "block_count",
"ctime", "device", "flags", "gid", "inode",
"io_block_size", "link_count", "mime_type",
"mtime", "name", "permissions", "access", "size",
"symlink_name", "type", "uid", "valid_fields");
} else if (!strcmp(attr, "name")) {
if (finfo->name)
return PyString_FromString(finfo->name);
Py_INCREF(Py_None);
return Py_None;
} else if (!strcmp(attr, "valid_fields")) {
return PyInt_FromLong(finfo->valid_fields);
} else if (!strcmp(attr, "type")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_TYPE)) {
PyErr_SetString(PyExc_ValueError, "type field has no valid value");
return NULL;
}
return PyInt_FromLong(finfo->type);
} else if (!strcmp(attr, "permissions")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS)) {
PyErr_SetString(PyExc_ValueError,
"permissions field has no valid value");
return NULL;
}
return PyInt_FromLong(finfo->permissions & (~PYGNOME_VFS_ACCESS_BITS));
} else if (!strcmp(attr, "access")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_ACCESS)) {
PyErr_SetString(PyExc_ValueError,
"access field has no valid value");
return NULL;
}
return PyInt_FromLong(finfo->permissions & PYGNOME_VFS_ACCESS_BITS);
} else if (!strcmp(attr, "flags")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_FLAGS)) {
PyErr_SetString(PyExc_ValueError,"flags field has no valid value");
return NULL;
}
return PyInt_FromLong(finfo->flags);
} else if (!strcmp(attr, "device")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_DEVICE)) {
PyErr_SetString(PyExc_ValueError,
"device field has no valid value");
return NULL;
}
if (finfo->device <= G_MAXLONG)
return PyInt_FromLong(finfo->device);
else
return PyLong_FromUnsignedLongLong(finfo->device);
} else if (!strcmp(attr, "inode")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_INODE)) {
PyErr_SetString(PyExc_ValueError,"inode field has no valid value");
return NULL;
}
if (finfo->inode <= G_MAXLONG)
return PyInt_FromLong(finfo->inode);
else
return PyLong_FromUnsignedLongLong(finfo->inode);
} else if (!strcmp(attr, "link_count")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_LINK_COUNT)) {
PyErr_SetString(PyExc_ValueError,
"link_count field has no valid value");
return NULL;
}
if (finfo->link_count < G_MAXLONG)
return PyInt_FromLong(finfo->link_count);
else
return PyLong_FromUnsignedLong(finfo->link_count);
} else if (!strcmp(attr, "uid")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_IDS)) {
PyErr_SetString(PyExc_ValueError, "uid field has no valid value");
return NULL;
}
if (finfo->uid < G_MAXLONG)
return PyInt_FromLong(finfo->uid);
else
return PyLong_FromUnsignedLong(finfo->uid);
} else if (!strcmp(attr, "gid")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_IDS)) {
PyErr_SetString(PyExc_ValueError, "gid field has no valid value");
return NULL;
}
if (finfo->gid < G_MAXLONG)
return PyInt_FromLong(finfo->gid);
else
return PyLong_FromUnsignedLong(finfo->gid);
} else if (!strcmp(attr, "size")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE)) {
PyErr_SetString(PyExc_ValueError, "size field has no valid value");
return NULL;
}
if (finfo->size <= G_MAXLONG)
return PyInt_FromLong(finfo->size);
else
return PyLong_FromUnsignedLongLong(finfo->size);
} else if (!strcmp(attr, "block_count")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_BLOCK_COUNT)) {
PyErr_SetString(PyExc_ValueError,
"block_count field has no valid value");
return NULL;
}
if (finfo->block_count <= G_MAXLONG)
return PyInt_FromLong(finfo->block_count);
else
return PyLong_FromUnsignedLongLong(finfo->block_count);
} else if (!strcmp(attr, "io_block_size")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_IO_BLOCK_SIZE)){
PyErr_SetString(PyExc_ValueError,
"io_block_size field has no valid value");
return NULL;
}
if (finfo->io_block_size < G_MAXLONG)
return PyInt_FromLong(finfo->io_block_size);
else
return PyLong_FromUnsignedLong(finfo->io_block_size);
} else if (!strcmp(attr, "atime")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_ATIME)) {
PyErr_SetString(PyExc_ValueError,"atime field has no valid value");
return NULL;
}
return PyLong_FromLongLong(finfo->atime);
} else if (!strcmp(attr, "mtime")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_MTIME)) {
PyErr_SetString(PyExc_ValueError,"mtime field has no valid value");
return NULL;
}
return PyLong_FromLongLong(finfo->mtime);
} else if (!strcmp(attr, "ctime")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_CTIME)) {
PyErr_SetString(PyExc_ValueError,"ctime field has no valid value");
return NULL;
}
return PyLong_FromLongLong(finfo->ctime);
} else if (!strcmp(attr, "symlink_name")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SYMLINK_NAME)) {
PyErr_SetString(PyExc_ValueError,
"link_name field has no valid value");
return NULL;
}
if (finfo->symlink_name)
return PyString_FromString(finfo->symlink_name);
Py_INCREF(Py_None);
return Py_None;
} else if (!strcmp(attr, "mime_type")) {
if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_MIME_TYPE)) {
PyErr_SetString(PyExc_ValueError,
"mime_type field has no valid value");
return NULL;
}
if (finfo->mime_type)
return PyString_FromString(finfo->mime_type);
Py_INCREF(Py_None);
return Py_None;
} else {
PyObject *name = PyString_FromString(attr);
PyObject *ret = PyObject_GenericGetAttr((PyObject *)self, name);
Py_DECREF(name);
return ret;
}
}
