static PyObject *
svc_FindVisibleRegion(captureobject *self, PyObject *args)
{
void *visible;
int width;
if (!PyArg_Parse(args, ""))
return NULL;
if (svFindVisibleRegion(self->ob_svideo->ob_svideo,
self->ob_capture, &visible,
self->ob_info.width))
return sv_error();
if (visible == NULL) {
PyErr_SetString(SvError, "data in wrong format");
return NULL;
}
return newcaptureobject(self->ob_svideo, visible, 0);
}
/*
* Set attribute
*
* Arguments: self - The X509Name object
* name - The attribute name
* value - The value to set
*/
static int
crypto_X509Name_setattr(crypto_X509NameObj *self, char *name, PyObject *value)
{
int nid;
int result;
char *buffer;
if ((nid = OBJ_txt2nid(name)) == NID_undef)
{
PyErr_SetString(PyExc_AttributeError, "No such attribute");
return -1;
}
/* Something of a hack to get nice unicode behaviour */
if (!PyArg_Parse(value, "es:setattr", "utf-8", &buffer))
return -1;
result = set_name_by_nid(self->x509_name, nid, buffer);
PyMem_Free(buffer);
return result;
}
static PyObject *
DynamicMusic_addScene(DynamicMusicP* self, PyObject* args)
{
PyObject* object;
if(!PyArg_Parse(args, "O:sound", &object))
return nullptr;
Sound* sound = checkSound(object);
if(!sound)
return nullptr;
try
{
return Py_BuildValue("i", (*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->addScene(*reinterpret_cast<std::shared_ptr<aud::ISound>*>(sound->sound)));
}
catch(aud::Exception& e)
{
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
static PyObject *tdb_hnd_subscript(tdb_hnd_object *obj, PyObject *key)
{
TDB_DATA drec, krec;
PyObject *result;
if (!PyArg_Parse(key, "s#", &krec.dptr, &krec.dsize))
return NULL;
drec = tdb_fetch(obj->tdb, krec);
if (!drec.dptr) {
PyErr_SetString(PyExc_KeyError,
PyString_AsString(key));
return NULL;
}
result = PyString_FromStringAndSize(drec.dptr, drec.dsize);
free(drec.dptr);
return result;
}
static int
DynamicMusic_set_volume(DynamicMusicP* self, PyObject* args, void* nothing)
{
float volume;
if(!PyArg_Parse(args, "f:volume", &volume))
return -1;
try
{
if((*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->setVolume(volume))
return 0;
PyErr_SetString(AUDError, "Couldn't change the volume!");
}
catch(aud::Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
return -1;
}
static int
DynamicMusic_set_scene(DynamicMusicP* self, PyObject* args, void* nothing)
{
int scene;
if(!PyArg_Parse(args, "i:scene", &scene))
return -1;
try
{
if((*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->changeScene(scene))
return 0;
PyErr_SetString(AUDError, "Couldn't change the scene!");
}
catch(aud::Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
return -1;
}
static int
DynamicMusic_set_position(DynamicMusicP* self, PyObject* args, void* nothing)
{
float position;
if(!PyArg_Parse(args, "f:position", &position))
return -1;
try
{
if((*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->seek(position))
return 0;
PyErr_SetString(AUDError, "Couldn't seek the sound!");
}
catch(aud::Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
return -1;
}
static PyObject *
rpmts_HdrCheck(rpmtsObject * s, PyObject *obj)
{
PyObject * blob;
char * msg = NULL;
const void * uh;
int uc;
rpmRC rpmrc;
if (!PyArg_Parse(obj, "S:HdrCheck", &blob))
return NULL;
uh = PyBytes_AsString(blob);
uc = PyBytes_Size(blob);
Py_BEGIN_ALLOW_THREADS;
rpmrc = headerCheck(s->ts, uh, uc, &msg);
Py_END_ALLOW_THREADS;
return Py_BuildValue("(is)", rpmrc, msg);
}
static PyObject *
forms_show_choice(PyObject *f, PyObject *args)
{
char *m1, *m2, *m3, *b1, *b2, *b3;
int nb;
char *format;
long rv;
if (args == NULL || !PyTuple_Check(args)) {
PyErr_BadArgument();
return NULL;
}
nb = PyTuple_Size(args) - 3;
if (nb <= 0) {
PyErr_SetString(PyExc_TypeError,
"need at least one button label");
return NULL;
}
if (PyInt_Check(PyTuple_GetItem(args, 3))) {
PyErr_SetString(PyExc_TypeError,
"'number-of-buttons' argument not needed");
return NULL;
}
switch (nb) {
case 1: format = "(ssss)"; break;
case 2: format = "(sssss)"; break;
case 3: format = "(ssssss)"; break;
default:
PyErr_SetString(PyExc_TypeError, "too many button labels");
return NULL;
}
if (!PyArg_Parse(args, format, &m1, &m2, &m3, &b1, &b2, &b3))
return NULL;
Py_BEGIN_ALLOW_THREADS
rv = fl_show_choice(m1, m2, m3, nb, b1, b2, b3);
Py_END_ALLOW_THREADS
return PyInt_FromLong(rv);
}
void IndividualHumanPy::Expose( const IContagionPopulation* cp, float dt, TransmissionRoute::Enum transmission_route )
{
#ifdef ENABLE_PYTHON_FEVER
if( cp->GetTotalContagion() == 0 )
{
return;
}
LOG_DEBUG_F( "Calling py:expose with contagion pop %f\n", cp->GetTotalContagion() );
static auto pFunc = PythonSupportPtr->IdmPyInit( PythonSupport::SCRIPT_PYTHON_FEVER.c_str(), "expose" );
if( pFunc )
{
// pass individual id AND dt
static PyObject * vars = PyTuple_New(4);
vars = Py_BuildValue( "llls", GetSuid().data, int(cp->GetTotalContagion()), int(dt), PyLong_FromLong( transmission_route == TransmissionRoute::TRANSMISSIONROUTE_ENVIRONMENTAL ? 0 : 1 ) );
PyObject * retVal = PyObject_CallObject( pFunc, vars );
if( retVal == nullptr )
{
PyErr_Print();
std::stringstream msg;
msg << "Embedded python code failed: PyObject_CallObject failed in call to 'expose'.";
throw Kernel::IllegalOperationException( __FILE__, __LINE__, __FUNCTION__, msg.str().c_str() );
}
bool val = false;
PyArg_Parse( retVal, "b", &val );
if( val )
{
StrainIdentity strainId;
AcquireNewInfection(&strainId);
}
#if !defined(_WIN32) || !defined(_DEBUG)
Py_DECREF( retVal );
#endif
}
return;
#endif
}
static PyObject *riscos_listdir(PyObject *self,PyObject *args)
{ char *path,buf[256];
PyObject *d, *v;
int c=0,count;
if (!PyArg_Parse(args, "s", &path)) return NULL;
d=PyList_New(0);
if(!d) return NULL;
for(;;)
{ e=xosgbpb_dir_entries(path,(osgbpb_string_list*)buf,
1,c,256,0,&count,&c);
if(e)
{ Py_DECREF(d);return riscos_oserror();
}
if(count)
{ v=PyString_FromString(buf);
if(!v) { Py_DECREF(d);return 0;}
if(PyList_Append(d,v)) {Py_DECREF(d);Py_DECREF(v);return 0;}
}
if(c==-1) break;
}
return d;
}
static PyObject *
sv_CaptureOneFrame(svobject *self, PyObject *args)
{
svCaptureInfo info;
int format, width, height;
int bytes;
PyObject *videodata = NULL;
PyObject *res = NULL;
char *str;
if (!PyArg_Parse(args, "(iii)", &format, &width, &height))
return NULL;
info.format = format;
info.width = width;
info.height = height;
info.size = 0;
info.samplingrate = 0;
if (svQueryCaptureBufferSize(self->ob_svideo, &info, &bytes))
return sv_error();
if (!(videodata = PyString_FromStringAndSize(NULL, bytes)))
return NULL;
str = PyString_AsString(videodata);
if (!str)
goto finally;
if (svCaptureOneFrame(self->ob_svideo, format, &width, &height, str)) {
res = sv_error();
goto finally;
}
res = Py_BuildValue("(iiO)", width, height, videodata);
finally:
Py_XDECREF(videodata);
return res;
}
bool OsdInfo::RemovePool()
{
s32 sl1;
if (pyFunc_RemovePool && PyCallable_Check(pyFunc_RemovePool))
{
FiEvent evt;
evt.Wait(1000);
char *str1;
PyObject *pyRet = PyObject_CallObject(pyFunc_RemovePool,NULL);
PyArg_Parse(pyRet, "(ls)", &sl1, &str1);
OSD_LOG_ERR("===RemovePool===ret[%d],retStr[%s]\n",sl1,str1);
}
if (sl1 == 0)
{
return true;
}
else
{
return false;
}
}
static PyObject *
_dbm_dbm_setdefault_impl(dbmobject *self, const char *key,
Py_ssize_clean_t key_length,
PyObject *default_value)
/*[clinic end generated code: output=52545886cf272161 input=6a3b99ae91f20203]*/
{
datum dbm_key, val;
Py_ssize_t tmp_size;
dbm_key.dptr = (char *)key;
dbm_key.dsize = key_length;
check_dbmobject_open(self);
val = dbm_fetch(self->di_dbm, dbm_key);
if (val.dptr != NULL)
return PyBytes_FromStringAndSize(val.dptr, val.dsize);
if (default_value == NULL) {
default_value = PyBytes_FromStringAndSize(NULL, 0);
if (default_value == NULL)
return NULL;
val.dptr = NULL;
val.dsize = 0;
}
else {
if ( !PyArg_Parse(default_value, "s#", &val.dptr, &tmp_size) ) {
PyErr_SetString(PyExc_TypeError,
"dbm mappings have byte string elements only");
return NULL;
}
val.dsize = tmp_size;
Py_INCREF(default_value);
}
if (dbm_store(self->di_dbm, dbm_key, val, DBM_INSERT) < 0) {
dbm_clearerr(self->di_dbm);
PyErr_SetString(DbmError, "cannot add item to database");
Py_DECREF(default_value);
return NULL;
}
return default_value;
}
mediacontrol_PositionOrigin
positionOrigin_py_to_c( PyObject * py_origin )
{
mediacontrol_PositionOrigin origin_position = mediacontrol_AbsolutePosition;
int origin;
if( !PyArg_Parse( py_origin,"i", &origin ) )
{
PyErr_SetString( MediaControl_InternalException,
"Invalid origin value" );
return origin_position;
}
switch ( origin )
{
case 0: origin_position = mediacontrol_AbsolutePosition; break;
case 1: origin_position = mediacontrol_RelativePosition; break;
case 2: origin_position = mediacontrol_ModuloPosition; break;
}
return origin_position;
}
static int rv_setitem(PyObject* self, Py_ssize_t ix, PyObject* value) {
NPyRangeVar* r = (NPyRangeVar*)self;
if (ix < 0 || ix >= rv_len(self)) {
PyErr_SetString(PyExc_IndexError, r->sym_->name);
return -1;
}
int err;
double* d = nrnpy_rangepointer(r->pyseg_->pysec_->sec_, r->sym_, r->pyseg_->x_, &err);
if (!d) {
rv_noexist(r->pyseg_->pysec_->sec_, r->sym_->name, r->pyseg_->x_, err);
return -1;
}
d += ix;
if (!PyArg_Parse(value, "d", d)) {
PyErr_SetString(PyExc_ValueError, "bad value");
return -1;
}
if (r->sym_->u.rng.type == EXTRACELL && r->sym_->u.rng.index == 0) {
diam_changed = 1;
}
return 0;
}
QStringList PythonEngine::codePyFlakes(const QString& fileName)
{
QStringList out;
if (!m_isScriptRunning)
{
QString exp = QString("result_pyflakes_pythonlab = python_engine_pyflakes_check(\"%1\")").arg(compatibleFilename(fileName));
#pragma omp critical(flakes)
{
PyObject *run = PyRun_String(exp.toLatin1().data(), Py_single_input, m_dict, m_dict);
// parse result
PyObject *result = PyDict_GetItemString(m_dict, "result_pyflakes_pythonlab");
if (result)
{
Py_INCREF(result);
PyObject *list;
if (PyArg_Parse(result, "O", &list))
{
int count = PyList_Size(list);
for (int i = 0; i < count; i++)
{
PyObject *item = PyList_GetItem(list, i);
QString str = PyString_AsString(item);
out.append(str);
}
}
Py_DECREF(result);
}
Py_XDECREF(run);
PyObject *del = PyRun_String("del result_pyflakes_pythonlab", Py_single_input, m_dict, m_dict);
Py_XDECREF(del);
}
}
return out;
}
void OsdInfo::GetPoolUsed(vector<PoolInfo> &piAry)
{
if (pyFunc_GetPoolUsed && PyCallable_Check(pyFunc_GetPoolUsed))
{
string poolType;
char *str1,*str2;
s64 sll1,sll2;
s32 sl1;
PyObject *pyRet = PyObject_CallObject(pyFunc_GetPoolUsed,NULL);
PyObject *pyRetItem = NULL;
PoolInfo pi;
for (u32 i = 0;i<PyList_Size(pyRet);++i)
{
pyRetItem = PyList_GetItem(pyRet,i);
PyArg_Parse(pyRetItem, "(sLLls)", &str1, &sll1, &sll2, &sl1, &str2);
OSD_LOG_ERR("===GetPoolUsed=== %s,%lld,%lld,%d,%s\n",str1,sll1,sll2,sl1,str2);
poolType = str1;
if (poolType == "Meta")
{
pi.poolType = OsdInfo_Meta;
}
else if (poolType == "Data")
{
pi.poolType = OsdInfo_Data;
}
else
{
pi.poolType = OsdInfo_Unkown;
}
pi.poolMountPoint = str2;
pi.poolUsed = sll1;
pi.poolLeft = sll2;
pi.usedPct = sl1;
piAry.push_back(pi);
}
}
}
static PyObject *
dbm_subscript(dbmobject *dp, register PyObject *key)
{
PyObject *v;
datum drec, krec;
if (!PyArg_Parse(key, "s#", &krec.dptr, &krec.dsize) )
return NULL;
if (dp->di_dbm == NULL) {
PyErr_SetString(DbmError,
"GDBM object has already been closed");
return NULL;
}
drec = gdbm_fetch(dp->di_dbm, krec);
if (drec.dptr == 0) {
PyErr_SetObject(PyExc_KeyError, key);
return NULL;
}
v = PyBytes_FromStringAndSize(drec.dptr, drec.dsize);
free(drec.dptr);
return v;
}
static PyObject *
lock_PyThread_acquire_lock(lockobject *self, PyObject *args)
{
int i;
if (args != NULL) {
if (!PyArg_Parse(args, "i", &i))
return NULL;
}
else
i = 1;
Py_BEGIN_ALLOW_THREADS
i = PyThread_acquire_lock(self->lock_lock, i);
Py_END_ALLOW_THREADS
if (args == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
else
return PyInt_FromLong((long)i);
}
STDMETHODIMP PyGShellItemArray::GetPropertyStore(
/* [in] */ GETPROPERTYSTOREFLAGS flags,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void ** ppv)
{
PY_GATEWAY_METHOD;
PyObject *obriid;
obriid = PyWinObject_FromIID(riid);
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetPropertyStore", &result, "kO", flags, obriid);
Py_XDECREF(obriid);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
PyObject *obppv;
if (!PyArg_Parse(result, "O" , &obppv))
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetPropertyStore");
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obppv, riid, (void **)ppv, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetPropertyStore");
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGShellView::GetItemObject(
/* [in] */ UINT uItem,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void ** ppv)
{
PY_GATEWAY_METHOD;
*ppv = NULL;
PyObject *obriid;
obriid = PyWinObject_FromIID(riid);
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetItemObject", &result, "iO", uItem, obriid);
Py_XDECREF(obriid);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
PyObject *obppv;
if (!PyArg_Parse(result, "O" , &obppv)) return MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetItemObject");
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obppv, riid, ppv, FALSE/* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetItemObject");
Py_DECREF(result);
return hr;
}
main() {
char *cstr;
PyObject *pstr, *pmod, *pdict;
printf("basic2\n");
Py_Initialize();
/* get string.uppercase */
pmod = PyImport_ImportModule("string");
pdict = PyModule_GetDict(pmod);
pstr = PyRun_String("uppercase", Py_eval_input, pdict, pdict);
/* convert to C */
PyArg_Parse(pstr, "s", &cstr);
printf("%s\n", cstr);
/* assign string.X */
PyObject_SetAttrString(pmod, "X", pstr);
/* print string.lower */
(void) PyRun_String("print lower(X)", Py_file_input, pdict, pdict);
Py_DECREF(pmod);
Py_DECREF(pstr);
}
static PyObject *
dbm_subscript(dbmobject *dp, PyObject *key)
{
datum drec, krec;
Py_ssize_t tmp_size;
if (!PyArg_Parse(key, "s#", &krec.dptr, &tmp_size) )
return NULL;
krec.dsize = tmp_size;
check_dbmobject_open(dp);
drec = dbm_fetch(dp->di_dbm, krec);
if ( drec.dptr == 0 ) {
PyErr_SetObject(PyExc_KeyError, key);
return NULL;
}
if ( dbm_error(dp->di_dbm) ) {
dbm_clearerr(dp->di_dbm);
PyErr_SetString(DbmError, "");
return NULL;
}
return PyBytes_FromStringAndSize(drec.dptr, drec.dsize);
}
static PyObject *
imageop_tovideo(PyObject *self, PyObject *args)
{
int maxx, maxy, x, y, len;
int i;
unsigned char *cp, *ncp;
int width;
PyObject *rv;
if ( !PyArg_Parse(args, "(s#iii)", &cp, &len, &width, &maxx, &maxy) )
return 0;
if ( width != 1 && width != 4 ) {
PyErr_SetString(ImageopError, "Size should be 1 or 4");
return 0;
}
if ( maxx*maxy*width != len ) {
PyErr_SetString(ImageopError, "String has incorrect length");
return 0;
}
rv = PyString_FromStringAndSize(NULL, len);
if ( rv == 0 )
return 0;
ncp = (unsigned char *)PyString_AsString(rv);
if ( width == 1 ) {
memcpy(ncp, cp, maxx); /* Copy first line */
ncp += maxx;
for (y=1; y<maxy; y++) { /* Interpolate other lines */
for(x=0; x<maxx; x++) {
i = y*maxx + x;
*ncp++ = ((int)cp[i] + (int)cp[i-maxx]) >> 1;
}
}
} else {
/**
* @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 *
generic_add_object(formobject *f, PyObject *args, FL_OBJECT *(*func)(int, float, float, float, float, char*), PyMethodDef *internal_methods)
{
int type;
float x, y, w, h;
char *name;
FL_OBJECT *obj;
if (!PyArg_Parse(args,"(iffffs)", &type,&x,&y,&w,&h,&name))
return NULL;
fl_addto_form (f-> ob_form);
obj = (*func) (type, x, y, w, h, name);
fl_end_form();
if (obj == NULL) {
PyErr_NoMemory();
return NULL;
}
return newgenericobject (obj, internal_methods);
}
static PyObject *
rpmts_HdrFromFdno(rpmtsObject * s, PyObject *arg)
{
PyObject *ho = NULL;
rpmfdObject *fdo = NULL;
Header h;
rpmRC rpmrc;
if (!PyArg_Parse(arg, "O&:HdrFromFdno", rpmfdFromPyObject, &fdo))
return NULL;
Py_BEGIN_ALLOW_THREADS;
rpmrc = rpmReadPackageFile(s->ts, rpmfdGetFd(fdo), NULL, &h);
Py_END_ALLOW_THREADS;
Py_XDECREF(fdo);
if (rpmrc == RPMRC_OK) {
ho = hdr_Wrap(&hdr_Type, h);
} else {
Py_INCREF(Py_None);
ho = Py_None;
}
return Py_BuildValue("(iN)", rpmrc, ho);
}
static PyObject* AUD_getSoundFromPointer(PyObject* self, PyObject* args)
{
long int lptr;
if(PyArg_Parse(args, "l:_sound_from_pointer", &lptr))
{
if(lptr)
{
AUD_Reference<AUD_IFactory>* factory = (AUD_Reference<AUD_IFactory>*) sound_get_factory((void*) lptr);
if(factory)
{
Factory* obj = (Factory*) Factory_empty();
if(obj)
{
obj->factory = new AUD_Reference<AUD_IFactory>(*factory);
return (PyObject*) obj;
}
}
}
}
Py_RETURN_NONE;
}
static PyObject* ComposeWindow_attach(clawsmail_ComposeWindowObject *self, PyObject *args)
{
PyObject *olist;
Py_ssize_t size, iEl;
GList *list = NULL;
if(!PyArg_ParseTuple(args, "O!", &PyList_Type, &olist))
return NULL;
size = PyList_Size(olist);
for(iEl = 0; iEl < size; iEl++) {
char *ss;
PyObject *element = PyList_GET_ITEM(olist, iEl);
if(!element)
continue;
Py_INCREF(element);
if(!PyArg_Parse(element, "s", &ss)) {
Py_DECREF(element);
if(list)
g_list_free(list);
return NULL;
}
list = g_list_prepend(list, ss);
Py_DECREF(element);
}
compose_attach_from_list(self->compose, list, FALSE);
g_list_free(list);
flush_gtk_queue();
Py_INCREF(Py_None);
return Py_None;
}
