static PyObject *Triton_getRegValue(PyObject *self, PyObject *regId) { RegisterOperand reg; uint64 tritonReg; if (!PyLong_Check(regId) && !PyInt_Check(regId)) return PyErr_Format(PyExc_TypeError, "getRegValue(): expected a register id (IDREF.REG) as argument"); if (!ap.getCurrentCtxH()) return PyErr_Format(PyExc_TypeError, "getRegValue(): Can't call getRegValue() right now. You must run the program before."); tritonReg = PyLong_AsLong(regId); reg = createTmpReg(tritonReg); if (tritonReg >= ID_XMM0 && tritonReg <= ID_XMM15){ uint128 value = ap.getSSERegisterValue(reg); return uint128ToPyLongObject(value); } return Py_BuildValue("k", ap.getRegisterValue(reg)); }
static int validItem(rpmTagClass tclass, PyObject *item) { int rc; switch (tclass) { case RPM_NUMERIC_CLASS: rc = (PyLong_Check(item) || PyInt_Check(item)); break; case RPM_STRING_CLASS: rc = (PyBytes_Check(item) || PyUnicode_Check(item)); break; case RPM_BINARY_CLASS: rc = PyBytes_Check(item); break; default: rc = 0; break; } return rc; }
/* adapted from Python source, floatobject.c:convert_to_double */ int convert_to_double(PyObject *obj, double *dbl) { if (PyFloat_Check(obj)) { *dbl = PyFloat_AS_DOUBLE(obj); #ifndef IS_PY3K } else if (PyInt_Check(obj)) { *dbl = (double)PyInt_AS_LONG(obj); #endif } else if (PyLong_Check(obj)) { *dbl = PyLong_AsDouble(obj); if (*dbl == -1.0 && PyErr_Occurred()) { return 0; } } else { PyErr_SetString(PyExc_ValueError, "Expected a number"); return 0; } return 1; }
static PyObject * AerospikePredicates_Equals(PyObject * self, PyObject * args) { PyObject * py_bin = NULL; PyObject * py_val = NULL; if (PyArg_ParseTuple(args, "OO:equals", &py_bin, &py_val) == false) { goto exit; } if (PyInt_Check(py_val) || PyLong_Check(py_val)) { return Py_BuildValue("iiOO", AS_PREDICATE_EQUAL, AS_INDEX_NUMERIC, py_bin, py_val); } else if (PyString_Check(py_val) || PyUnicode_Check(py_val)) { return Py_BuildValue("iiOO", AS_PREDICATE_EQUAL, AS_INDEX_STRING, py_bin, py_val); } exit: Py_INCREF(Py_None); return Py_None; }
static int Context_setDebug (Context *self, PyObject *value, void *closure) { int d; #if PY_MAJOR_VERSION < 3 if (PyInt_Check (value)) value = PyLong_FromLong (PyInt_AsLong (value)); #endif if (!PyLong_Check (value)) { PyErr_SetString (PyExc_TypeError, "must be int"); return -1; } d = PyLong_AsLong (value); smbc_setDebug (self->context, d); return 0; }
static int get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p) { unsigned PY_LONG_LONG x; v = get_pylong(v); if (v == NULL) return -1; assert(PyLong_Check(v)); x = PyLong_AsUnsignedLongLong(v); Py_DECREF(v); if (x == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) PyErr_SetString(StructError, "argument out of range"); return -1; } *p = x; return 0; }
VALUE ptorLong(PyObject* pNum) { if(!PyLong_Check(pNum)) return Qnil; VALUE rNum; long cNum; cNum = PyLong_AsLong(pNum); if(PyErr_ExceptionMatches(PyExc_OverflowError)) { rpPythonError(); return Qnil; } rNum = INT2NUM(cNum); return rNum; }
static int BufferObj_set_cfa(Buffer *self, PyObject *value, void *_) { long cfa_id; if (PyInt_Check(value)) cfa_id = PyInt_AS_LONG(value); else if (PyLong_Check(value)) cfa_id = PyLong_AsLong(value); else return -1; if (cfa_id >= _PLDRAW_CFA_N_) { PyErr_SetString(PyExc_ValueError, "Invalid CFA identifier"); return -1; } pldraw_set_cfa(self->pldraw, cfa_id); return Buffer_update_cached_colors(self); }
static int get_long(PyObject *v, long *p) { long x; if (!PyLong_Check(v)) { PyErr_SetString(StructError, "required argument is not an integer"); return -1; } x = PyLong_AsLong(v); if (x == -1 && PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) PyErr_SetString(StructError, "argument out of range"); return -1; } *p = x; return 0; }
//----------------------------------------------------------------------------- // NumberVar_SetValue() // Set the value of the variable. //----------------------------------------------------------------------------- static int NumberVar_SetValue( udt_NumberVar *var, // variable to set value for unsigned pos, // array position to set PyObject *value) // value to set { #if PY_MAJOR_VERSION < 3 if (PyInt_Check(value)) return NumberVar_SetValueFromInteger(var, pos, value); #endif if (PyLong_Check(value)) return NumberVar_SetValueFromLong(var, pos, value); if (PyBool_Check(value)) return NumberVar_SetValueFromBoolean(var, pos, value); if (PyFloat_Check(value)) return NumberVar_SetValueFromFloat(var, pos, value); if (Py_TYPE(value) == g_DecimalType) return NumberVar_SetValueFromDecimal(var, pos, value); PyErr_SetString(PyExc_TypeError, "expecting numeric data"); return -1; }
static int get_size_t(PyObject *v, size_t *p) { size_t x; v = get_pylong(v); if (v == NULL) return -1; assert(PyLong_Check(v)); x = PyLong_AsSize_t(v); Py_DECREF(v); if (x == (size_t)-1 && PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) PyErr_SetString(StructError, "argument out of range"); return -1; } *p = x; return 0; }
static int Context_setTimeout (Context *self, PyObject *value, void *closure) { #if PY_MAJOR_VERSION < 3 if (!PyInt_Check (value)) #else if (!PyLong_Check (value)) #endif { PyErr_SetString (PyExc_TypeError, "must be long"); return -1; } #if PY_MAJOR_VERSION < 3 smbc_setTimeout (self->context, PyInt_AsLong (value)); #else smbc_setTimeout (self->context, PyLong_AsLong (value)); #endif return 0; }
bool ChPythonEngine::GetInteger(const char* variable, int& return_val) { PyObject * module = PyImport_AddModule("__main__"); // borrowed reference assert(module); // __main__ should always exist PyObject * dictionary = PyModule_GetDict(module); // borrowed reference assert(dictionary); // __main__ should have a dictionary PyObject * result = PyDict_GetItemString(dictionary, variable); // borrowed reference if (!result) return false; if (PyLong_Check(result)) { return_val = PyLong_AsLong(result); return true; } return false; }
/*static*/ PyObject * ReplicateAttributes_SetNewPeriodicOrigin(PyObject *self, PyObject *args) { ReplicateAttributesObject *obj = (ReplicateAttributesObject *)self; double *dvals = obj->data->GetNewPeriodicOrigin(); if(!PyArg_ParseTuple(args, "ddd", &dvals[0], &dvals[1], &dvals[2])) { PyObject *tuple; if(!PyArg_ParseTuple(args, "O", &tuple)) return NULL; if(PyTuple_Check(tuple)) { if(PyTuple_Size(tuple) != 3) return NULL; PyErr_Clear(); for(int i = 0; i < PyTuple_Size(tuple); ++i) { PyObject *item = PyTuple_GET_ITEM(tuple, i); if(PyFloat_Check(item)) dvals[i] = PyFloat_AS_DOUBLE(item); else if(PyInt_Check(item)) dvals[i] = double(PyInt_AS_LONG(item)); else if(PyLong_Check(item)) dvals[i] = PyLong_AsDouble(item); else dvals[i] = 0.; } } else return NULL; } // Mark the newPeriodicOrigin in the object as modified. obj->data->SelectNewPeriodicOrigin(); Py_INCREF(Py_None); return Py_None; }
int get_addr_from_python (PyObject *obj, CORE_ADDR *addr) { if (gdbpy_is_value_object (obj)) *addr = value_as_address (value_object_to_value (obj)); else if (PyLong_Check (obj)) { /* Assume CORE_ADDR corresponds to unsigned long. */ *addr = PyLong_AsUnsignedLong (obj); if (PyErr_Occurred () != NULL) return 0; } else if (PyInt_Check (obj)) { long val; /* Assume CORE_ADDR corresponds to unsigned long. */ val = PyInt_AsLong (obj); if (val >= 0) *addr = val; else { /* If no error ocurred, VAL is indeed negative. */ if (PyErr_Occurred () != NULL) return 0; PyErr_SetString (PyExc_ValueError, _("Supplied address is negative.")); return 0; } } else { PyErr_SetString (PyExc_TypeError, _("Invalid type for address.")); return 0; } return 1; }
/*static*/ PyObject * WindowInformation_SetWindowSize(PyObject *self, PyObject *args) { WindowInformationObject *obj = (WindowInformationObject *)self; int *ivals = obj->data->GetWindowSize(); if(!PyArg_ParseTuple(args, "ii", &ivals[0], &ivals[1])) { PyObject *tuple; if(!PyArg_ParseTuple(args, "O", &tuple)) return NULL; if(PyTuple_Check(tuple)) { if(PyTuple_Size(tuple) != 2) return NULL; PyErr_Clear(); for(int i = 0; i < PyTuple_Size(tuple); ++i) { PyObject *item = PyTuple_GET_ITEM(tuple, i); if(PyFloat_Check(item)) ivals[i] = int(PyFloat_AS_DOUBLE(item)); else if(PyInt_Check(item)) ivals[i] = int(PyInt_AS_LONG(item)); else if(PyLong_Check(item)) ivals[i] = int(PyLong_AsDouble(item)); else ivals[i] = 0; } } else return NULL; } // Mark the windowSize in the object as modified. obj->data->SelectWindowSize(); Py_INCREF(Py_None); return Py_None; }
/*static*/ PyObject * WindowInformation_SetExtents(PyObject *self, PyObject *args) { WindowInformationObject *obj = (WindowInformationObject *)self; double *dvals = obj->data->GetExtents(); if(!PyArg_ParseTuple(args, "dddddd", &dvals[0], &dvals[1], &dvals[2], &dvals[3], &dvals[4], &dvals[5])) { PyObject *tuple; if(!PyArg_ParseTuple(args, "O", &tuple)) return NULL; if(PyTuple_Check(tuple)) { if(PyTuple_Size(tuple) != 6) return NULL; PyErr_Clear(); for(int i = 0; i < PyTuple_Size(tuple); ++i) { PyObject *item = PyTuple_GET_ITEM(tuple, i); if(PyFloat_Check(item)) dvals[i] = PyFloat_AS_DOUBLE(item); else if(PyInt_Check(item)) dvals[i] = double(PyInt_AS_LONG(item)); else if(PyLong_Check(item)) dvals[i] = PyLong_AsDouble(item); else dvals[i] = 0.; } } else return NULL; } // Mark the extents in the object as modified. obj->data->SelectExtents(); Py_INCREF(Py_None); return Py_None; }
/*static*/ PyObject * TransferFunctionWidget_SetPosition(PyObject *self, PyObject *args) { TransferFunctionWidgetObject *obj = (TransferFunctionWidgetObject *)self; float *fvals = obj->data->GetPosition(); if(!PyArg_ParseTuple(args, "ffffffff", &fvals[0], &fvals[1], &fvals[2], &fvals[3], &fvals[4], &fvals[5], &fvals[6], &fvals[7])) { PyObject *tuple; if(!PyArg_ParseTuple(args, "O", &tuple)) return NULL; if(PyTuple_Check(tuple)) { if(PyTuple_Size(tuple) != 8) return NULL; PyErr_Clear(); for(int i = 0; i < PyTuple_Size(tuple); ++i) { PyObject *item = PyTuple_GET_ITEM(tuple, i); if(PyFloat_Check(item)) fvals[i] = float(PyFloat_AS_DOUBLE(item)); else if(PyInt_Check(item)) fvals[i] = float(PyInt_AS_LONG(item)); else if(PyLong_Check(item)) fvals[i] = float(PyLong_AsDouble(item)); else fvals[i] = 0.; } } else return NULL; } // Mark the Position in the object as modified. obj->data->SelectPosition(); Py_INCREF(Py_None); return Py_None; }
static int music_delivery(sp_session * session, const sp_audioformat * format, const void *frames, int num_frames) { PyGILState_STATE gstate; PyObject *res, *method; #ifdef DEBUG fprintf(stderr, "[DEBUG]-session- >> music_delivery called\n"); #endif gstate = PyGILState_Ensure(); int siz = frame_size(format); PyObject *pyframes = PyBuffer_FromMemory((void *)frames, num_frames * siz); Session *psession = (Session *) PyObject_CallObject((PyObject *)&SessionType, NULL); psession->_session = session; PyObject *client = (PyObject *)sp_session_userdata(session); method = PyObject_GetAttrString(client, "music_delivery"); res = PyObject_CallFunction(method, "OOiiiii", psession, pyframes, siz, num_frames, format->sample_type, format->sample_rate, format->channels); int consumed = num_frames; // assume all consumed if (!res) PyErr_WriteUnraisable(method); if (PyInt_Check(res)) consumed = (int)PyInt_AsLong(res); else if (PyLong_Check(res)) consumed = (int)PyLong_AsLong(res); else { PyErr_SetString(PyExc_TypeError, "music_delivery must return an integer"); PyErr_WriteUnraisable(method); } Py_DECREF(pyframes); Py_DECREF(psession); Py_XDECREF(res); Py_DECREF(method); PyGILState_Release(gstate); return consumed; }
/*static*/ PyObject * RadialResampleAttributes_SetCenter(PyObject *self, PyObject *args) { RadialResampleAttributesObject *obj = (RadialResampleAttributesObject *)self; float *fvals = obj->data->GetCenter(); if(!PyArg_ParseTuple(args, "fff", &fvals[0], &fvals[1], &fvals[2])) { PyObject *tuple; if(!PyArg_ParseTuple(args, "O", &tuple)) return NULL; if(PyTuple_Check(tuple)) { if(PyTuple_Size(tuple) != 3) return NULL; PyErr_Clear(); for(int i = 0; i < PyTuple_Size(tuple); ++i) { PyObject *item = PyTuple_GET_ITEM(tuple, i); if(PyFloat_Check(item)) fvals[i] = float(PyFloat_AS_DOUBLE(item)); else if(PyInt_Check(item)) fvals[i] = float(PyInt_AS_LONG(item)); else if(PyLong_Check(item)) fvals[i] = float(PyLong_AsDouble(item)); else fvals[i] = 0.; } } else return NULL; } // Mark the center in the object as modified. obj->data->SelectCenter(); Py_INCREF(Py_None); return Py_None; }
PyObject* pyInfoTree::graft(pyInfoTreeObject* self, PyObject* args, PyObject* kwds) { const char* path = nullptr; PyObject* val = 0; static char* kwlist[] = {(char*)"path", (char*)"value", nullptr}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "sO", kwlist, &path, &val)) { Py_INCREF(Py_False); return Py_False; } if (PyBool_Check(val)) { if (!self->tree->graft(path, InfoTree::make(PyObject_IsTrue(val) ? true : false))) { Py_INCREF(Py_False); return Py_False; } } else if (PyLong_Check(val)) { if (!self->tree->graft(path, InfoTree::make(PyLong_AsLong(val)))) { Py_INCREF(Py_False); return Py_False; } } else if (PyFloat_Check(val)) { if (!self->tree->graft(path, InfoTree::make(PyFloat_AsDouble(val)))) { Py_INCREF(Py_False); return Py_False; } } else if (PyUnicode_Check(val)) { if (!self->tree->graft(path, InfoTree::make(PyUnicode_AsUTF8(val)))) { Py_INCREF(Py_False); return Py_False; } } else if (PyObject_IsInstance(val, reinterpret_cast<PyObject*>(&pyInfoTree::pyType))) { if (!self->tree->graft(path, reinterpret_cast<pyInfoTree::pyInfoTreeObject*>(val)->keepAlive)) { Py_INCREF(Py_False); return Py_False; } } else { // unsorted PyObject type Py_INCREF(Py_False); return Py_False; } // return true if everything went well Py_INCREF(Py_True); return Py_True; }
static int SpiDev_set_mode(SpiDevObject *self, PyObject *val, void *closure) { uint8_t mode, tmp; if (val == NULL) { PyErr_SetString(PyExc_TypeError, "Cannot delete attribute"); return -1; } #if PY_MAJOR_VERSION < 3 if (PyInt_Check(val)) { mode = PyInt_AS_LONG(val); } else #endif { if (PyLong_Check(val)) { mode = PyLong_AS_LONG(val); } else { PyErr_SetString(PyExc_TypeError, "The mode attribute must be an integer"); return -1; } } if ( mode > 3 ) { PyErr_SetString(PyExc_TypeError, "The mode attribute must be an integer" "between 0 and 3."); return -1; } // clean and set CPHA and CPOL bits tmp = ( self->mode & ~(SPI_CPHA | SPI_CPOL) ) | mode ; __spidev_set_mode(self->fd, tmp); self->mode = tmp; return 0; }
static PyObject * BufferSubscript(PyObject *self, PyObject* idx) { if (PyLong_Check(idx)) { long _idx = PyLong_AsLong(idx); return BufferItem(self,_idx); } else if (PySlice_Check(idx)) { Py_ssize_t start, stop, step, slicelen; if (PySlice_GetIndicesEx((PySliceObject *)idx, (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count+1, &start, &stop, &step, &slicelen) < 0) { return NULL; } return BufferSlice(self,start,stop+1); } else { PyErr_SetString(PyExc_IndexError, "Index must be int or slice"); return NULL; } }
static PyObject * RangeSubscript(PyObject *self, PyObject* idx) { if (PyLong_Check(idx)) { long _idx = PyLong_AsLong(idx); return RangeItem(self,_idx); } else if (PySlice_Check(idx)) { Py_ssize_t start, stop, step, slicelen; if (PySlice_GetIndicesEx((PySliceObject *)idx, ((RangeObject *)(self))->end-((RangeObject *)(self))->start+1, &start, &stop, &step, &slicelen) < 0) { return NULL; } return RangeSlice(self,start,stop+1); } else { PyErr_SetString(PyExc_IndexError, "Index must be int or slice"); return NULL; } }
PyObject *KX_VertexProxy::PySetRGBA(PyObject *value) { if (PyLong_Check(value)) { int rgba = PyLong_AsLong(value); m_vertex->SetRGBA(rgba); m_mesh->SetMeshModified(true); Py_RETURN_NONE; } else { MT_Vector4 vec; if (PyVecTo(value, vec)) { m_vertex->SetRGBA(vec); m_mesh->SetMeshModified(true); Py_RETURN_NONE; } } PyErr_SetString(PyExc_TypeError, "vert.setRGBA(value): KX_VertexProxy, expected a 4D vector or an int"); return NULL; }
Object to_object(PyObject *obj){ if (PyBool_Check(obj)) return AB::to_object( obj == Py_True ); if (PyFloat_Check(obj)) return AB::to_object( PyFloat_AsDouble(obj) ); if (PyLong_Check(obj)) return AB::to_object( (int)PyLong_AsLong(obj) ); if (PyInt_Check(obj)) return AB::to_object( (int)PyInt_AsLong(obj) ); if (PyUnicode_Check(obj)){ Py_ssize_t size; const char *str; PyObject_AsCharBuffer(obj, &str, &size); std::string str8{str}; PyMem_Free((void*)str); return AB::to_object( str8 ); } throw(AB::object_not_convertible( obj->ob_type->tp_name, "Object")); }
static PyObject * RangeSubscript(PyObject *self, PyObject* idx) { if (PyLong_Check(idx)) { long _idx = PyLong_AsLong(idx); return RangeItem((RangeObject *)(self), _idx); } else if (PySlice_Check(idx)) { Py_ssize_t start, stop, step, slicelen; if (PySlice_GetIndicesEx((PySliceObject_T *)idx, ((RangeObject *)(self))->end-((RangeObject *)(self))->start+1, &start, &stop, &step, &slicelen) < 0) { return NULL; } return RangeSlice((RangeObject *)(self), start, stop); } else { RAISE_INVALID_INDEX_TYPE(idx); return NULL; } }
static Py_ssize_t RangeAsSubscript(PyObject *self, PyObject *idx, PyObject *val) { if (PyLong_Check(idx)) { long n = PyLong_AsLong(idx); return RangeAsItem(self, n, val); } else if (PySlice_Check(idx)) { Py_ssize_t start, stop, step, slicelen; if (PySlice_GetIndicesEx((PySliceObject_T *)idx, ((RangeObject *)(self))->end-((RangeObject *)(self))->start+1, &start, &stop, &step, &slicelen) < 0) { return -1; } return RangeAsSlice(self, start, stop, val); } else { RAISE_INVALID_INDEX_TYPE(idx); return -1; } }
static int SpiDev_set_bits_per_word(SpiDevObject *self, PyObject *val, void *closure) { uint8_t bits; if (val == NULL) { PyErr_SetString(PyExc_TypeError, "Cannot delete attribute"); return -1; } #if PY_MAJOR_VERSION < 3 if (PyInt_Check(val)) { bits = PyInt_AS_LONG(val); } else #endif { if (PyLong_Check(val)) { bits = PyLong_AS_LONG(val); } else { PyErr_SetString(PyExc_TypeError, "The bits_per_word attribute must be an integer"); return -1; } } if (bits < 8 || bits > 16) { PyErr_SetString(PyExc_TypeError, "invalid bits_per_word (8 to 16)"); return -1; } if (self->bits_per_word != bits) { if (ioctl(self->fd, SPI_IOC_WR_BITS_PER_WORD, &bits) == -1) { PyErr_SetFromErrno(PyExc_IOError); return -1; } self->bits_per_word = bits; } return 0; }
Py::Object writeCameraFile(const Py::Tuple& args) { PyObject *Arg[4]; const char *FileName; double vecs[4][3]; if (!PyArg_ParseTuple(args.ptr(), "sO!O!O!O!",&FileName,&PyTuple_Type, &Arg[0],&PyTuple_Type, &Arg[1],&PyTuple_Type, &Arg[2],&PyTuple_Type, &Arg[3])) throw Py::Exception(); // go through the Tuple of Tuples for (int i=0;i<4;i++) { // check the right size of the Tuple of floats if (PyTuple_GET_SIZE(Arg[i]) != 3) throw Py::ValueError("Wrong parameter format, four Tuple of three floats needed!"); // go through the Tuple of floats for (int l=0;l<3;l++) { PyObject* temp = PyTuple_GetItem(Arg[i],l); // check Type if (PyFloat_Check(temp)) vecs[i][l] = PyFloat_AsDouble(temp); else if (PyLong_Check(temp)) vecs[i][l] = (double) PyLong_AsLong(temp); #if PY_MAJOR_VERSION < 3 else if (PyInt_Check(temp)) vecs[i][l] = (double) PyInt_AsLong(temp); #endif else throw Py::ValueError("Wrong parameter format, four Tuple of three floats needed!"); } } // call the write method of PovTools.... PovTools::writeCamera(FileName,CamDef(gp_Vec(vecs[0][0],vecs[0][1],vecs[0][2]), gp_Vec(vecs[1][0],vecs[1][1],vecs[1][2]), gp_Vec(vecs[2][0],vecs[2][1],vecs[2][2]), gp_Vec(vecs[3][0],vecs[3][1],vecs[3][2]))); return Py::None(); }