/******************************************************************************* ** Calculate the bond order parameters and filter atoms (if required). ** ** Inputs: ** - visibleAtoms: the list of atoms that are currently visible ** - pos: positions of all the atoms ** - maxBondDistance: the maximum bond distance to consider ** - scalarsQ4: array to store the Q4 parameter value ** - scalarsQ6: array to store the Q6 parameter value ** - cellDims: simulation cell dimensions ** - PBC: periodic boundaries conditions ** - NScalars: the number of previously calculated scalar values ** - fullScalars: the full list of previously calculated scalars ** - NVectors: the number of previously calculated vector values ** - fullVectors: the full list of previously calculated vectors ** - filterQ4: filter atoms by the Q4 parameter ** - minQ4: the minimum Q4 for an atom to be visible ** - maxQ4: the maximum Q4 for an atom to be visible ** - filterQ6: filter atoms by the Q6 parameter ** - minQ6: the minimum Q6 for an atom to be visible ** - maxQ6: the maximum Q6 for an atom to be visible *******************************************************************************/ static PyObject* bondOrderFilter(PyObject *self, PyObject *args) { int NVisibleIn, *visibleAtoms, *PBC, NScalars, filterQ4Enabled, filterQ6Enabled; int NVectors; double maxBondDistance, *scalarsQ4, *scalarsQ6, *cellDims; double *pos, *fullScalars, minQ4, maxQ4, minQ6, maxQ6; PyArrayObject *posIn=NULL; PyArrayObject *visibleAtomsIn=NULL; PyArrayObject *PBCIn=NULL; PyArrayObject *scalarsQ4In=NULL; PyArrayObject *scalarsQ6In=NULL; PyArrayObject *cellDimsIn=NULL; PyArrayObject *fullScalarsIn=NULL; PyArrayObject *fullVectors=NULL; int i, NVisible, boxstat; double *visiblePos, maxSep2; struct Boxes *boxes; struct NeighbourList *nebList; struct AtomStructureResults *results; /* parse and check arguments from Python */ if (!PyArg_ParseTuple(args, "O!O!dO!O!O!O!iO!iddiddiO!", &PyArray_Type, &visibleAtomsIn, &PyArray_Type, &posIn, &maxBondDistance, &PyArray_Type, &scalarsQ4In, &PyArray_Type, &scalarsQ6In, &PyArray_Type, &cellDimsIn, &PyArray_Type, &PBCIn, &NScalars, &PyArray_Type, &fullScalarsIn, &filterQ4Enabled, &minQ4, &maxQ4, &filterQ6Enabled, &minQ6, &maxQ6, &NVectors, &PyArray_Type, &fullVectors)) return NULL; if (not_intVector(visibleAtomsIn)) return NULL; visibleAtoms = pyvector_to_Cptr_int(visibleAtomsIn); NVisibleIn = (int) PyArray_DIM(visibleAtomsIn, 0); if (not_doubleVector(posIn)) return NULL; pos = pyvector_to_Cptr_double(posIn); if (not_doubleVector(scalarsQ4In)) return NULL; scalarsQ4 = pyvector_to_Cptr_double(scalarsQ4In); if (not_doubleVector(scalarsQ6In)) return NULL; scalarsQ6 = pyvector_to_Cptr_double(scalarsQ6In); if (not_doubleVector(cellDimsIn)) return NULL; cellDims = pyvector_to_Cptr_double(cellDimsIn); if (not_intVector(PBCIn)) return NULL; PBC = pyvector_to_Cptr_int(PBCIn); if (not_doubleVector(fullScalarsIn)) return NULL; fullScalars = pyvector_to_Cptr_double(fullScalarsIn); if (not_doubleVector(fullVectors)) return NULL; /* construct array of positions of visible atoms */ visiblePos = malloc(3 * NVisibleIn * sizeof(double)); if (visiblePos == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate visiblePos"); return NULL; } for (i = 0; i < NVisibleIn; i++) { int index = visibleAtoms[i]; int ind3 = 3 * index; int i3 = 3 * i; visiblePos[i3 ] = pos[ind3 ]; visiblePos[i3 + 1] = pos[ind3 + 1]; visiblePos[i3 + 2] = pos[ind3 + 2]; } /* box visible atoms */ boxes = setupBoxes(maxBondDistance, PBC, cellDims); if (boxes == NULL) { free(visiblePos); return NULL; } boxstat = putAtomsInBoxes(NVisibleIn, visiblePos, boxes); if (boxstat) { free(visiblePos); return NULL; } /* build neighbour list */ maxSep2 = maxBondDistance * maxBondDistance; nebList = constructNeighbourList(NVisibleIn, visiblePos, boxes, cellDims, PBC, maxSep2); /* only required for building neb list */ free(visiblePos); freeBoxes(boxes); /* return if failed to build the neighbour list */ if (nebList == NULL) return NULL; /* allocate results structure */ results = malloc(NVisibleIn * sizeof(struct AtomStructureResults)); if (results == NULL) { PyErr_SetString(PyExc_MemoryError, "Could not allocate results"); freeNeighbourList(nebList, NVisibleIn); return NULL; } /* first calc q_lm for each atom over all m values */ complex_qlm(NVisibleIn, visibleAtoms, nebList, pos, cellDims, PBC, results); /* free neighbour list */ freeNeighbourList(nebList, NVisibleIn); /* calculate Q4 and Q6 */ calculate_Q(NVisibleIn, results); /* do filtering here, storing results along the way */ NVisible = 0; for (i = 0; i < NVisibleIn; i++) { int j; double q4 = results[i].Q4; double q6 = results[i].Q6; /* skip if not within the valid range */ if (filterQ4Enabled && (q4 < minQ4 || q4 > maxQ4)) continue; if (filterQ6Enabled && (q6 < minQ6 || q6 > maxQ6)) continue; /* store in visible atoms array */ visibleAtoms[NVisible] = visibleAtoms[i]; /* store calculated values */ scalarsQ4[NVisible] = q4; scalarsQ6[NVisible] = q6; /* update full scalars/vectors arrays */ for (j = 0; j < NScalars; j++) { int nj = j * NVisibleIn; fullScalars[nj + NVisible] = fullScalars[nj + i]; } for (j = 0; j < NVectors; j++) { int nj = j * NVisibleIn; DIND2(fullVectors, nj + NVisible, 0) = DIND2(fullVectors, nj + i, 0); DIND2(fullVectors, nj + NVisible, 1) = DIND2(fullVectors, nj + i, 1); DIND2(fullVectors, nj + NVisible, 2) = DIND2(fullVectors, nj + i, 2); } NVisible++; } /* free results memory */ free(results); return Py_BuildValue("i", NVisible); }
static PyObject* Track_last_sector(dvda_Track *self, void *closure) { return Py_BuildValue("I", dvda_track_last_sector(self->track)); }
static PyObject* TrackReader_channels(dvda_TrackReader *self, void *closure) { return Py_BuildValue("I", dvda_channel_count(self->reader)); }
static PyObject* Title_number(dvda_Title *self, void *closure) { return Py_BuildValue("I", dvda_title_number(self->title)); }
static PyObject* Title_pts_length(dvda_Title *self, void *closure) { return Py_BuildValue("I", dvda_title_pts_length(self->title)); }
static PyObject *py_probe_step(PyMIActions *self) { return Py_BuildValue("ill", self->ss->oper_id, self->ss->oper_step, self->ss->oper_stepnum); }
static PyObject* DVDA_titlesets(dvda_DVDA *self, void *closure) { return Py_BuildValue("I", dvda_titleset_count(self->dvda)); }
static PyObject * Track_popularity(Track * self) { return Py_BuildValue("i", sp_track_popularity(self->_track)); }
static PyObject * Track_error(Track * self) { return Py_BuildValue("i", sp_track_error(self->_track)); }
static PyObject * GMPy_RandomState_Repr(RandomState_Object *self) { return Py_BuildValue("s", "<gmpy2.RandomState>"); };
static PyObject * reset(CPoly_GaussCoil *self, PyObject *args) { return Py_BuildValue("d",0.0); }
static PyObject *csolve(PyObject* self, PyObject *args, PyObject *kwargs) { /* data structures for arguments */ PyArrayObject *Ax, *Ai, *Ap, *c, *b; PyObject *cone, *warm = SCS_NULL; PyObject *verbose = SCS_NULL; PyObject *normalize = SCS_NULL; /* get the typenum for the primitive scs_int and scs_float types */ int scs_intType = getIntType(); int scs_floatType = getFloatType(); struct ScsPyData ps = { SCS_NULL, SCS_NULL, SCS_NULL, SCS_NULL, SCS_NULL, }; /* scs data structures */ Data * d = scs_calloc(1, sizeof(Data)); Cone * k = scs_calloc(1, sizeof(Cone)); AMatrix * A; Sol sol = { 0 }; Info info; char *kwlist[] = { "shape", "Ax", "Ai", "Ap", "b", "c", "cone", "warm", "verbose", "normalize", "max_iters", "scale", "eps", "cg_rate", "alpha", "rho_x", SCS_NULL }; /* parse the arguments and ensure they are the correct type */ #ifdef DLONG #ifdef FLOAT char *argparse_string = "(ll)O!O!O!O!O!O!|O!O!O!lfffff"; char *outarg_string = "{s:l,s:l,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:s}"; #else char *argparse_string = "(ll)O!O!O!O!O!O!|O!O!O!lddddd"; char *outarg_string = "{s:l,s:l,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:s}"; #endif #else #ifdef FLOAT char *argparse_string = "(ii)O!O!O!O!O!O!|O!O!O!ifffff"; char *outarg_string = "{s:i,s:i,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:s}"; #else char *argparse_string = "(ii)O!O!O!O!O!O!|O!O!O!iddddd"; char *outarg_string = "{s:i,s:i,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:s}"; #endif #endif npy_intp veclen[1]; PyObject *x, *y, *s, *returnDict, *infoDict; d->stgs = scs_malloc(sizeof(Settings)); /* set defaults */ setDefaultSettings(d); if ( !PyArg_ParseTupleAndKeywords(args, kwargs, argparse_string, kwlist, &(d->m), &(d->n), &PyArray_Type, &Ax, &PyArray_Type, &Ai, &PyArray_Type, &Ap, &PyArray_Type, &b, &PyArray_Type, &c, &PyDict_Type, &cone, &PyDict_Type, &warm, &PyBool_Type, &verbose, &PyBool_Type, &normalize, &(d->stgs->max_iters), &(d->stgs->scale), &(d->stgs->eps), &(d->stgs->cg_rate), &(d->stgs->alpha), &(d->stgs->rho_x)) ) { PySys_WriteStderr("error parsing inputs\n"); return SCS_NULL; } if (d->m < 0) { PyErr_SetString(PyExc_ValueError, "m must be a positive integer"); return SCS_NULL; } if (d->n < 0) { PyErr_SetString(PyExc_ValueError, "n must be a positive integer"); return SCS_NULL; } /* set A */ if (!PyArray_ISFLOAT(Ax) || PyArray_NDIM(Ax) != 1) { return finishWithErr(d, k, &ps, "Ax must be a numpy array of floats"); } if (!PyArray_ISINTEGER(Ai) || PyArray_NDIM(Ai) != 1) { return finishWithErr(d, k, &ps, "Ai must be a numpy array of ints"); } if (!PyArray_ISINTEGER(Ap) || PyArray_NDIM(Ap) != 1) { return finishWithErr(d, k, &ps, "Ap must be a numpy array of ints"); } ps.Ax = getContiguous(Ax, scs_floatType); ps.Ai = getContiguous(Ai, scs_intType); ps.Ap = getContiguous(Ap, scs_intType); A = scs_malloc(sizeof(AMatrix)); A->n = d->n; A->m = d->m; A->x = (scs_float *) PyArray_DATA(ps.Ax); A->i = (scs_int *) PyArray_DATA(ps.Ai); A->p = (scs_int *) PyArray_DATA(ps.Ap); d->A = A; /*d->Anz = d->Ap[d->n]; */ /*d->Anz = PyArray_DIM(Ai,0); */ /* set c */ if (!PyArray_ISFLOAT(c) || PyArray_NDIM(c) != 1) { return finishWithErr(d, k, &ps, "c must be a dense numpy array with one dimension"); } if (PyArray_DIM(c,0) != d->n) { return finishWithErr(d, k, &ps, "c has incompatible dimension with A"); } ps.c = getContiguous(c, scs_floatType); d->c = (scs_float *) PyArray_DATA(ps.c); /* set b */ if (!PyArray_ISFLOAT(b) || PyArray_NDIM(b) != 1) { return finishWithErr(d, k, &ps, "b must be a dense numpy array with one dimension"); } if (PyArray_DIM(b,0) != d->m) { return finishWithErr(d, k, &ps, "b has incompatible dimension with A"); } ps.b = getContiguous(b, scs_floatType); d->b = (scs_float *) PyArray_DATA(ps.b); if (getPosIntParam("f", &(k->f), 0, cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field f"); } if (getPosIntParam("l", &(k->l), 0, cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field l"); } if (getConeArrDim("q", &(k->q), &(k->qsize), cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field q"); } if (getConeArrDim("s", &(k->s), &(k->ssize), cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field s"); } if (getConeFloatArr("p", &(k->p), &(k->psize), cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field p"); } if (getPosIntParam("ep", &(k->ep), 0, cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field ep"); } if (getPosIntParam("ed", &(k->ed), 0, cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field ed"); } d->stgs->verbose = verbose ? (scs_int) PyObject_IsTrue(verbose) : VERBOSE; d->stgs->normalize = normalize ? (scs_int) PyObject_IsTrue(normalize) : NORMALIZE; if(d->stgs->max_iters < 0) { return finishWithErr(d, k, &ps, "max_iters must be positive"); } if(d->stgs->scale < 0) { return finishWithErr(d, k, &ps, "scale must be positive"); } if(d->stgs->eps < 0) { return finishWithErr(d, k, &ps, "eps must be positive"); } if(d->stgs->cg_rate < 0) { return finishWithErr(d, k, &ps, "cg_rate must be positive"); } if(d->stgs->alpha < 0) { return finishWithErr(d, k, &ps, "alpha must be positive"); } if(d->stgs->rho_x < 0) { return finishWithErr(d, k, &ps, "rho_x must be positive"); } /* parse warm start if set */ d->stgs->warm_start = WARM_START; if (warm) { d->stgs->warm_start = getWarmStart("x", &(sol.x), d->n, warm); d->stgs->warm_start |= getWarmStart("y", &(sol.y), d->m, warm); d->stgs->warm_start |= getWarmStart("s", &(sol.s), d->m, warm); } Py_BEGIN_ALLOW_THREADS /* Solve! */ scs(d, k, &sol, &info); Py_END_ALLOW_THREADS /* create output (all data is *deep copied*) */ /* x */ /* matrix *x; */ /* if(!(x = Matrix_New(n,1,DOUBLE))) */ /* return PyErr_NoMemory(); */ /* memcpy(MAT_BUFD(x), mywork->x, n*sizeof(scs_float)); */ veclen[0] = d->n; x = PyArray_SimpleNewFromData(1, veclen, scs_floatType, sol.x); PyArray_ENABLEFLAGS((PyArrayObject *) x, NPY_ARRAY_OWNDATA); /* y */ /* matrix *y; */ /* if(!(y = Matrix_New(p,1,DOUBLE))) */ /* return PyErr_NoMemory(); */ /* memcpy(MAT_BUFD(y), mywork->y, p*sizeof(scs_float)); */ veclen[0] = d->m; y = PyArray_SimpleNewFromData(1, veclen, scs_floatType, sol.y); PyArray_ENABLEFLAGS((PyArrayObject *) y, NPY_ARRAY_OWNDATA); /* s */ /* matrix *s; */ /* if(!(s = Matrix_New(m,1,DOUBLE))) */ /* return PyErr_NoMemory(); */ /* memcpy(MAT_BUFD(s), mywork->s, m*sizeof(scs_float)); */ veclen[0] = d->m; s = PyArray_SimpleNewFromData(1, veclen, scs_floatType, sol.s); PyArray_ENABLEFLAGS((PyArrayObject *) s, NPY_ARRAY_OWNDATA); infoDict = Py_BuildValue(outarg_string, "statusVal", (scs_int) info.statusVal, "iter", (scs_int) info.iter, "pobj", (scs_float) info.pobj, "dobj", (scs_float) info.dobj, "resPri", (scs_float) info.resPri, "resDual", (scs_float) info.resDual, "relGap", (scs_float) info.relGap, "resInfeas", (scs_float) info.resInfeas, "resUnbdd", (scs_float) info.resUnbdd, "solveTime", (scs_float) (info.solveTime), "setupTime", (scs_float) (info.setupTime), "status", info.status); returnDict = Py_BuildValue("{s:O,s:O,s:O,s:O}", "x", x, "y", y, "s", s, "info", infoDict); /* give up ownership to the return dictionary */ Py_DECREF(x); Py_DECREF(y); Py_DECREF(s); Py_DECREF(infoDict); /* no longer need pointers to arrays that held primitives */ freePyData(d, k, &ps); return returnDict; }
static PyObject *version(PyObject* self) { return Py_BuildValue("s", scs_version()); }
static PyObject *SmtAstNode_getKind(PyObject *self, PyObject *noarg) { return Py_BuildValue("k", PySmtAstNode_AsSmtAstNode(self)->getKind()); }
PyObject *PyErr_SetExcFromWindowsErrWithFilenameObjects( PyObject *exc, int ierr, PyObject *filenameObject, PyObject *filenameObject2) { int len; WCHAR *s_buf = NULL; /* Free via LocalFree */ PyObject *message; PyObject *args, *v; DWORD err = (DWORD)ierr; if (err==0) err = GetLastError(); len = FormatMessageW( /* Error API error */ FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, /* no message source */ err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */ (LPWSTR) &s_buf, 0, /* size not used */ NULL); /* no args */ if (len==0) { /* Only seen this in out of mem situations */ message = PyUnicode_FromFormat("Windows Error 0x%x", err); s_buf = NULL; } else { /* remove trailing cr/lf and dots */ while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.')) s_buf[--len] = L'\0'; message = PyUnicode_FromWideChar(s_buf, len); } if (message == NULL) { LocalFree(s_buf); return NULL; } if (filenameObject == NULL) { assert(filenameObject2 == NULL); filenameObject = filenameObject2 = Py_None; } else if (filenameObject2 == NULL) filenameObject2 = Py_None; /* This is the constructor signature for OSError. The POSIX translation will be figured out by the constructor. */ args = Py_BuildValue("(iOOiO)", 0, message, filenameObject, err, filenameObject2); Py_DECREF(message); if (args != NULL) { v = PyObject_Call(exc, args, NULL); Py_DECREF(args); if (v != NULL) { PyErr_SetObject((PyObject *) Py_TYPE(v), v); Py_DECREF(v); } } LocalFree(s_buf); return NULL; }
static PyObject * Track_availability(Track *self) { return Py_BuildValue("i", sp_track_get_availability(g_session, self->_track)); }
static PyObject *py_put_operation(PyMIActions *self, PyObject *args) { int trycount; shmstruct *ss; char *operation; operqueue_entry *oqe; int used; int oper_id; char *buffer; int remain; int datalen; ss = self->ss; for (trycount = 0; trycount < 4; ++trycount) { if (semop(self->semid, sbqput, SBOPLEN(sbqput)) >= 0) { if (!PyArg_ParseTuple(args, "s:put_operation", &operation)) { semop(self->semid, sbqunput, SBOPLEN(sbqunput)); return NULL; } datalen = strlen(operation) + 1; if (ss->bufdata_len + datalen > ss->bufspace) { PyErr_SetString(PyExc_ValueError, "Too long operation."); semop(self->semid, sbqunput, SBOPLEN(sbqunput)); return NULL; } /* Save the operation entry. */ used = semctl(self->semid, SEMQUSED, GETVAL); if (used < 0) { PyErr_SetFromErrno(PyExc_OSError); semop(self->semid, sbqunput, SBOPLEN(sbqunput)); return NULL; } oqe = ss->queue; oqe[used - 1].oper_id = oper_id = self->oper_cnt++; oqe[used - 1].operdata_len = datalen; /* Save the operation into buffer. */ buffer = ss->data; if (ss->bufdata_start + ss->bufdata_len + datalen <= ss->bufspace) strcpy(buffer + ss->bufdata_start + ss->bufdata_len, operation); else if (ss->bufdata_start + ss->bufdata_len < ss->bufspace) { remain = ss->bufspace - ss->bufdata_start - ss->bufdata_len; memcpy(buffer + ss->bufdata_start + ss->bufdata_len, operation, remain); strcpy(buffer, operation + remain); } else { remain = ss->bufdata_start + ss->bufdata_len - ss->bufspace; strcpy(buffer + remain, operation); } ss->bufdata_len += datalen; if (semop(self->semid, sbqunlock, SBOPLEN(sbqunlock)) < 0) { PyErr_SetFromErrno(PyExc_OSError); return NULL; } return Py_BuildValue("i", oper_id); /* put successfully. */ } if (errno == EAGAIN) usleep(100); /* sleep 1/10 second. */ else { PyErr_SetFromErrno(PyExc_OSError); return NULL; } } PyErr_SetFromErrno(PyExc_OSError); return NULL; }
static PyObject * Track_is_loaded(Track * self) { return Py_BuildValue("i", sp_track_is_loaded(self->_track)); }
PyObject *KX_LightObject::pyattr_get_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef) { KX_LightObject* self = static_cast<KX_LightObject*>(self_v); return Py_BuildValue("[fff]", self->m_lightobj->m_color[0], self->m_lightobj->m_color[1], self->m_lightobj->m_color[2]); }
static PyObject * Track_duration(Track * self) { return Py_BuildValue("i", sp_track_duration(self->_track)); }
static PyObject* Titleset_titles(dvda_Titleset *self, void *closure) { return Py_BuildValue("I", dvda_title_count(self->titleset)); }
PyObject * PyFile_GetLine(PyObject *f, int n) { PyObject *result; if (f == NULL) { PyErr_BadInternalCall(); return NULL; } { PyObject *reader; PyObject *args; _Py_IDENTIFIER(readline); reader = _PyObject_GetAttrId(f, &PyId_readline); if (reader == NULL) return NULL; if (n <= 0) args = PyTuple_New(0); else args = Py_BuildValue("(i)", n); if (args == NULL) { Py_DECREF(reader); return NULL; } result = PyEval_CallObject(reader, args); Py_DECREF(reader); Py_DECREF(args); if (result != NULL && !PyBytes_Check(result) && !PyUnicode_Check(result)) { Py_DECREF(result); result = NULL; PyErr_SetString(PyExc_TypeError, "object.readline() returned non-string"); } } if (n < 0 && result != NULL && PyBytes_Check(result)) { char *s = PyBytes_AS_STRING(result); Py_ssize_t len = PyBytes_GET_SIZE(result); if (len == 0) { Py_DECREF(result); result = NULL; PyErr_SetString(PyExc_EOFError, "EOF when reading a line"); } else if (s[len-1] == '\n') { if (result->ob_refcnt == 1) _PyBytes_Resize(&result, len-1); else { PyObject *v; v = PyBytes_FromStringAndSize(s, len-1); Py_DECREF(result); result = v; } } } if (n < 0 && result != NULL && PyUnicode_Check(result)) { Py_ssize_t len = PyUnicode_GET_LENGTH(result); if (len == 0) { Py_DECREF(result); result = NULL; PyErr_SetString(PyExc_EOFError, "EOF when reading a line"); } else if (PyUnicode_READ_CHAR(result, len-1) == '\n') { PyObject *v; v = PyUnicode_Substring(result, 0, len-1); Py_DECREF(result); result = v; } } return result; }
static PyObject* Title_tracks(dvda_Title *self, void *closure) { return Py_BuildValue("I", dvda_track_count(self->title)); }
PyMODINIT_FUNC PyInit__multiprocessing(void) { PyObject *module, *temp, *value; /* Initialize module */ module = PyModule_Create(&multiprocessing_module); if (!module) return NULL; /* Get copy of objects from pickle */ temp = PyImport_ImportModule(PICKLE_MODULE); if (!temp) return NULL; pickle_dumps = PyObject_GetAttrString(temp, "dumps"); pickle_loads = PyObject_GetAttrString(temp, "loads"); pickle_protocol = PyObject_GetAttrString(temp, "HIGHEST_PROTOCOL"); Py_XDECREF(temp); /* Get copy of BufferTooShort */ temp = PyImport_ImportModule("multiprocessing"); if (!temp) return NULL; BufferTooShort = PyObject_GetAttrString(temp, "BufferTooShort"); Py_XDECREF(temp); /* Add connection type to module */ if (PyType_Ready(&ConnectionType) < 0) return NULL; Py_INCREF(&ConnectionType); PyModule_AddObject(module, "Connection", (PyObject*)&ConnectionType); #if defined(MS_WINDOWS) || \ (defined(HAVE_SEM_OPEN) && !defined(POSIX_SEMAPHORES_NOT_ENABLED)) /* Add SemLock type to module */ if (PyType_Ready(&SemLockType) < 0) return NULL; Py_INCREF(&SemLockType); PyDict_SetItemString(SemLockType.tp_dict, "SEM_VALUE_MAX", Py_BuildValue("i", SEM_VALUE_MAX)); PyModule_AddObject(module, "SemLock", (PyObject*)&SemLockType); #endif #ifdef MS_WINDOWS /* Add PipeConnection to module */ if (PyType_Ready(&PipeConnectionType) < 0) return NULL; Py_INCREF(&PipeConnectionType); PyModule_AddObject(module, "PipeConnection", (PyObject*)&PipeConnectionType); /* Initialize win32 class and add to multiprocessing */ temp = create_win32_namespace(); if (!temp) return NULL; PyModule_AddObject(module, "win32", temp); /* Initialize the event handle used to signal Ctrl-C */ sigint_event = CreateEvent(NULL, TRUE, FALSE, NULL); if (!sigint_event) { PyErr_SetFromWindowsErr(0); return NULL; } if (!SetConsoleCtrlHandler(ProcessingCtrlHandler, TRUE)) { PyErr_SetFromWindowsErr(0); return NULL; } #endif /* Add configuration macros */ temp = PyDict_New(); if (!temp) return NULL; #define ADD_FLAG(name) \ value = Py_BuildValue("i", name); \ if (value == NULL) { Py_DECREF(temp); return NULL; } \ if (PyDict_SetItemString(temp, #name, value) < 0) { \ Py_DECREF(temp); Py_DECREF(value); return NULL; } \ Py_DECREF(value) #if defined(HAVE_SEM_OPEN) && !defined(POSIX_SEMAPHORES_NOT_ENABLED) ADD_FLAG(HAVE_SEM_OPEN); #endif #ifdef HAVE_SEM_TIMEDWAIT ADD_FLAG(HAVE_SEM_TIMEDWAIT); #endif #ifdef HAVE_FD_TRANSFER ADD_FLAG(HAVE_FD_TRANSFER); #endif #ifdef HAVE_BROKEN_SEM_GETVALUE ADD_FLAG(HAVE_BROKEN_SEM_GETVALUE); #endif #ifdef HAVE_BROKEN_SEM_UNLINK ADD_FLAG(HAVE_BROKEN_SEM_UNLINK); #endif if (PyModule_AddObject(module, "flags", temp) < 0) return NULL; return module; }
static PyObject* Track_pts_length(dvda_Track *self, void *closure) { return Py_BuildValue("I", dvda_track_pts_length(self->track)); }
static PyObject * EC_new(PyTypeObject *self, PyObject *args, PyObject *kw) { PyObject *name, *bases=NULL, *dict=NULL; PyObject *new_bases=NULL, *new_args, *result; int have_base = 0, i; if (kw && PyObject_IsTrue(kw)) { PyErr_SetString(PyExc_TypeError, "Keyword arguments are not supported"); return NULL; } if (!PyArg_ParseTuple(args, "O|O!O!", &name, &PyTuple_Type, &bases, &PyDict_Type, &dict)) return NULL; /* Make sure Base is in bases */ if (bases) { for (i = 0; i < PyTuple_GET_SIZE(bases); i++) { if (PyObject_TypeCheck(PyTuple_GET_ITEM(bases, i), &ExtensionClassType)) { have_base = 1; break; } } if (! have_base) { new_bases = PyTuple_New(PyTuple_GET_SIZE(bases) + 1); if (new_bases == NULL) return NULL; for (i = 0; i < PyTuple_GET_SIZE(bases); i++) { Py_XINCREF(PyTuple_GET_ITEM(bases, i)); PyTuple_SET_ITEM(new_bases, i, PyTuple_GET_ITEM(bases, i)); } Py_INCREF(OBJECT(&BaseType)); PyTuple_SET_ITEM(new_bases, PyTuple_GET_SIZE(bases), OBJECT(&BaseType)); } } else { new_bases = Py_BuildValue("(O)", &BaseType); if (new_bases == NULL) return NULL; } if (new_bases) { if (dict) new_args = Py_BuildValue("OOO", name, new_bases, dict); else new_args = Py_BuildValue("OO", name, new_bases); Py_DECREF(new_bases); if (new_args == NULL) return NULL; result = PyType_Type.tp_new(self, new_args, kw); Py_DECREF(new_args); } else { result = PyType_Type.tp_new(self, args, kw); /* We didn't have to add Base, so maybe NoInstanceDictionaryBase is in the bases. We need to check if it was. If it was, we need to suppress instance dictionary support. */ for (i = 0; i < PyTuple_GET_SIZE(bases); i++) { if ( PyObject_TypeCheck(PyTuple_GET_ITEM(bases, i), &ExtensionClassType) && PyType_IsSubtype(TYPE(PyTuple_GET_ITEM(bases, i)), &NoInstanceDictionaryBaseType) ) { TYPE(result)->tp_dictoffset = 0; break; } } } return result; }
static PyObject* TrackReader_bits_per_sample(dvda_TrackReader *self, void *closure) { return Py_BuildValue("I", dvda_bits_per_sample(self->reader)); }
PyObject * PyErr_SetFromErrnoWithFilenameObjects(PyObject *exc, PyObject *filenameObject, PyObject *filenameObject2) { PyObject *message; PyObject *v, *args; int i = errno; #ifdef MS_WINDOWS WCHAR *s_buf = NULL; #endif /* Unix/Windows */ #ifdef EINTR if (i == EINTR && PyErr_CheckSignals()) return NULL; #endif #ifndef MS_WINDOWS if (i != 0) { char *s = strerror(i); message = PyUnicode_DecodeLocale(s, "surrogateescape"); } else { /* Sometimes errno didn't get set */ message = PyUnicode_FromString("Error"); } #else if (i == 0) message = PyUnicode_FromString("Error"); /* Sometimes errno didn't get set */ else { /* Note that the Win32 errors do not lineup with the errno error. So if the error is in the MSVC error table, we use it, otherwise we assume it really _is_ a Win32 error code */ if (i > 0 && i < _sys_nerr) { message = PyUnicode_FromString(_sys_errlist[i]); } else { int len = FormatMessageW( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, /* no message source */ i, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */ (LPWSTR) &s_buf, 0, /* size not used */ NULL); /* no args */ if (len==0) { /* Only ever seen this in out-of-mem situations */ s_buf = NULL; message = PyUnicode_FromFormat("Windows Error 0x%x", i); } else { /* remove trailing cr/lf and dots */ while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.')) s_buf[--len] = L'\0'; message = PyUnicode_FromWideChar(s_buf, len); } } } #endif /* Unix/Windows */ if (message == NULL) { #ifdef MS_WINDOWS LocalFree(s_buf); #endif return NULL; } if (filenameObject != NULL) { if (filenameObject2 != NULL) args = Py_BuildValue("(iOOiO)", i, message, filenameObject, 0, filenameObject2); else args = Py_BuildValue("(iOO)", i, message, filenameObject); } else { assert(filenameObject2 == NULL); args = Py_BuildValue("(iO)", i, message); } Py_DECREF(message); if (args != NULL) { v = PyObject_Call(exc, args, NULL); Py_DECREF(args); if (v != NULL) { PyErr_SetObject((PyObject *) Py_TYPE(v), v); Py_DECREF(v); } } #ifdef MS_WINDOWS LocalFree(s_buf); #endif return NULL; }
static PyObject* TrackReader_channel_mask(dvda_TrackReader *self, void *closure) { return Py_BuildValue("I", dvda_riff_wave_channel_mask(self->reader)); }
PyObject* Effect::wrapSetImage(PyObject *self, PyObject *args) { // get the effect Effect * effect = getEffect(); // check if we have aborted already if (effect->_abortRequested) { return Py_BuildValue(""); } // determine the timeout int timeout = effect->_timeout; if (timeout > 0) { timeout = effect->_endTime - QDateTime::currentMSecsSinceEpoch(); // we are done if the time has passed if (timeout <= 0) { return Py_BuildValue(""); } } // bytearray of values int width, height; PyObject * bytearray = nullptr; if (PyArg_ParseTuple(args, "iiO", &width, &height, &bytearray)) { if (PyByteArray_Check(bytearray)) { int length = PyByteArray_Size(bytearray); if (length == 3 * width * height) { Image<ColorRgb> image(width, height); char * data = PyByteArray_AS_STRING(bytearray); memcpy(image.memptr(), data, length); effect->_imageProcessor->process(image, effect->_colors); effect->setColors(effect->_priority, effect->_colors, timeout, false); return Py_BuildValue(""); } else { PyErr_SetString(PyExc_RuntimeError, "Length of bytearray argument should be 3*width*height"); return nullptr; } } else { PyErr_SetString(PyExc_RuntimeError, "Argument 3 is not a bytearray"); return nullptr; } } else { return nullptr; } // error PyErr_SetString(PyExc_RuntimeError, "Unknown error"); return nullptr; }