//-------------------------------------------------------------------------------------
PyObject* EntityMailboxAbstract::__py_reduce_ex__(PyObject* self, PyObject* protocol)
{
EntityMailboxAbstract* emailbox = static_cast<EntityMailboxAbstract*>(self);
PyObject* args = PyTuple_New(2);
PyObject* unpickleMethod = script::Pickler::getUnpickleFunc("Mailbox");
PyTuple_SET_ITEM(args, 0, unpickleMethod);
PyObject* args1 = PyTuple_New(4);
PyTuple_SET_ITEM(args1, 0, PyLong_FromLong(emailbox->getID()));
PyTuple_SET_ITEM(args1, 1, PyLong_FromUnsignedLongLong(emailbox->getComponentID()));
PyTuple_SET_ITEM(args1, 2, PyLong_FromUnsignedLong(emailbox->getUType()));
int16 mbType = static_cast<int16>(emailbox->getType());
PyTuple_SET_ITEM(args1, 3, PyLong_FromLong(mbType));
PyTuple_SET_ITEM(args, 1, args1);
if(unpickleMethod == NULL) {
Py_DECREF(args);
return NULL;
}
return args;
}
static PyObject *get_scale(instruction_t *self, PyObject *args)
{
unsigned int i;
xed_decoded_inst_t *decoded_inst;
xed_uint_t scale;
PyObject *r = NULL;
if(PyArg_ParseTuple(args, "I", &i) == 0)
goto _err;
decoded_inst = self->decoded_inst;
if(i >= xed_decoded_inst_number_of_memory_operands(decoded_inst))
{
PyErr_SetString(PyExc_IndexError, "Invalid operand index");
goto _err;
}
scale = xed_decoded_inst_get_scale(decoded_inst, i);
r = PyLong_FromUnsignedLong(scale);
_err:
return r;
}
static void __pyx_f_13cunsignedlong_f(void) {
unsigned long __pyx_v_x;
PyObject *__pyx_v_y;
unsigned long __pyx_1;
PyObject *__pyx_2 = 0;
__pyx_v_y = Py_None; Py_INCREF(Py_None);
/* "/Local/Projects/D/Pyrex/Source/Tests/8/cunsignedlong.pyx":4 */
__pyx_1 = PyInt_AsUnsignedLongMask(__pyx_v_y); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; goto __pyx_L1;}
__pyx_v_x = __pyx_1;
/* "/Local/Projects/D/Pyrex/Source/Tests/8/cunsignedlong.pyx":5 */
__pyx_2 = PyLong_FromUnsignedLong(__pyx_v_x); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; goto __pyx_L1;}
Py_DECREF(__pyx_v_y);
__pyx_v_y = __pyx_2;
__pyx_2 = 0;
goto __pyx_L0;
__pyx_L1:;
Py_XDECREF(__pyx_2);
__Pyx_WriteUnraisable("cunsignedlong.f");
__pyx_L0:;
Py_DECREF(__pyx_v_y);
}
PyObject *py_ue_skeletal_mesh_get_active_bone_indices(ue_PyUObject *self, PyObject * args)
{
ue_py_check(self);
int lod_index = 0;
if (!PyArg_ParseTuple(args, "|i:skeletal_mesh_get_active_bone_indices", &lod_index))
return nullptr;
USkeletalMesh *mesh = ue_py_check_type<USkeletalMesh>(self);
if (!mesh)
return PyErr_Format(PyExc_Exception, "uobject is not a USkeletalMesh");
#if ENGINE_MINOR_VERSION < 19
FSkeletalMeshResource *resource = mesh->GetImportedResource();
#else
FSkeletalMeshModel *resource = mesh->GetImportedModel();
#endif
if (lod_index < 0 || lod_index >= resource->LODModels.Num())
return PyErr_Format(PyExc_Exception, "invalid LOD index, must be between 0 and %d", resource->LODModels.Num() - 1);
#if ENGINE_MINOR_VERSION < 19
FStaticLODModel &model = resource->LODModels[lod_index];
#else
FSkeletalMeshLODModel &model = resource->LODModels[lod_index];
#endif
PyObject *py_list = PyList_New(0);
for (uint16 index : model.ActiveBoneIndices)
{
PyList_Append(py_list, PyLong_FromUnsignedLong(index));
}
return py_list;
}
/* {{{ get_attrs
*/
PyObject *
get_attrs(LIBSSH2_SFTP_ATTRIBUTES *attr)
{
PyObject *attrs=NULL;
attrs = PyList_New(0);
PyList_Append(attrs, PyLong_FromUnsignedLong(
(unsigned long)attr->filesize));
PyList_Append(attrs, PyLong_FromUnsignedLong(
(unsigned long)attr->uid));
PyList_Append(attrs, PyLong_FromUnsignedLong(
(unsigned long)attr->gid));
PyList_Append(attrs, PyLong_FromUnsignedLong(
(unsigned long)attr->permissions));
PyList_Append(attrs, PyLong_FromUnsignedLong(
(unsigned long)attr->atime));
PyList_Append(attrs, PyLong_FromUnsignedLong(
(unsigned long)attr->mtime));
return attrs;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControl, getFontSize)
{
return PyLong_FromUnsignedLong(self->fThis->GetFontSize());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGameMgrInviteRevokedMsg, newGameID)
{
return PyLong_FromUnsignedLong(self->fThis->NewGameID());
}
PyObject* PythonQtConv::ConvertQtValueToPythonInternal(int type, const void* data) {
switch (type) {
case QMetaType::Void:
Py_INCREF(Py_None);
return Py_None;
case QMetaType::Char:
return PyInt_FromLong(*((char*)data));
case QMetaType::UChar:
return PyInt_FromLong(*((unsigned char*)data));
case QMetaType::Short:
return PyInt_FromLong(*((short*)data));
case QMetaType::UShort:
return PyInt_FromLong(*((unsigned short*)data));
case QMetaType::Long:
return PyInt_FromLong(*((long*)data));
case QMetaType::ULong:
// does not fit into simple int of python
return PyLong_FromUnsignedLong(*((unsigned long*)data));
case QMetaType::Bool:
return PythonQtConv::GetPyBool(*((bool*)data));
case QMetaType::Int:
return PyInt_FromLong(*((int*)data));
case QMetaType::UInt:
// does not fit into simple int of python
return PyLong_FromUnsignedLong(*((unsigned int*)data));
case QMetaType::QChar:
return PyInt_FromLong(*((short*)data));
case QMetaType::Float:
return PyFloat_FromDouble(*((float*)data));
case QMetaType::Double:
return PyFloat_FromDouble(*((double*)data));
case QMetaType::LongLong:
return PyLong_FromLongLong(*((qint64*)data));
case QMetaType::ULongLong:
return PyLong_FromUnsignedLongLong(*((quint64*)data));
// implicit conversion from QByteArray to str has been removed:
//case QMetaType::QByteArray: {
// QByteArray* v = (QByteArray*) data;
// return PyString_FromStringAndSize(*v, v->size());
// }
case QMetaType::QVariantMap:
return PythonQtConv::QVariantMapToPyObject(*((QVariantMap*)data));
case QMetaType::QVariantList:
return PythonQtConv::QVariantListToPyObject(*((QVariantList*)data));
case QMetaType::QString:
return PythonQtConv::QStringToPyObject(*((QString*)data));
case QMetaType::QStringList:
return PythonQtConv::QStringListToPyObject(*((QStringList*)data));
case PythonQtMethodInfo::Variant:
return PythonQtConv::QVariantToPyObject(*((QVariant*)data));
case QMetaType::QObjectStar:
case QMetaType::QWidgetStar:
return PythonQt::priv()->wrapQObject(*((QObject**)data));
default:
if (PythonQt::priv()->isPythonQtObjectPtrMetaId(type)) {
// special case, it is a PythonQtObjectPtr which contains a PyObject, take it directly:
PyObject* o = ((PythonQtObjectPtr*)data)->object();
Py_INCREF(o);
return o;
} else {
if (type > 0) {
// if the type is known, we can construct it via QMetaType::construct
void* newCPPObject = QMetaType::construct(type, data);
// XXX this could be optimized by using metatypeid directly
PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)PythonQt::priv()->wrapPtr(newCPPObject, QMetaType::typeName(type));
wrap->_ownedByPythonQt = true;
wrap->_useQMetaTypeDestroy = true;
return (PyObject*)wrap;
}
std::cerr << "Unknown type that can not be converted to Python: " << type << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
}
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
demarshal_value(CORBA_TypeCode tc, gconstpointer *val)
{
PyObject *ret = NULL;
while (tc->kind == CORBA_tk_alias)
tc = tc->subtypes[0];
switch (tc->kind) {
case CORBA_tk_null:
case CORBA_tk_void:
ret = Py_None;
Py_INCREF(ret);
break;
case CORBA_tk_short:
alignval(val, ORBIT_ALIGNOF_CORBA_SHORT);
ret = PyInt_FromLong(getval(val, CORBA_short));
advanceptr(val, sizeof(CORBA_short));
break;
case CORBA_tk_long:
alignval(val, ORBIT_ALIGNOF_CORBA_LONG);
ret = PyInt_FromLong(getval(val, CORBA_long));
advanceptr(val, sizeof(CORBA_long));
break;
case CORBA_tk_ushort:
alignval(val, ORBIT_ALIGNOF_CORBA_SHORT);
ret = PyInt_FromLong(getval(val, CORBA_unsigned_short));
advanceptr(val, sizeof(CORBA_unsigned_short));
break;
case CORBA_tk_ulong:
alignval(val, ORBIT_ALIGNOF_CORBA_LONG);
ret = PyLong_FromUnsignedLong(getval(val, CORBA_unsigned_long));
advanceptr(val, sizeof(CORBA_unsigned_long));
break;
case CORBA_tk_float:
alignval(val, ORBIT_ALIGNOF_CORBA_FLOAT);
ret = PyFloat_FromDouble(getval(val, CORBA_float));
advanceptr(val, sizeof(CORBA_float));
break;
case CORBA_tk_double:
alignval(val, ORBIT_ALIGNOF_CORBA_DOUBLE);
ret = PyFloat_FromDouble(getval(val, CORBA_double));
advanceptr(val, sizeof(CORBA_double));
break;
case CORBA_tk_boolean:
ret = getval(val, CORBA_boolean) ? Py_True : Py_False;
Py_INCREF(ret);
advanceptr(val, sizeof(CORBA_boolean));
break;
case CORBA_tk_char: {
char charbuf[2];
charbuf[0] = getval(val, CORBA_char);
charbuf[1] = '\0';
ret = PyString_FromString(charbuf);
advanceptr(val, sizeof(CORBA_char));
break;
}
case CORBA_tk_octet:
ret = PyInt_FromLong(getval(val, CORBA_octet));
advanceptr(val, sizeof(CORBA_octet));
break;
case CORBA_tk_any:
alignval(val, ORBIT_ALIGNOF_CORBA_ANY);
ret = pycorba_any_new(&getval(val, CORBA_any));
advanceptr(val, sizeof(CORBA_any));
break;
case CORBA_tk_TypeCode:
alignval(val, ORBIT_ALIGNOF_CORBA_POINTER);
ret = pycorba_typecode_new(getval(val, CORBA_TypeCode));
advanceptr(val, sizeof(CORBA_TypeCode));
break;
case CORBA_tk_Principal:
g_warning("can't demarshal Principal's");
break;
case CORBA_tk_objref:
alignval(val, ORBIT_ALIGNOF_CORBA_POINTER);
ret = pycorba_object_new_with_type(getval(val, CORBA_Object), tc);
advanceptr(val, sizeof(CORBA_Object));
break;
case CORBA_tk_struct:
case CORBA_tk_except: {
PyObject *stub;
PyObject *instance;
gint i;
alignval(val, tc->c_align);
stub = pyorbit_get_stub(tc);
if (!stub) {
if (tc->kind == CORBA_tk_struct)
stub = (PyObject *)&PyBaseObject_Type;
else
stub = pyorbit_exception;
}
instance = PyObject_CallFunction(stub, "()");
if (!instance)
break;
if (stub == pyorbit_exception) {
PyObject *pytc = pycorba_typecode_new(tc);
PyObject_SetAttrString(instance, "__typecode__", pytc);
Py_DECREF(pytc);
}
for (i = 0; i < tc->sub_parts; i++) {
PyObject *item;
gchar *pyname;
item = demarshal_value(tc->subtypes[i], val);
if (!item) {
Py_DECREF(instance);
break;
}
pyname = _pyorbit_escape_name(tc->subnames[i]);
PyObject_SetAttrString(instance, pyname, item);
g_free(pyname);
Py_DECREF(item);
}
if (i == tc->sub_parts) ret = instance;
break;
}
case CORBA_tk_union: {
PyObject *stub, *instance, *discrim, *subval;
CORBA_TypeCode subtc;
gint i, sz = 0;
gconstpointer body;
alignval(val, MAX(tc->c_align, tc->discriminator->c_align));
stub = pyorbit_get_stub(tc);
if (!stub) {
if (tc->kind == CORBA_tk_struct)
stub = (PyObject *)&PyBaseObject_Type;
else
stub = PyExc_Exception;
}
instance = PyObject_CallFunction(stub, "()");
if (!instance)
break;
discrim = demarshal_value(tc->discriminator, val);
if (!discrim) {
Py_DECREF(instance);
break;
}
subtc = get_union_tc(tc, discrim);
if (!subtc) {
Py_DECREF(instance);
Py_DECREF(discrim);
break;
}
PyObject_SetAttrString(instance, "_d", discrim);
Py_DECREF(discrim);
for (i = 0; i < tc->sub_parts; i++)
sz = MAX(sz, ORBit_gather_alloc_info(tc->subtypes[i]));
alignval(val, tc->c_align);
body = *val;
subval = demarshal_value(subtc, &body);
if (!subval) {
Py_DECREF(instance);
break;
}
PyObject_SetAttrString(instance, "_v", subval);
Py_DECREF(subval);
ret = instance;
advanceptr(val, sz);
break;
}
case CORBA_tk_enum:
alignval(val, ORBIT_ALIGNOF_CORBA_LONG);
ret = pycorba_enum_from_long(tc, getval(val, CORBA_unsigned_long));
advanceptr(val, sizeof(CORBA_unsigned_long));
break;
case CORBA_tk_string: {
CORBA_string str;
alignval(val, ORBIT_ALIGNOF_CORBA_POINTER);
str = getval(val, CORBA_string);
advanceptr(val, sizeof(CORBA_string));
if (str) {
ret = PyString_FromString(str);
} else {
Py_INCREF(Py_None);
ret = Py_None;
}
break;
}
case CORBA_tk_sequence: {
const CORBA_sequence_CORBA_octet *sval;
gconstpointer seqval;
alignval(val, ORBIT_ALIGNOF_CORBA_SEQ);
sval = (CORBA_sequence_CORBA_octet *)*val;
advanceptr(val, sizeof(CORBA_sequence_CORBA_octet));
switch (tc->subtypes[0]->kind) {
case CORBA_tk_char:
case CORBA_tk_octet:
ret = PyString_FromStringAndSize((char *) sval->_buffer, sval->_length);
break;
default: {
PyObject *list;
Py_ssize_t i;
int align;
list = PyList_New(sval->_length);
align = tc->subtypes[0]->c_align;
seqval = sval->_buffer;
for (i = 0; i < sval->_length; i++) {
PyObject *item;
alignval(&seqval, align);
item = demarshal_value(tc->subtypes[0], &seqval);
if (!item) {
Py_DECREF(list);
break;
}
PyList_SetItem(list, i, item);
}
if (i == sval->_length) ret = list;
}
}
break;
}
case CORBA_tk_array:
switch (tc->subtypes[0]->kind) {
case CORBA_tk_char:
case CORBA_tk_octet:
ret = PyString_FromStringAndSize(*val, tc->length);
advanceptr(val, tc->length);
break;
default: {
PyObject *list;
gint i, align;
list = PyList_New(tc->length);
align = tc->subtypes[0]->c_align;
for (i = 0; i < tc->length; i++) {
PyObject *item;
alignval(val, align);
item = demarshal_value(tc->subtypes[0], val);
if (!item) {
Py_DECREF(list);
break;
}
PyList_SetItem(list, i, item);
}
if (i == tc->length) ret = list;
}
}
break;
case CORBA_tk_longlong:
alignval(val, ORBIT_ALIGNOF_CORBA_LONG_LONG);
ret = PyLong_FromLongLong(getval(val, CORBA_long_long));
advanceptr(val, sizeof(CORBA_long_long));
break;
case CORBA_tk_ulonglong:
alignval(val, ORBIT_ALIGNOF_CORBA_LONG_LONG);
ret = PyLong_FromUnsignedLongLong(getval(val, CORBA_unsigned_long_long));
advanceptr(val, sizeof(CORBA_unsigned_long_long));
break;
case CORBA_tk_longdouble:
g_warning("can't demarshal long doubles");
break;
case CORBA_tk_wchar: {
Py_UNICODE uchar;
alignval(val, ORBIT_ALIGNOF_CORBA_SHORT);
uchar = getval(val, CORBA_wchar);
ret = PyUnicode_FromUnicode(&uchar, 1);
advanceptr(val, sizeof(CORBA_wchar));
break;
}
case CORBA_tk_wstring: {
CORBA_wstring wstr;
alignval(val, ORBIT_ALIGNOF_CORBA_POINTER);
wstr = getval(val, CORBA_wstring);
advanceptr(val, sizeof(CORBA_wstring));
if (wstr) {
gint i, length = CORBA_wstring_len(wstr);
Py_UNICODE *ustr;
ustr = g_new(Py_UNICODE, length);
for (i = 0; i < length; i++) ustr[i] = wstr[i];
ret = PyUnicode_FromUnicode(ustr, length);
g_free(ustr);
} else {
Py_INCREF(Py_None);
ret = Py_None;
}
break;
}
default:
g_warning("unhandled typecode: %s, (kind==%d)", tc->repo_id, tc->kind);
break;
}
return ret;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultAgeInfoNode, getCzarID)
{
return PyLong_FromUnsignedLong(self->fThis->GetCzarID());
}
static PyObject *get_immediate_width_bits(instruction_t *self)
{
xed_uint_t width;
width = xed_decoded_inst_get_immediate_width_bits(self->decoded_inst);
return PyLong_FromUnsignedLong(width);
}
static PyObject *py_ue_frandomstream_get_unsigned_int(ue_PyFRandomStream *self, PyObject * args) {
return PyLong_FromUnsignedLong(self->rstream.GetUnsignedInt());
}
PyObject *MemoryEntryToPython(const GSM_MemoryEntry * entry)
{
PyObject *v;
PyObject *f;
PyObject *r;
PyObject *d;
PyObject *l;
int i;
int j;
Py_UNICODE *s;
char *t;
const GSM_BinaryPicture *bitmap;
const char *bmptype;
v = PyList_New(0);
if (v == NULL)
return NULL;
for (i = 0; i < entry->EntriesNum; i++) {
f = Py_None;
switch (entry->Entries[i].EntryType) {
case PBK_Number_General:
convert_number("General");
break;
case PBK_Number_Mobile:
convert_number("Mobile");
break;
case PBK_Number_Fax:
convert_number("Fax");
break;
case PBK_Number_Pager:
convert_number("Pager");
break;
case PBK_Number_Other:
convert_number("Other");
break;
case PBK_Text_Note:
convert_text("Text_Note");
break;
case PBK_Text_Postal:
convert_text("Text_Postal");
break;
case PBK_Text_Email:
convert_text("Text_Email");
break;
case PBK_Text_Email2:
convert_text("Text_Email2");
break;
case PBK_Text_URL:
convert_text("Text_URL");
break;
case PBK_Date:
d = BuildPythonDateTime(&
(entry->Entries[i].
Date));
if (d == NULL) {
Py_DECREF(v);
return NULL;
}
f = Py_BuildValue("{s:s,s:O}", "Type", "Date",
"Value", d);
Py_DECREF(d);
break;
case PBK_LastModified:
d = BuildPythonDateTime(&
(entry->Entries[i].
Date));
if (d == NULL) {
Py_DECREF(v);
return NULL;
}
f = Py_BuildValue("{s:s,s:O}", "Type",
"LastModified", "Value", d);
Py_DECREF(d);
break;
case PBK_Caller_Group:
f = Py_BuildValue("{s:s,s:i}", "Type",
"Caller_Group", "Value",
entry->Entries[i].Number);
break;
case PBK_Text_Name:
convert_text("Text_Name");
break;
case PBK_Text_LastName:
convert_text("Text_LastName");
break;
case PBK_Text_FirstName:
convert_text("Text_FirstName");
break;
case PBK_Text_SecondName:
convert_text("Text_SecondName");
break;
case PBK_Text_NickName:
convert_text("Text_NickName");
break;
case PBK_Text_FormalName:
convert_text("Text_FormalName");
break;
case PBK_Text_NamePrefix:
convert_text("Text_NamePrefix");
break;
case PBK_Text_NameSuffix:
convert_text("Text_NameSuffix");
break;
case PBK_Text_Company:
convert_text("Text_Company");
break;
case PBK_Text_JobTitle:
convert_text("Text_JobTitle");
break;
case PBK_Category:
if (entry->Entries[i].Number == -1) {
convert_text("Category");
} else {
f = Py_BuildValue("{s:s,s:i}", "Type",
"Category", "Value",
entry->Entries[i].
Number);
}
break;
case PBK_Private:
f = Py_BuildValue("{s:s,s:i}", "Type",
"Private", "Value",
entry->Entries[i].Number);
break;
case PBK_Text_StreetAddress:
convert_text("Text_StreetAddress");
break;
case PBK_Text_City:
convert_text("Text_City");
break;
case PBK_Text_State:
convert_text("Text_State");
break;
case PBK_Text_Zip:
convert_text("Text_Zip");
break;
case PBK_Text_Country:
convert_text("Text_Country");
break;
case PBK_Text_Custom1:
convert_text("Text_Custom1");
break;
case PBK_Text_Custom2:
convert_text("Text_Custom2");
break;
case PBK_Text_Custom3:
convert_text("Text_Custom3");
break;
case PBK_Text_Custom4:
convert_text("Text_Custom4");
break;
case PBK_Text_LUID:
convert_text("Text_LUID");
break;
case PBK_Text_VOIP:
convert_text("Text_VOIP");
break;
case PBK_Text_SWIS:
convert_text("Text_SWIS");
break;
case PBK_Text_WVID:
convert_text("Text_WVID");
break;
case PBK_Text_SIP:
convert_text("Text_SIP");
break;
case PBK_Text_DTMF:
convert_text("Text_DTMF");
break;
case PBK_Text_UserID:
convert_text("Text_UserID");
break;
case PBK_Text_PictureName:
convert_text("Text_PictureName");
break;
case PBK_RingtoneID:
f = Py_BuildValue("{s:s,s:O}", "Type",
"RingtoneID", "Value",
PyLong_FromUnsignedLong
(entry->Entries[i].Number));
break;
case PBK_PictureID:
f = Py_BuildValue("{s:s,s:O}", "Type",
"PictureID", "Value",
PyLong_FromUnsignedLong
(entry->Entries[i].Number));
break;
case PBK_CallLength:
f = Py_BuildValue("{s:s,s:i}", "Type",
"CallLength", "Value",
entry->Entries[i].CallLength);
break;
case PBK_Number_Messaging:
convert_number("Messaging");
break;
case PBK_Number_Video:
convert_number("Video");
break;
case PBK_PushToTalkID:
convert_text("PushToTalkID");
break;
case PBK_Photo:
bitmap = &(entry->Entries[i].Picture);
d = PyString_FromStringAndSize((char *)bitmap->
Buffer,
bitmap->Length);
if (d == NULL) {
Py_DECREF(v);
return NULL;
}
bmptype = "";
switch (bitmap->Type) {
case PICTURE_BMP:
bmptype = "BMP";
break;
case PICTURE_GIF:
bmptype = "GIF";
break;
case PICTURE_JPG:
bmptype = "JPG";
break;
case PICTURE_ICN:
bmptype = "ICN";
break;
case PICTURE_PNG:
bmptype = "PNG";
break;
}
f = Py_BuildValue("{s:s,s:O,s:s}", "Type",
"Photo", "Value", d,
"PictureType", bmptype);
Py_DECREF(d);
break;
}
if (f == Py_None) {
Py_DECREF(v);
PyErr_Format(PyExc_ValueError,
"Bad MemoryEntry item type from gammu: %d",
entry->Entries[i].EntryType);
return NULL;
}
if (f == NULL) {
Py_DECREF(v);
return NULL;
}
if (PyList_Append(v, f) != 0) {
Py_DECREF(f);
Py_DECREF(v);
return NULL;
}
Py_DECREF(f);
}
t = MemoryTypeToString(entry->MemoryType);
if (t == NULL) {
Py_DECREF(v);
return NULL;
}
r = Py_BuildValue("{s:i,s:s,s:O}",
"Location", entry->Location,
"MemoryType", t, "Entries", v);
free(t);
Py_DECREF(v);
return r;
}
static PyObject *
shm_get_value(int shared_memory_id, enum GET_SET_IDENTIFIERS field) {
struct shmid_ds shm_info;
PyObject *py_value = NULL;
DPRINTF("Calling shmctl(...IPC_STAT...), field = %d\n", field);
if (-1 == shmctl(shared_memory_id, IPC_STAT, &shm_info)) {
switch (errno) {
case EIDRM:
case EINVAL:
PyErr_Format(pExistentialException,
"No shared memory with id %d exists",
shared_memory_id);
break;
case EACCES:
PyErr_SetString(pPermissionsException,
"You do not have permission to read the shared memory attribute");
break;
default:
PyErr_SetFromErrno(PyExc_OSError);
break;
}
goto error_return;
}
switch (field) {
case SVIFP_SHM_SIZE:
py_value = SIZE_T_TO_PY(shm_info.shm_segsz);
break;
case SVIFP_SHM_LAST_ATTACH_TIME:
py_value = TIME_T_TO_PY(shm_info.shm_atime);
break;
case SVIFP_SHM_LAST_DETACH_TIME:
py_value = TIME_T_TO_PY(shm_info.shm_dtime);
break;
case SVIFP_SHM_LAST_CHANGE_TIME:
py_value = TIME_T_TO_PY(shm_info.shm_ctime);
break;
case SVIFP_SHM_CREATOR_PID:
py_value = PID_T_TO_PY(shm_info.shm_cpid);
break;
case SVIFP_SHM_LAST_AT_DT_PID:
py_value = PID_T_TO_PY(shm_info.shm_lpid);
break;
case SVIFP_SHM_NUMBER_ATTACHED:
// shm_nattch is unsigned
// ref: http://www.opengroup.org/onlinepubs/007908799/xsh/sysshm.h.html
#if PY_MAJOR_VERSION > 2
py_value = PyLong_FromUnsignedLong(shm_info.shm_nattch);
#else
py_value = py_int_or_long_from_ulong(shm_info.shm_nattch);
#endif
break;
case SVIFP_IPC_PERM_UID:
py_value = UID_T_TO_PY(shm_info.shm_perm.uid);
break;
case SVIFP_IPC_PERM_GID:
py_value = GID_T_TO_PY(shm_info.shm_perm.gid);
break;
case SVIFP_IPC_PERM_CUID:
py_value = UID_T_TO_PY(shm_info.shm_perm.cuid);
break;
case SVIFP_IPC_PERM_CGID:
py_value = GID_T_TO_PY(shm_info.shm_perm.cgid);
break;
case SVIFP_IPC_PERM_MODE:
py_value = MODE_T_TO_PY(shm_info.shm_perm.mode);
break;
default:
PyErr_Format(pInternalException, "Bad field %d passed to shm_get_value", field);
goto error_return;
break;
}
return py_value;
error_return:
return NULL;
}
static PyObject*
PySfSound_GetStatus(PySfSound *self)
{
return PyLong_FromUnsignedLong(self->obj->GetStatus());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGameMgrInviteReceivedMsg, inviterID)
{
return PyLong_FromUnsignedLong(self->fThis->InviterID());
}
static PyObject *get_second_immediate(instruction_t *self)
{
xed_uint8_t imm;
imm = xed_decoded_inst_get_second_immediate(self->decoded_inst);
return PyLong_FromUnsignedLong(imm);
}
PYTHON_METHOD_DEFINITION_NOARGS(ptDniInfoSource, getAgeTime)
{
return PyLong_FromUnsignedLong(self->fThis->GetAgeTime());
}
PyObject* PythonQtConv::ConvertQtValueToPythonInternal(int type, const void* data) {
switch (type) {
case QMetaType::Void:
Py_INCREF(Py_None);
return Py_None;
case QMetaType::Char:
return PyLong_FromLong(*((char*)data));
case QMetaType::UChar:
return PyLong_FromLong(*((unsigned char*)data));
case QMetaType::Short:
return PyLong_FromLong(*((short*)data));
case QMetaType::UShort:
return PyLong_FromLong(*((unsigned short*)data));
case QMetaType::Long:
return PyLong_FromLong(*((long*)data));
case QMetaType::ULong:
// does not fit into simple int of python
return PyLong_FromUnsignedLong(*((unsigned long*)data));
case QMetaType::Bool:
return PythonQtConv::GetPyBool(*((bool*)data));
case QMetaType::Int:
return PyLong_FromLong(*((int*)data));
case QMetaType::UInt:
// does not fit into simple int of python
return PyLong_FromUnsignedLong(*((unsigned int*)data));
case QMetaType::QChar:
return PyLong_FromLong(*((unsigned short*)data));
case QMetaType::Float:
return PyFloat_FromDouble(*((float*)data));
case QMetaType::Double:
return PyFloat_FromDouble(*((double*)data));
case QMetaType::LongLong:
return PyLong_FromLongLong(*((qint64*)data));
case QMetaType::ULongLong:
return PyLong_FromUnsignedLongLong(*((quint64*)data));
// implicit conversion from QByteArray to str has been removed:
//case QMetaType::QByteArray: {
// QByteArray* v = (QByteArray*) data;
// return PyBytes_FromStringAndSize(*v, v->size());
// }
case QMetaType::QVariantHash:
return PythonQtConv::QVariantHashToPyObject(*((QVariantHash*)data));
case QMetaType::QVariantMap:
return PythonQtConv::QVariantMapToPyObject(*((QVariantMap*)data));
case QMetaType::QVariantList:
return PythonQtConv::QVariantListToPyObject(*((QVariantList*)data));
case QMetaType::QString:
return PythonQtConv::QStringToPyObject(*((QString*)data));
case QMetaType::QStringList:
return PythonQtConv::QStringListToPyObject(*((QStringList*)data));
case PythonQtMethodInfo::Variant:
#if QT_VERSION >= 0x040800
case QMetaType::QVariant:
#endif
return PythonQtConv::QVariantToPyObject(*((QVariant*)data));
case QMetaType::QObjectStar:
#if( QT_VERSION < QT_VERSION_CHECK(5,0,0) )
case QMetaType::QWidgetStar:
#endif
return PythonQt::priv()->wrapQObject(*((QObject**)data));
default:
if (PythonQt::priv()->isPythonQtObjectPtrMetaId(type)) {
// special case, it is a PythonQtObjectPtr which contains a PyObject, take it directly:
PyObject* o = ((PythonQtObjectPtr*)data)->object();
Py_INCREF(o);
return o;
} else {
if (type > 0) {
return createCopyFromMetaType(type, data);
} else {
std::cerr << "Unknown type that can not be converted to Python: " << type << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
}
}
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *get_number_of_memory_operands(instruction_t *self)
{
xed_uint_t num;
num = xed_decoded_inst_number_of_memory_operands(self->decoded_inst);
return PyLong_FromUnsignedLong(num);
}
PyObject* EntityApp<E>::__py_getWatcher(PyObject* self, PyObject* args)
{
int argCount = PyTuple_Size(args);
if(argCount != 1)
{
PyErr_Format(PyExc_TypeError, "KBEngine::getWatcher(): args[strpath] is error!");
PyErr_PrintEx(0);
return 0;
}
char* path;
if(PyArg_ParseTuple(args, "s", &path) == -1)
{
PyErr_Format(PyExc_TypeError, "KBEngine::getWatcher(): args[strpath] is error!");
PyErr_PrintEx(0);
return 0;
}
//DebugHelper::getSingleton().setScriptMsgType(type);
KBEShared_ptr< WatcherObject > pWobj = WatcherPaths::root().getWatcher(path);
if(pWobj.get() == NULL)
{
PyErr_Format(PyExc_TypeError, "KBEngine::getWatcher(): not found watcher[%s]!", path);
PyErr_PrintEx(0);
return 0;
}
WATCHER_VALUE_TYPE wtype = pWobj->getType();
PyObject* pyval = NULL;
MemoryStream* stream = MemoryStream::ObjPool().createObject();
pWobj->addToStream(stream);
WATCHER_ID id;
(*stream) >> id;
switch(wtype)
{
case WATCHER_VALUE_TYPE_UINT8:
{
uint8 v;
(*stream) >> v;
pyval = PyLong_FromUnsignedLong(v);
}
break;
case WATCHER_VALUE_TYPE_UINT16:
{
uint16 v;
(*stream) >> v;
pyval = PyLong_FromUnsignedLong(v);
}
break;
case WATCHER_VALUE_TYPE_UINT32:
{
uint32 v;
(*stream) >> v;
pyval = PyLong_FromUnsignedLong(v);
}
break;
case WATCHER_VALUE_TYPE_UINT64:
{
uint64 v;
(*stream) >> v;
pyval = PyLong_FromUnsignedLongLong(v);
}
break;
case WATCHER_VALUE_TYPE_INT8:
{
int8 v;
(*stream) >> v;
pyval = PyLong_FromLong(v);
}
break;
case WATCHER_VALUE_TYPE_INT16:
{
int16 v;
(*stream) >> v;
pyval = PyLong_FromLong(v);
}
break;
case WATCHER_VALUE_TYPE_INT32:
{
int32 v;
(*stream) >> v;
pyval = PyLong_FromLong(v);
}
break;
case WATCHER_VALUE_TYPE_INT64:
{
int64 v;
(*stream) >> v;
pyval = PyLong_FromLongLong(v);
}
break;
case WATCHER_VALUE_TYPE_FLOAT:
{
float v;
(*stream) >> v;
pyval = PyLong_FromDouble(v);
}
break;
case WATCHER_VALUE_TYPE_DOUBLE:
{
double v;
(*stream) >> v;
pyval = PyLong_FromDouble(v);
}
break;
case WATCHER_VALUE_TYPE_CHAR:
case WATCHER_VALUE_TYPE_STRING:
{
std::string v;
(*stream) >> v;
pyval = PyUnicode_FromString(v.c_str());
}
break;
case WATCHER_VALUE_TYPE_BOOL:
{
bool v;
(*stream) >> v;
pyval = PyBool_FromLong(v);
}
break;
case WATCHER_VALUE_TYPE_COMPONENT_TYPE:
{
COMPONENT_TYPE v;
(*stream) >> v;
pyval = PyBool_FromLong(v);
}
break;
default:
KBE_ASSERT(false && "no support!\n");
};
MemoryStream::ObjPool().reclaimObject(stream);
return pyval;
}
static PyObject *PyBan_time_get(PyBan *self, void *closure)
{
BAN_REC *data = self->data;
RET_NULL_IF_INVALID(self->data);
return PyLong_FromUnsignedLong(data->time);
}
PyObject *
PyMember_GetOne(const char *addr, PyMemberDef *l)
{
PyObject *v;
addr += l->offset;
switch (l->type) {
case T_BOOL:
v = PyBool_FromLong(*(char*)addr);
break;
case T_BYTE:
v = PyLong_FromLong(*(char*)addr);
break;
case T_UBYTE:
v = PyLong_FromUnsignedLong(*(unsigned char*)addr);
break;
case T_SHORT:
v = PyLong_FromLong(*(short*)addr);
break;
case T_USHORT:
v = PyLong_FromUnsignedLong(*(unsigned short*)addr);
break;
case T_INT:
v = PyLong_FromLong(*(int*)addr);
break;
case T_UINT:
v = PyLong_FromUnsignedLong(*(unsigned int*)addr);
break;
case T_LONG:
v = PyLong_FromLong(*(long*)addr);
break;
case T_ULONG:
v = PyLong_FromUnsignedLong(*(unsigned long*)addr);
break;
case T_PYSSIZET:
v = PyLong_FromSsize_t(*(Py_ssize_t*)addr);
break;
case T_FLOAT:
v = PyFloat_FromDouble((double)*(float*)addr);
break;
case T_DOUBLE:
v = PyFloat_FromDouble(*(double*)addr);
break;
case T_STRING:
if (*(char**)addr == NULL) {
Py_INCREF(Py_None);
v = Py_None;
}
else
v = PyUnicode_FromString(*(char**)addr);
break;
case T_STRING_INPLACE:
v = PyUnicode_FromString((char*)addr);
break;
case T_CHAR:
v = PyUnicode_FromStringAndSize((char*)addr, 1);
break;
case T_OBJECT:
v = *(PyObject **)addr;
if (v == NULL)
v = Py_None;
Py_INCREF(v);
break;
case T_OBJECT_EX:
v = *(PyObject **)addr;
if (v == NULL)
PyErr_SetString(PyExc_AttributeError, l->name);
Py_XINCREF(v);
break;
#ifdef HAVE_LONG_LONG
case T_LONGLONG:
v = PyLong_FromLongLong(*(PY_LONG_LONG *)addr);
break;
case T_ULONGLONG:
v = PyLong_FromUnsignedLongLong(*(unsigned PY_LONG_LONG *)addr);
break;
#endif /* HAVE_LONG_LONG */
case T_NONE:
v = Py_None;
Py_INCREF(v);
break;
default:
PyErr_SetString(PyExc_SystemError, "bad memberdescr type");
v = NULL;
}
return v;
}
SWIGRUNTIME PyObject *
PySwigObject_long(PySwigObject *v)
{
return PyLong_FromUnsignedLong((unsigned long) v->ptr);
}
static PyObject *
wadobject_getattr(wadobject *self, char *name) {
if (strcmp(name,"__NAME__") == 0) {
return Py_BuildValue("z", self->frame->sym_name);
} else if (strcmp(name,"__EXE__") == 0) {
return Py_BuildValue("z", self->frame->object->path);
} else if (strcmp(name,"__FILE__") == 0) {
return Py_BuildValue("z", self->frame->loc_srcfile);
} else if (strcmp(name,"__OBJECT__") == 0) {
return Py_BuildValue("z", self->frame->loc_objfile);
} else if (strcmp(name,"__LINE__") == 0) {
return Py_BuildValue("i", self->frame->loc_line);
} else if (strcmp(name,"__SOURCE__") == 0) {
return Py_BuildValue("z",self->frame->debug_srcstr);
} else if (strcmp(name,"__PC__") == 0) {
return PyLong_FromUnsignedLong(self->frame->pc);
} else if (strcmp(name,"__SP__") == 0) {
return PyLong_FromUnsignedLong(self->frame->sp);
} else if (strcmp(name,"__FP__") == 0) {
return PyLong_FromUnsignedLong(self->frame->fp);
} else if (strcmp(name,"__STACK__") == 0) {
return PyString_FromStringAndSize(self->frame->stack, self->frame->stack_size);
} else if (strcmp(name,"__NARGS__") == 0) {
return PyInt_FromLong(self->frame->debug_nargs);
} else if (strcmp(name,"__LAST__") == 0) {
return PyInt_FromLong(self->frame->last);
} else if (strcmp(name,"__WHERE__") == 0) {
return Py_BuildValue("z",self->frame->debug_str);
} else if (strcmp(name,"__WAD__") == 0) {
return PyInt_FromLong(1);
}
/* Put a check for local variables */
{
int i;
for (i = 0; i < 2; i++) {
WadLocal *loc;
if (i == 0) loc = self->frame->debug_locals;
else loc = self->frame->debug_args;
while (loc) {
if (strcmp(name,loc->name) == 0) {
switch(loc->type) {
case WAD_TYPE_INT32:
case WAD_TYPE_INT16:
case WAD_TYPE_INT8:
return PyLong_FromLong(wad_local_as_long(loc));
break;
case WAD_TYPE_UINT8:
case WAD_TYPE_UINT16:
case WAD_TYPE_UINT32:
return PyLong_FromUnsignedLong((unsigned long) wad_local_as_long(loc));
break;
case WAD_TYPE_CHAR:
return Py_BuildValue("c", (char) (PyLong_FromLong(wad_local_as_long(loc))));
break;
case WAD_TYPE_FLOAT:
case WAD_TYPE_DOUBLE:
return PyFloat_FromDouble(wad_local_as_double(loc));
break;
default:
return PyLong_FromUnsignedLong((unsigned long) wad_local_as_long(loc));
}
}
loc = loc->next;
}
}
}
PyErr_SetString(PyExc_NameError,"Unknown attribute.");
return NULL;
}
PyObject *PyObject_FromPROPVARIANT( PROPVARIANT *pVar )
{
switch (pVar->vt) {
case VT_EMPTY:
case VT_NULL:
case VT_ILLEGAL:
Py_INCREF(Py_None);
return Py_None;
case VT_I1:
return PyInt_FromLong(pVar->cVal);
case VT_I1|VT_VECTOR:
return VectorToSeq(pVar->cac.pElems, pVar->cac.cElems, PyWinObject_FromCHAR);
case VT_UI1:
return PyInt_FromLong(pVar->bVal);
case VT_UI1|VT_VECTOR:
return VectorToSeq(pVar->caub.pElems, pVar->caub.cElems, PyWinObject_FromUCHAR);
case VT_I2:
return PyInt_FromLong(pVar->iVal);
case VT_I2|VT_VECTOR:
return VectorToSeq(pVar->cai.pElems, pVar->cai.cElems, PyWinObject_FromSHORT);
case VT_UI2:
return PyInt_FromLong(pVar->uiVal);
case VT_UI2|VT_VECTOR:
return VectorToSeq(pVar->caui.pElems, pVar->caui.cElems, PyWinObject_FromUSHORT);
case VT_I4:
return PyInt_FromLong(pVar->lVal);
case VT_I4|VT_VECTOR:
return VectorToSeq(pVar->cal.pElems, pVar->cal.cElems, PyInt_FromLong);
case VT_INT:
return PyInt_FromLong(pVar->intVal);
case VT_UI4:
return PyLong_FromUnsignedLong(pVar->ulVal);
case VT_UI4|VT_VECTOR:
return VectorToSeq(pVar->caul.pElems, pVar->caul.cElems, PyLong_FromUnsignedLong);
case VT_UINT:
return PyLong_FromUnsignedLong(pVar->uintVal);
case VT_I8:
return PyWinObject_FromLARGE_INTEGER(pVar->hVal);
case VT_I8|VT_VECTOR:
return VectorToSeq<LARGE_INTEGER>(pVar->cah.pElems, pVar->cah.cElems, PyWinObject_FromLARGE_INTEGER);
case VT_UI8:
return PyWinObject_FromULARGE_INTEGER(pVar->uhVal);
case VT_UI8|VT_VECTOR:
return VectorToSeq<ULARGE_INTEGER>(pVar->cauh.pElems, pVar->cauh.cElems, PyWinObject_FromULARGE_INTEGER);
case VT_R4:
return PyFloat_FromDouble(pVar->fltVal);
case VT_R4|VT_VECTOR:
return VectorToSeq(pVar->caflt.pElems, pVar->caflt.cElems, PyWinObject_FromFLOAT);
case VT_R8:
return PyFloat_FromDouble(pVar->dblVal);
case VT_R8|VT_VECTOR:
return VectorToSeq(pVar->cadbl.pElems, pVar->cadbl.cElems, PyFloat_FromDouble);
case VT_CY:
return PyObject_FromCurrency(pVar->cyVal);
case VT_CY|VT_VECTOR:
return VectorToSeq<CY>(pVar->cacy.pElems, pVar->cacy.cElems, PyObject_FromCurrency);
case VT_DATE:
return PyWinObject_FromDATE(pVar->date);
case VT_DATE|VT_VECTOR:
return VectorToSeq(pVar->cadate.pElems, pVar->cadate.cElems, PyWinObject_FromDATE);
case VT_BSTR:
return PyWinObject_FromBstr(pVar->bstrVal);
case VT_BSTR|VT_VECTOR:
return VectorToSeq(pVar->cabstr.pElems, pVar->cabstr.cElems, PyWinObject_FromVT_BSTR);
case VT_BOOL:
return PyWinObject_FromVARIANT_BOOL(pVar->boolVal);
case VT_BOOL|VT_VECTOR:
return VectorToSeq(pVar->cabool.pElems, pVar->cabool.cElems, PyWinObject_FromVARIANT_BOOL);
case VT_ERROR:
return PyInt_FromLong(pVar->scode);
case VT_ERROR|VT_VECTOR:
return VectorToSeq(pVar->cascode.pElems, pVar->cascode.cElems, PyInt_FromLong);
case VT_FILETIME:
return PyWinObject_FromFILETIME(pVar->filetime);
case VT_FILETIME|VT_VECTOR:
return VectorToSeq<FILETIME>(pVar->cafiletime.pElems, pVar->cafiletime.cElems, PyWinObject_FromFILETIME);
case VT_LPSTR:
if (pVar->pszVal == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
return PyWinCoreString_FromString(pVar->pszVal);
case VT_LPSTR|VT_VECTOR:
{
PyObject *ret = PyList_New(pVar->calpstr.cElems);
if (ret==NULL) return NULL;
for (ULONG i=0; i<pVar->calpstr.cElems;i++){
PyObject *elem=PyWinCoreString_FromString(pVar->calpstr.pElems[i]);
if (elem==NULL){
Py_DECREF(ret);
return NULL;
}
PyList_SET_ITEM(ret, i, elem);
}
return ret;
}
case VT_LPWSTR:
return PyWinObject_FromOLECHAR(pVar->pwszVal);
case VT_LPWSTR|VT_VECTOR:
{
PyObject *ret = PyList_New(pVar->calpwstr.cElems);
if (ret==NULL) return NULL;
for (ULONG i=0; i<pVar->calpwstr.cElems;i++){
PyObject *elem=PyWinObject_FromWCHAR(pVar->calpwstr.pElems[i]);
if (elem==NULL){
Py_DECREF(ret);
return NULL;
}
PyList_SET_ITEM(ret, i, elem);
}
return ret;
}
case VT_CLSID:
return PyWinObject_FromIID(*pVar->puuid);
case VT_CLSID|VT_VECTOR:
return VectorToSeq<CLSID>(pVar->cauuid.pElems, pVar->cauuid.cElems, PyWinObject_FromIID);
case VT_STREAM:
case VT_STREAMED_OBJECT:
return PyCom_PyObjectFromIUnknown(pVar->pStream, IID_IStream, TRUE);
case VT_STORAGE:
case VT_STORED_OBJECT:
return PyCom_PyObjectFromIUnknown(pVar->pStorage, IID_IStorage, TRUE);
case VT_VECTOR | VT_VARIANT:
return PyObject_FromPROPVARIANTs(pVar->capropvar.pElems, pVar->capropvar.cElems);
case VT_BLOB:
case VT_BLOB_OBJECT:
return PyString_FromStringAndSize((const char *)pVar->blob.pBlobData,
pVar->blob.cbSize);
// case VT_UNKNOWN:
// return PyCom_PyObjectFromIUnknown(pVar->punkVal, IID_IUnknown, TRUE);
// case VT_DISPATCH:
// return PyCom_PyObjectFromIUnknown(pVar->pdispVal, IID_IDispatch, TRUE);
/*
// Want to get VT_CF and VT_BLOB working with a test case first!
case VT_CF: { // special "clipboard format"
// cbSize is the size of the buffer pointed to
// by pClipData, plus sizeof(ulClipFmt)
// XXX - in that case, shouldn't we pass
// pClipData + sizeof(DWORD) to Py_BuildValue??
ULONG cb = CBPCLIPDATA(*pVar->pclipdata);
return Py_BuildValue("is#",
pVar->pclipdata->ulClipFmt,
pVar->pclipdata->pClipData,
(int)cb);
}
*/
default:
PyErr_Format(PyExc_TypeError, "Unsupported property type 0x%x", pVar->vt);
return NULL;
}
}
//-------------------------------------------------------------------------------------
PyObject* Cellapp::__py_gametime(PyObject* self, PyObject* args)
{
return PyLong_FromUnsignedLong(Cellapp::getSingleton().time());
}
static PyObject *SlawToPython (bslaw s)
{
PyObject *ret = NULL;
if (s == NULL) {
ret = Py_None;
} else if (slaw_is_map (s)) {
int64 count = slaw_map_count (s);
int64 i = 0;
ret = PyDict_New ();
for (i = 0; i < count; i++) {
bslaw x = slaw_list_emit_nth (s, i);
assert (slaw_is_cons (x));
PyObject *k = SlawToPython (slaw_cons_emit_car (x));
PyObject *v = SlawToPython (slaw_cons_emit_cdr (x));
PyDict_SetItem (ret, k, v);
}
} else if (slaw_is_protein (s)) {
ret = PyList_New (2);
assert (slaw_is_nil (slaw_cons_emit_car (s)));
PyList_SET_ITEM (ret, 0, SlawToPython (protein_descrips (s)));
PyList_SET_ITEM (ret, 1, SlawToPython (protein_ingests (s)));
} else if (slaw_is_list (s)) {
int64 count = slaw_list_count (s);
int64 i = 0;
assert (count < 1024);
ret = PyList_New ((int) count);
for (i = 0; i < count; i++) {
PyList_SET_ITEM (ret, i, SlawToPython (slaw_list_emit_nth (s, i)));
}
} else if (slaw_is_cons (s)) {
ret = PyTuple_New (2);
PyTuple_SET_ITEM (ret, 0, SlawToPython (slaw_cons_emit_car (s)));
PyTuple_SET_ITEM (ret, 1, SlawToPython (slaw_cons_emit_cdr (s)));
} else if (slaw_is_string (s)) {
ret = PyString_FromString (slaw_string_emit (s));
} else if (slaw_is_numeric (s)) {
if (slaw_is_int32 (s)) {
int32 v = *(slaw_int32_emit (s));
ret = PyLong_FromLong (v);
} else if (slaw_is_unt32 (s)) {
unt32 v = *(slaw_unt32_emit (s));
ret = PyLong_FromUnsignedLong (v);
} else if (slaw_is_int16 (s)) {
int16 v = *(slaw_int16_emit (s));
ret = PyLong_FromLong (v);
} else if (slaw_is_unt16 (s)) {
unt16 v = *(slaw_unt16_emit (s));
ret = PyLong_FromUnsignedLong (v);
} else if (slaw_is_float32 (s)) {
float32 v = *(slaw_float32_emit (s));
ret = PyFloat_FromDouble (v);
} else if (slaw_is_float64 (s)) {
float64 v = *(slaw_float64_emit (s));
ret = PyFloat_FromDouble (v);
} else {
UNKNOWN_TYPE (s);
}
} else if (slaw_is_boolean (s)) {
ret = PyBool_FromLong (* (slaw_boolean_emit (s)));
} else if (slaw_is_nil (s)) {
ret = Py_None;
Py_INCREF (ret);
} else {
/* This should raise a SystemError instead of spamming the console
and aborting. This is nontrivial though as we'd then have to
check for errors in all the returns from SlawToPython, which in
turn would make refcounting challenging. Maybe easier to
switch to something like cython? */
/* https://redmine.hadronindustries.com/redmine/issues/153 */
UNKNOWN_TYPE (s);
}
return ret;
}
/*
* Callback function which is exposed as a part of the additional methods which allow
* a Python plugin to get certain internal values of the current Job.
*/
static PyObject *PyBareosGetValue(PyObject *self, PyObject *args)
{
int var;
bpContext *ctx = NULL;
PyObject *pyCtx;
PyObject *pRetVal = NULL;
if (!PyArg_ParseTuple(args, "Oi:BareosGetValue", &pyCtx, &var)) {
return NULL;
}
switch (var) {
case bDirVarJobId:
case bDirVarLevel:
case bDirVarType:
case bDirVarNumVols:
case bDirVarJobStatus:
case bDirVarPriority:
case bDirVarFDJobStatus:
case bDirVarSDJobStatus: {
int value = 0;
ctx = PyGetbpContext(pyCtx);
if (bfuncs->getBareosValue(ctx, (brDirVariable)var, &value) == bRC_OK) {
pRetVal = PyInt_FromLong(value);
}
break;
}
case bDirVarJobErrors:
case bDirVarSDErrors:
case bDirVarJobFiles:
case bDirVarSDJobFiles:
case bDirVarLastRate:
case bDirVarJobBytes:
case bDirVarReadBytes: {
uint64_t value = 0;
ctx = PyGetbpContext(pyCtx);
if (bfuncs->getBareosValue(ctx, (brDirVariable)var, &value) == bRC_OK) {
pRetVal = PyLong_FromUnsignedLong(value);
}
break;
}
case bDirVarJobName:
case bDirVarJob:
case bDirVarClient:
case bDirVarPool:
case bDirVarStorage:
case bDirVarWriteStorage:
case bDirVarReadStorage:
case bDirVarCatalog:
case bDirVarMediaType:
case bDirVarVolumeName: {
char *value;
ctx = PyGetbpContext(pyCtx);
if (bfuncs->getBareosValue(ctx, (brDirVariable)var, &value) == bRC_OK) {
pRetVal = PyString_FromString(value);
}
break;
}
case bDirVarPluginDir: {
char *value;
if (bfuncs->getBareosValue(NULL, (brDirVariable)var, &value) == bRC_OK) {
pRetVal = PyString_FromString(value);
}
break;
}
default:
ctx = PyGetbpContext(pyCtx);
Dmsg(ctx, dbglvl, "PyBareosGetValue: Unknown variable requested %d\n", var);
break;
}
if (!pRetVal) {
Py_INCREF(Py_None);
pRetVal = Py_None;
}
return pRetVal;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptImage, getHeight)
{
return PyLong_FromUnsignedLong(self->fThis->GetHeight());
}
