static PyObject *
VmMngr_get_vmmngr(VmMngr *self, void *closure)
{
return PyLong_FromUnsignedLongLong((uint64_t)(intptr_t)&(self->vm_mngr));
}
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;
}
PyObject* cpu_get_interrupt_num(JitCpu* self, PyObject* args)
{
return PyLong_FromUnsignedLongLong((uint64_t)(((vm_cpu_t*)self->cpu)->interrupt_num));
}
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;
}
void PythonFlowAnalyzer::onDataRecord(IpfixDataRecord* record)
{
// only treat non-Options Data Records (although we cannot be sure that there is a Flow inside)
if((record->templateInfo->setId != TemplateInfo::NetflowTemplate)
&& (record->templateInfo->setId != TemplateInfo::IpfixTemplate)
&& (record->templateInfo->setId != TemplateInfo::IpfixDataTemplate)) {
record->removeReference();
return;
}
Connection conn(record);
enum TimeIdentifier { NONE = 1, SEC = 1, mSEC = 2, nSEC = 3 };
TimeIdentifier flowstart = NONE;
TimeIdentifier flowend = NONE;
TimeIdentifier revflowstart = NONE;
TimeIdentifier revflowend = NONE;
PyObject* pydict = PyDict_New();
for (uint32_t i = 0; i < record->templateInfo->fieldCount; i++) {
TemplateInfo::FieldInfo* fi = &record->templateInfo->fieldInfo[i];
if (fi->type.enterprise==0) {
uint64_t time;
switch (fi->type.id) {
// TODO: call Py_DECREF for each passed value to PyDict_SetItemString
case IPFIX_TYPEID_sourceIPv4Address:
PyDict_SetItemString(pydict, "sourceIPv4Address",
PyLong_FromLong(ntohl(*(uint32_t*)(record->data + fi->offset))));
break;
case IPFIX_TYPEID_destinationIPv4Address:
PyDict_SetItemString(pydict, "destinationIPv4Address",
PyLong_FromLong(ntohl(*(uint32_t*)(record->data + fi->offset))));
break;
case IPFIX_TYPEID_sourceTransportPort:
PyDict_SetItemString(pydict, "sourceTransportPort",
PyLong_FromLong(ntohs(*(uint16_t*)(record->data + fi->offset))));
break;
case IPFIX_TYPEID_destinationTransportPort:
PyDict_SetItemString(pydict, "destinationTransportPort",
PyLong_FromLong(ntohs(*(uint16_t*)(record->data + fi->offset))));
break;
case IPFIX_TYPEID_protocolIdentifier:
PyDict_SetItemString(pydict, "protocolIdentifier",
PyLong_FromLong(*(uint8_t*)(record->data + fi->offset)));
break;
case IPFIX_TYPEID_flowStartNanoSeconds:
flowstart = nSEC;
convertNtp64(*(uint64_t*)(record->data + fi->offset), time);
PyDict_SetItemString(pydict, "flowStartMilliSeconds", PyLong_FromUnsignedLongLong(time));
break;
case IPFIX_TYPEID_flowStartMilliSeconds:
if (flowstart>=mSEC) break;
flowstart = mSEC;
PyDict_SetItemString(pydict, "flowStartMilliSeconds",
PyLong_FromUnsignedLongLong(ntohll(*(uint64_t*)(record->data + fi->offset))));
break;
case IPFIX_TYPEID_flowStartSeconds:
if (flowstart>=SEC) break;
flowstart = SEC;
PyDict_SetItemString(pydict, "flowStartMilliSeconds",
PyLong_FromLong(ntohl(*(uint32_t*)(record->data + fi->offset))));
break;
case IPFIX_TYPEID_flowEndNanoSeconds:
flowend = nSEC;
convertNtp64(*(uint64_t*)(record->data + fi->offset), time);
PyDict_SetItemString(pydict, "flowEndMilliSeconds", PyLong_FromUnsignedLongLong(time));
break;
case IPFIX_TYPEID_flowEndMilliSeconds:
if (flowend>=mSEC) break;
flowend = mSEC;
PyDict_SetItemString(pydict, "flowEndMilliSeconds",
PyLong_FromUnsignedLongLong(ntohll(*(uint64_t*)(record->data + fi->offset))));
break;
case IPFIX_TYPEID_flowEndSeconds:
if (flowend>=SEC) break;
flowend = SEC;
PyDict_SetItemString(pydict, "flowEndMilliSeconds",
PyLong_FromLong(ntohl(*(uint32_t*)(record->data + fi->offset))));
break;
}
} else if (fi->type.enterprise==IPFIX_PEN_reverse) {
uint64_t time;
switch (fi->type.id) {
case IPFIX_TYPEID_flowStartNanoSeconds:
revflowstart = nSEC;
convertNtp64(*(uint64_t*)(record->data + fi->offset), time);
PyDict_SetItemString(pydict, "revFlowStartMilliSeconds", PyLong_FromUnsignedLongLong(time));
break;
case IPFIX_TYPEID_flowStartMilliSeconds:
if (revflowstart>=mSEC) break;
revflowstart = mSEC;
PyDict_SetItemString(pydict, "revFlowStartMilliSeconds",
PyLong_FromUnsignedLongLong(ntohll(*(uint64_t*)(record->data + fi->offset))));
break;
case IPFIX_TYPEID_flowStartSeconds:
if (revflowstart>=SEC) break;
revflowstart = SEC;
PyDict_SetItemString(pydict, "revFlowStartMilliSeconds",
PyLong_FromLong(ntohl(*(uint32_t*)(record->data + fi->offset))));
break;
case IPFIX_TYPEID_flowEndNanoSeconds:
revflowend = nSEC;
convertNtp64(*(uint64_t*)(record->data + fi->offset), time);
PyDict_SetItemString(pydict, "revFlowEndMilliSeconds", PyLong_FromUnsignedLongLong(time));
break;
case IPFIX_TYPEID_flowEndMilliSeconds:
if (revflowend>=mSEC) break;
revflowend = mSEC;
PyDict_SetItemString(pydict, "revFlowEndMilliSeconds",
PyLong_FromUnsignedLongLong(ntohll(*(uint64_t*)(record->data + fi->offset))));
break;
case IPFIX_TYPEID_flowEndSeconds:
if (revflowend>=SEC) break;
revflowend = SEC;
PyDict_SetItemString(pydict, "revFlowEndMilliSeconds",
PyLong_FromLong(ntohl(*(uint32_t*)(record->data + fi->offset))));
break;
}
}
}
/*char buf[100];
snprintf(buf, ARRAY_SIZE(buf), "FlowRecord(%u, %u, %u, %u)\n", ntohl(conn.srcIP), ntohl(conn.dstIP), ntohs(conn.srcPort), ntohs(conn.dstPort));
PyObject* fr = PyRun_String(buf, Py_eval_input, pyDict, pyDict);
if (!fr) {
PyErr_Print();
THROWEXCEPTION("PythonFlowAnalyzer: failed to execute given Python code, function 'onDataRecord' not found");
}*/
PyObject* t = PyTuple_New(1);
PyTuple_SetItem(t, 0, pydict);
PyObject* instance = PyObject_CallObject(pyClass, t);
if (!instance) {
PyErr_Print();
THROWEXCEPTION("PythonFlowAnalyzer: failed to instantiate class 'FlowRecord'");
}
Py_DECREF(t);
t = PyTuple_New(1);
PyTuple_SetItem(t, 0, instance);
PyObject* r = PyObject_CallObject(pyFunc, t);
if (!r) {
PyErr_Print();
THROWEXCEPTION("PythonFlowAnalyzer: failed to execute function 'onDataRecord'");
}
Py_DECREF(t);
Py_DECREF(r);
record->removeReference();
}
static PyObject* wsql_result_get_num_rows(wsql_result *self, void* closure)
{
CHECK_RESULT(self, NULL);
return PyLong_FromUnsignedLongLong(mysql_num_rows(self->result));
}
static void python_process_tracepoint(struct perf_sample *sample,
struct perf_evsel *evsel,
struct thread *thread,
struct addr_location *al)
{
PyObject *handler, *retval, *context, *t, *obj, *dict = NULL;
static char handler_name[256];
struct format_field *field;
unsigned long long val;
unsigned long s, ns;
struct event_format *event;
unsigned n = 0;
int pid;
int cpu = sample->cpu;
void *data = sample->raw_data;
unsigned long long nsecs = sample->time;
const char *comm = thread__comm_str(thread);
t = PyTuple_New(MAX_FIELDS);
if (!t)
Py_FatalError("couldn't create Python tuple");
event = find_cache_event(evsel);
if (!event)
die("ug! no event found for type %d", (int)evsel->attr.config);
pid = raw_field_value(event, "common_pid", data);
sprintf(handler_name, "%s__%s", event->system, event->name);
handler = PyDict_GetItemString(main_dict, handler_name);
if (handler && !PyCallable_Check(handler))
handler = NULL;
if (!handler) {
dict = PyDict_New();
if (!dict)
Py_FatalError("couldn't create Python dict");
}
s = nsecs / NSECS_PER_SEC;
ns = nsecs - s * NSECS_PER_SEC;
scripting_context->event_data = data;
scripting_context->pevent = evsel->tp_format->pevent;
context = PyCObject_FromVoidPtr(scripting_context, NULL);
PyTuple_SetItem(t, n++, PyString_FromString(handler_name));
PyTuple_SetItem(t, n++, context);
if (handler) {
PyTuple_SetItem(t, n++, PyInt_FromLong(cpu));
PyTuple_SetItem(t, n++, PyInt_FromLong(s));
PyTuple_SetItem(t, n++, PyInt_FromLong(ns));
PyTuple_SetItem(t, n++, PyInt_FromLong(pid));
PyTuple_SetItem(t, n++, PyString_FromString(comm));
} else {
pydict_set_item_string_decref(dict, "common_cpu", PyInt_FromLong(cpu));
pydict_set_item_string_decref(dict, "common_s", PyInt_FromLong(s));
pydict_set_item_string_decref(dict, "common_ns", PyInt_FromLong(ns));
pydict_set_item_string_decref(dict, "common_pid", PyInt_FromLong(pid));
pydict_set_item_string_decref(dict, "common_comm", PyString_FromString(comm));
}
for (field = event->format.fields; field; field = field->next) {
if (field->flags & FIELD_IS_STRING) {
int offset;
if (field->flags & FIELD_IS_DYNAMIC) {
offset = *(int *)(data + field->offset);
offset &= 0xffff;
} else
offset = field->offset;
obj = PyString_FromString((char *)data + offset);
} else { /* FIELD_IS_NUMERIC */
val = read_size(event, data + field->offset,
field->size);
if (field->flags & FIELD_IS_SIGNED) {
if ((long long)val >= LONG_MIN &&
(long long)val <= LONG_MAX)
obj = PyInt_FromLong(val);
else
obj = PyLong_FromLongLong(val);
} else {
if (val <= LONG_MAX)
obj = PyInt_FromLong(val);
else
obj = PyLong_FromUnsignedLongLong(val);
}
}
if (handler)
PyTuple_SetItem(t, n++, obj);
else
pydict_set_item_string_decref(dict, field->name, obj);
}
if (!handler)
PyTuple_SetItem(t, n++, dict);
if (_PyTuple_Resize(&t, n) == -1)
Py_FatalError("error resizing Python tuple");
if (handler) {
retval = PyObject_CallObject(handler, t);
if (retval == NULL)
handler_call_die(handler_name);
} else {
handler = PyDict_GetItemString(main_dict, "trace_unhandled");
if (handler && PyCallable_Check(handler)) {
retval = PyObject_CallObject(handler, t);
if (retval == NULL)
handler_call_die("trace_unhandled");
}
Py_DECREF(dict);
}
Py_DECREF(t);
}
static int
Snmp_handle(int operation, netsnmp_session *session, int reqid,
netsnmp_pdu *response, void *magic)
{
PyObject *key, *defer, *results = NULL, *resultvalue = NULL,
*resultoid = NULL, *tmp;
struct ErrorException *e;
struct variable_list *vars;
int i;
long long counter64;
SnmpObject *self;
if ((key = PyInt_FromLong(reqid)) == NULL)
/* Unknown session, don't know what to do... */
return 1;
self = (SnmpObject *)magic;
if ((defer = PyDict_GetItem(self->defers, key)) == NULL)
return 1;
Py_INCREF(defer);
PyDict_DelItem(self->defers, key);
Py_DECREF(key);
/* We have our deferred object. We will be able to trigger callbacks and
* errbacks */
if (operation == NETSNMP_CALLBACK_OP_RECEIVED_MESSAGE) {
if (response->errstat != SNMP_ERR_NOERROR) {
for (e = SnmpErrorToException; e->name; e++) {
if (e->error == response->errstat) {
PyErr_SetString(e->exception, snmp_errstring(e->error));
goto fireexception;
}
}
PyErr_Format(SnmpException, "unknown error %ld", response->errstat);
goto fireexception;
}
} else {
PyErr_SetString(SnmpException, "Timeout");
goto fireexception;
}
if ((results = PyDict_New()) == NULL)
goto fireexception;
for (vars = response->variables; vars;
vars = vars->next_variable) {
/* Let's handle the value */
switch (vars->type) {
case SNMP_NOSUCHOBJECT:
PyErr_SetString(SnmpNoSuchObject, "No such object was found");
goto fireexception;
case SNMP_NOSUCHINSTANCE:
PyErr_SetString(SnmpNoSuchInstance, "No such instance exists");
goto fireexception;
case SNMP_ENDOFMIBVIEW:
if (PyDict_Size(results) == 0) {
PyErr_SetString(SnmpEndOfMibView,
"End of MIB was reached");
goto fireexception;
} else
continue;
case ASN_INTEGER:
resultvalue = PyLong_FromLong(*vars->val.integer);
break;
case ASN_UINTEGER:
case ASN_TIMETICKS:
case ASN_GAUGE:
case ASN_COUNTER:
resultvalue = PyLong_FromUnsignedLong(
(unsigned long)*vars->val.integer);
break;
case ASN_OCTET_STR:
resultvalue = PyString_FromStringAndSize(
(char*)vars->val.string, vars->val_len);
break;
case ASN_BIT_STR:
resultvalue = PyString_FromStringAndSize(
(char*)vars->val.bitstring, vars->val_len);
break;
case ASN_OBJECT_ID:
if ((resultvalue = PyTuple_New(
vars->val_len/sizeof(oid))) == NULL)
goto fireexception;
for (i = 0; i < vars->val_len/sizeof(oid); i++) {
if ((tmp = PyLong_FromLong(
vars->val.objid[i])) == NULL)
goto fireexception;
PyTuple_SetItem(resultvalue, i, tmp);
}
if ((resultvalue = Snmp_oid2string(resultvalue)) == NULL)
goto fireexception;
break;
case ASN_IPADDRESS:
if (vars->val_len < 4) {
PyErr_Format(SnmpException, "IP address is too short (%zd < 4)",
vars->val_len);
goto fireexception;
}
resultvalue = PyString_FromFormat("%d.%d.%d.%d",
vars->val.string[0],
vars->val.string[1],
vars->val.string[2],
vars->val.string[3]);
break;
case ASN_COUNTER64:
#ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
case ASN_OPAQUE_U64:
case ASN_OPAQUE_I64:
case ASN_OPAQUE_COUNTER64:
#endif /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
counter64 = ((unsigned long long)(vars->val.counter64->high) << 32) +
(unsigned long long)(vars->val.counter64->low);
resultvalue = PyLong_FromUnsignedLongLong(counter64);
break;
#ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
case ASN_OPAQUE_FLOAT:
resultvalue = PyFloat_FromDouble(*vars->val.floatVal);
break;
case ASN_OPAQUE_DOUBLE:
resultvalue = PyFloat_FromDouble(*vars->val.doubleVal);
break;
#endif /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
default:
PyErr_Format(SnmpException, "unknown type returned (%d)",
vars->type);
goto fireexception;
}
if (resultvalue == NULL) goto fireexception;
/* And now, the OID */
if ((resultoid = PyTuple_New(vars->name_length)) == NULL)
goto fireexception;
for (i = 0; i < vars->name_length; i++) {
if ((tmp = PyLong_FromLong(vars->name[i])) == NULL)
goto fireexception;
PyTuple_SetItem(resultoid, i, tmp);
}
if ((resultoid = Snmp_oid2string(resultoid)) == NULL)
goto fireexception;
/* Put into dictionary */
PyDict_SetItem(results, resultoid, resultvalue);
Py_CLEAR(resultoid);
Py_CLEAR(resultvalue);
}
if ((tmp = PyObject_GetAttrString(defer, "callback")) == NULL)
goto fireexception;
Py_DECREF(PyObject_CallMethod(reactor, "callLater", "iOO", 0, tmp, results));
Py_DECREF(tmp);
Py_DECREF(results);
Py_DECREF(defer);
Py_DECREF(self);
return 1;
fireexception:
Snmp_invokeerrback(defer);
Py_XDECREF(results);
Py_XDECREF(resultvalue);
Py_XDECREF(resultoid);
Py_DECREF(defer);
Py_DECREF(self);
return 1;
}
PyObject *
PyInit_normalize(void) {
#else
#define INITERROR return
void
init_normalize(void) {
#endif
#ifdef IS_PY3K
PyObject *module = PyModule_Create(&module_def);
#else
PyObject *module = Py_InitModule("_normalize", normalize_methods);
#endif
if (module == NULL)
INITERROR;
struct module_state *st = GETSTATE(module);
st->error = PyErr_NewException("_normalize.Error", NULL, NULL);
if (st->error == NULL) {
Py_DECREF(module);
INITERROR;
}
if (!transliteration_module_setup(NULL)) {
PyErr_SetString(PyExc_RuntimeError,
"Could not load transliterate module");
Py_DECREF(module);
INITERROR;
}
PyModule_AddObject(module, "NORMALIZE_STRING_LATIN_ASCII", PyLong_FromUnsignedLongLong(NORMALIZE_STRING_LATIN_ASCII));
PyModule_AddObject(module, "NORMALIZE_STRING_TRANSLITERATE", PyLong_FromUnsignedLongLong(NORMALIZE_STRING_TRANSLITERATE));
PyModule_AddObject(module, "NORMALIZE_STRING_STRIP_ACCENTS", PyLong_FromUnsignedLongLong(NORMALIZE_STRING_STRIP_ACCENTS));
PyModule_AddObject(module, "NORMALIZE_STRING_DECOMPOSE", PyLong_FromUnsignedLongLong(NORMALIZE_STRING_DECOMPOSE));
PyModule_AddObject(module, "NORMALIZE_STRING_COMPOSE", PyLong_FromUnsignedLongLong(NORMALIZE_STRING_COMPOSE));
PyModule_AddObject(module, "NORMALIZE_STRING_LOWERCASE", PyLong_FromUnsignedLongLong(NORMALIZE_STRING_LOWERCASE));
PyModule_AddObject(module, "NORMALIZE_STRING_TRIM", PyLong_FromUnsignedLongLong(NORMALIZE_STRING_TRIM));
PyModule_AddObject(module, "NORMALIZE_STRING_REPLACE_HYPHENS", PyLong_FromUnsignedLongLong(NORMALIZE_STRING_REPLACE_HYPHENS));
PyModule_AddObject(module, "NORMALIZE_STRING_SIMPLE_LATIN_ASCII", PyLong_FromUnsignedLongLong(NORMALIZE_STRING_SIMPLE_LATIN_ASCII));
PyModule_AddObject(module, "NORMALIZE_TOKEN_REPLACE_HYPHENS", PyLong_FromUnsignedLongLong(NORMALIZE_TOKEN_REPLACE_HYPHENS));
PyModule_AddObject(module, "NORMALIZE_TOKEN_DELETE_HYPHENS", PyLong_FromUnsignedLongLong(NORMALIZE_TOKEN_DELETE_HYPHENS));
PyModule_AddObject(module, "NORMALIZE_TOKEN_DELETE_FINAL_PERIOD", PyLong_FromUnsignedLongLong(NORMALIZE_TOKEN_DELETE_FINAL_PERIOD));
PyModule_AddObject(module, "NORMALIZE_TOKEN_DELETE_ACRONYM_PERIODS", PyLong_FromUnsignedLongLong(NORMALIZE_TOKEN_DELETE_ACRONYM_PERIODS));
PyModule_AddObject(module, "NORMALIZE_TOKEN_DROP_ENGLISH_POSSESSIVES", PyLong_FromUnsignedLongLong(NORMALIZE_TOKEN_DROP_ENGLISH_POSSESSIVES));
PyModule_AddObject(module, "NORMALIZE_TOKEN_DELETE_OTHER_APOSTROPHE", PyLong_FromUnsignedLongLong(NORMALIZE_TOKEN_DELETE_OTHER_APOSTROPHE));
PyModule_AddObject(module, "NORMALIZE_TOKEN_SPLIT_ALPHA_FROM_NUMERIC", PyLong_FromUnsignedLongLong(NORMALIZE_TOKEN_SPLIT_ALPHA_FROM_NUMERIC));
PyModule_AddObject(module, "NORMALIZE_TOKEN_REPLACE_DIGITS", PyLong_FromUnsignedLongLong(NORMALIZE_TOKEN_REPLACE_DIGITS));
#if PY_MAJOR_VERSION >= 3
return module;
#endif
}
PyObject *
cpu_get_exception(JitCpu *self, PyObject *args) {
return PyLong_FromUnsignedLongLong(((struct vm_cpu *)self->cpu)->exception_flags);
}
static PyObject *
cpu_get_spr_access(JitCpu *self, PyObject *args) {
return PyLong_FromUnsignedLongLong(((struct vm_cpu *) self->cpu)->spr_access);
}
static PyObject* __py_genUUID64(PyObject *self, void *closure)
{
return PyLong_FromUnsignedLongLong(genUUID64());
}
static PyObject* wsql_connection_get_affected_rows(wsql_connection *self, void *closure)
{
CHECK_CONNECTION(self, NULL);
return PyLong_FromUnsignedLongLong(mysql_affected_rows(&(self->connection)));
}
PyObject* set_alarm(VmMngr* self)
{
global_vmmngr = self;
signal(SIGALRM, sig_alarm);
return PyLong_FromUnsignedLongLong((uint64_t)0);
}
PyObject * PyHit_GetWordID(PyObject * pSelf, PyObject* args, PyObject* kwargs)
{
/*
@param:
- Exact:
- Steam:
- ID with Marker:
*/
csfHelper_HitCollectorObject *self = (csfHelper_HitCollectorObject *)pSelf;
static char *kwlist[] = {"word", "exact", "steam", "idmarker", NULL };
char* sWord = NULL;
unsigned char bExact = 1;
unsigned char bSteam = 0;
unsigned char bIdMarker = 0;
int ok = PyArg_ParseTupleAndKeywords( args, kwargs, "s|BBB", kwlist, &sWord,
&bExact , &bSteam, &bIdMarker ); //not inc the value refer
if(!ok) {
if(PyErr_Occurred()) {
PyErr_Print();
PyErr_Clear();
}
return NULL;
}
{
CSphSource_Python* pPySource = dynamic_cast<CSphSource_Python*>(self->m_pSource);
CSphDict* pDict = pPySource->GetDict();
SphWordID_t iWord = 0;
BYTE sBuf [ 16+3*SPH_MAX_WORD_LEN + 1024 ]; //user's input term might be very long....
size_t iBytes = strlen ( (const char*)sWord );
if ( bExact )
{
size_t iBytes = strlen ( (const char*)sWord );
memcpy ( sBuf + 1, sWord, iBytes );
sBuf[0] = MAGIC_WORD_HEAD_NONSTEMMED;
sBuf[iBytes+1] = '\0';
iWord = pDict->GetWordIDNonStemmed ( sBuf );
} else
if (bIdMarker)
{
memcpy ( sBuf + 1, sWord, iBytes );
sBuf[0] = MAGIC_WORD_HEAD;
sBuf[iBytes+1] = '\0';
iWord = pDict->GetWordIDWithMarkers ( sBuf ) ;
}
else
{
iWord = pDict->GetWordID ((BYTE*) sWord );
}
if(!iWord)
RET_PYNONE;
#if USE_64BIT
return PyLong_FromUnsignedLongLong(iWord);
#else
return PyLong_FromUnsignedLong(iWord);
#endif
}
}
static PyObject *
dinode_rdev (DInode *self, void *closure)
{
return PyLong_FromUnsignedLongLong (self->dinode.id1.dev1.i_rdev);
}
OUT_TYPE_ERROR("UINT64");
return false;
}
//-------------------------------------------------------------------------------------
PyObject* UInt64Type::parseDefaultStr(std::string defaultVal)
{
uint64 val = 0;
if(!defaultVal.empty())
{
std::stringstream stream;
stream << defaultVal;
stream >> val;
}
PyObject* pyval = PyLong_FromUnsignedLongLong(val);
if (PyErr_Occurred())
{
S_RELEASE(pyval);
return PyLong_FromUnsignedLongLong(0);
}
return pyval;
}
//-------------------------------------------------------------------------------------
void UInt64Type::addToStream(MemoryStream* mstream, PyObject* pyValue)
{
uint64 udata = static_cast<uint64>(PyLong_AsUnsignedLongLong(pyValue));
(*mstream) << udata;
static PyObject *
dir_entry_inode (DirEntry *self, void *closure)
{
return PyLong_FromUnsignedLongLong (self->dentry.inode);
}
static PyObject *get_unsigned_immediate(instruction_t *self)
{
xed_uint64_t imm;
imm = xed_decoded_inst_get_unsigned_immediate(self->decoded_inst);
return PyLong_FromUnsignedLongLong(imm);
}
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;
}
PyObject* tcc_exec_bloc(PyObject* self, PyObject* args)
{
jitted_func func;
PyObject* jitcpu;
PyObject* func_py;
PyObject* lbl2ptr;
PyObject* breakpoints;
PyObject* retaddr = NULL;
int status;
block_id BlockDst;
uint64_t max_exec_per_call = 0;
uint64_t cpt;
int do_cpt;
if (!PyArg_ParseTuple(args, "OOOO|K",
&retaddr, &jitcpu, &lbl2ptr, &breakpoints,
&max_exec_per_call))
return NULL;
/* The loop will decref retaddr always once */
Py_INCREF(retaddr);
if (max_exec_per_call == 0) {
do_cpt = 0;
cpt = 1;
} else {
do_cpt = 1;
cpt = max_exec_per_call;
}
for (;;) {
if (cpt == 0)
return retaddr;
if (do_cpt)
cpt --;
// Init
BlockDst.is_local = 0;
BlockDst.address = 0;
// Get the expected jitted function address
func_py = PyDict_GetItem(lbl2ptr, retaddr);
if (func_py)
func = (jitted_func) PyLong_AsVoidPtr((PyObject*) func_py);
else {
if (BlockDst.is_local == 1) {
fprintf(stderr, "return on local label!\n");
exit(1);
}
// retaddr is not jitted yet
return retaddr;
}
// Execute it
status = func(&BlockDst, jitcpu);
Py_DECREF(retaddr);
retaddr = PyLong_FromUnsignedLongLong(BlockDst.address);
// Check exception
if (status)
return retaddr;
// Check breakpoint
if (PyDict_Contains(breakpoints, retaddr))
return retaddr;
}
}
/**
* pyg_value_as_pyobject:
* @value: the GValue object.
* @copy_boxed: true if boxed values should be copied.
*
* This function creates/returns a Python wrapper object that
* represents the GValue passed as an argument.
*
* Returns: a PyObject representing the value.
*/
PyObject *
pyg_value_as_pyobject(const GValue *value, gboolean copy_boxed)
{
gchar buf[128];
switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) {
case G_TYPE_INTERFACE:
if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT))
return pygobject_new(g_value_get_object(value));
else
break;
case G_TYPE_CHAR: {
gint8 val = g_value_get_char(value);
return PYGLIB_PyUnicode_FromStringAndSize((char *)&val, 1);
}
case G_TYPE_UCHAR: {
guint8 val = g_value_get_uchar(value);
return PYGLIB_PyBytes_FromStringAndSize((char *)&val, 1);
}
case G_TYPE_BOOLEAN: {
return PyBool_FromLong(g_value_get_boolean(value));
}
case G_TYPE_INT:
return PYGLIB_PyLong_FromLong(g_value_get_int(value));
case G_TYPE_UINT:
{
/* in Python, the Int object is backed by a long. If a
long can hold the whole value of an unsigned int, use
an Int. Otherwise, use a Long object to avoid overflow.
This matches the ULongArg behavior in codegen/argtypes.h */
#if (G_MAXUINT <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) g_value_get_uint(value));
#else
return PyLong_FromUnsignedLong((gulong) g_value_get_uint(value));
#endif
}
case G_TYPE_LONG:
return PYGLIB_PyLong_FromLong(g_value_get_long(value));
case G_TYPE_ULONG:
{
gulong val = g_value_get_ulong(value);
if (val <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) val);
else
return PyLong_FromUnsignedLong(val);
}
case G_TYPE_INT64:
{
gint64 val = g_value_get_int64(value);
if (G_MINLONG <= val && val <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) val);
else
return PyLong_FromLongLong(val);
}
case G_TYPE_UINT64:
{
guint64 val = g_value_get_uint64(value);
if (val <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) val);
else
return PyLong_FromUnsignedLongLong(val);
}
case G_TYPE_ENUM:
return pyg_enum_from_gtype(G_VALUE_TYPE(value), g_value_get_enum(value));
case G_TYPE_FLAGS:
return pyg_flags_from_gtype(G_VALUE_TYPE(value), g_value_get_flags(value));
case G_TYPE_FLOAT:
return PyFloat_FromDouble(g_value_get_float(value));
case G_TYPE_DOUBLE:
return PyFloat_FromDouble(g_value_get_double(value));
case G_TYPE_STRING:
{
const gchar *str = g_value_get_string(value);
if (str)
return PYGLIB_PyUnicode_FromString(str);
Py_INCREF(Py_None);
return Py_None;
}
case G_TYPE_POINTER:
return pyg_pointer_new(G_VALUE_TYPE(value),
g_value_get_pointer(value));
case G_TYPE_BOXED: {
PyGTypeMarshal *bm;
if (G_VALUE_HOLDS(value, PY_TYPE_OBJECT)) {
PyObject *ret = (PyObject *)g_value_dup_boxed(value);
if (ret == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
return ret;
} else if (G_VALUE_HOLDS(value, G_TYPE_VALUE)) {
GValue *n_value = g_value_get_boxed (value);
return pyg_value_as_pyobject(n_value, copy_boxed);
} else if (G_VALUE_HOLDS(value, G_TYPE_VALUE_ARRAY)) {
GValueArray *array = (GValueArray *) g_value_get_boxed(value);
PyObject *ret = PyList_New(array->n_values);
int i;
for (i = 0; i < array->n_values; ++i)
PyList_SET_ITEM(ret, i, pyg_value_as_pyobject
(array->values + i, copy_boxed));
return ret;
} else if (G_VALUE_HOLDS(value, G_TYPE_GSTRING)) {
GString *string = (GString *) g_value_get_boxed(value);
PyObject *ret = PYGLIB_PyUnicode_FromStringAndSize(string->str, string->len);
return ret;
}
bm = pyg_type_lookup(G_VALUE_TYPE(value));
if (bm) {
return bm->fromvalue(value);
} else {
if (copy_boxed)
return pyg_boxed_new(G_VALUE_TYPE(value),
g_value_get_boxed(value), TRUE, TRUE);
else
return pyg_boxed_new(G_VALUE_TYPE(value),
g_value_get_boxed(value),FALSE,FALSE);
}
}
case G_TYPE_PARAM:
return pyg_param_spec_new(g_value_get_param(value));
case G_TYPE_OBJECT:
return pygobject_new(g_value_get_object(value));
default:
{
PyGTypeMarshal *bm;
if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))))
return bm->fromvalue(value);
break;
}
}
g_snprintf(buf, sizeof(buf), "unknown type %s",
g_type_name(G_VALUE_TYPE(value)));
PyErr_SetString(PyExc_TypeError, buf);
return NULL;
}
static PyObject *
FDB_size_get(FDB *self, void *closure)
{
return PyLong_FromUnsignedLongLong(tcfdbfsiz(self->fdb));
}
/**
* Set one or more options in a decoder instance.
*
* Handled options are removed from the hash.
*
* @param di Decoder instance.
* @param options A GHashTable of options to set.
*
* @return SRD_OK upon success, a (negative) error code otherwise.
*/
SRD_API int srd_inst_option_set(struct srd_decoder_inst *di,
GHashTable *options)
{
PyObject *py_dec_options, *py_dec_optkeys, *py_di_options, *py_optval;
PyObject *py_optlist, *py_classval;
Py_UNICODE *py_ustr;
unsigned long long int val_ull;
int num_optkeys, ret, size, i;
char *key, *value;
if (!PyObject_HasAttrString(di->decoder->py_dec, "options")) {
/* Decoder has no options. */
if (g_hash_table_size(options) == 0) {
/* No options provided. */
return SRD_OK;
} else {
srd_err("Protocol decoder has no options.");
return SRD_ERR_ARG;
}
return SRD_OK;
}
ret = SRD_ERR_PYTHON;
key = NULL;
py_dec_options = py_dec_optkeys = py_di_options = py_optval = NULL;
py_optlist = py_classval = NULL;
py_dec_options = PyObject_GetAttrString(di->decoder->py_dec, "options");
/* All of these are synthesized objects, so they're good. */
py_dec_optkeys = PyDict_Keys(py_dec_options);
num_optkeys = PyList_Size(py_dec_optkeys);
if (!(py_di_options = PyObject_GetAttrString(di->py_inst, "options")))
goto err_out;
for (i = 0; i < num_optkeys; i++) {
/* Get the default class value for this option. */
py_str_as_str(PyList_GetItem(py_dec_optkeys, i), &key);
if (!(py_optlist = PyDict_GetItemString(py_dec_options, key)))
goto err_out;
if (!(py_classval = PyList_GetItem(py_optlist, 1)))
goto err_out;
if (!PyUnicode_Check(py_classval) && !PyLong_Check(py_classval)) {
srd_err("Options of type %s are not yet supported.",
Py_TYPE(py_classval)->tp_name);
goto err_out;
}
if ((value = g_hash_table_lookup(options, key))) {
/* An override for this option was provided. */
if (PyUnicode_Check(py_classval)) {
if (!(py_optval = PyUnicode_FromString(value))) {
/* Some UTF-8 encoding error. */
PyErr_Clear();
goto err_out;
}
} else if (PyLong_Check(py_classval)) {
if (!(py_optval = PyLong_FromString(value, NULL, 0))) {
/* ValueError Exception */
PyErr_Clear();
srd_err("Option %s has invalid value "
"%s: expected integer.",
key, value);
goto err_out;
}
}
g_hash_table_remove(options, key);
} else {
/* Use the class default for this option. */
if (PyUnicode_Check(py_classval)) {
/* Make a brand new copy of the string. */
py_ustr = PyUnicode_AS_UNICODE(py_classval);
size = PyUnicode_GET_SIZE(py_classval);
py_optval = PyUnicode_FromUnicode(py_ustr, size);
} else if (PyLong_Check(py_classval)) {
/* Make a brand new copy of the integer. */
val_ull = PyLong_AsUnsignedLongLong(py_classval);
if (val_ull == (unsigned long long)-1) {
/* OverFlowError exception */
PyErr_Clear();
srd_err("Invalid integer value for %s: "
"expected integer.", key);
goto err_out;
}
if (!(py_optval = PyLong_FromUnsignedLongLong(val_ull)))
goto err_out;
}
}
/*
* If we got here, py_optval holds a known good new reference
* to the instance option to set.
*/
if (PyDict_SetItemString(py_di_options, key, py_optval) == -1)
goto err_out;
}
ret = SRD_OK;
err_out:
Py_XDECREF(py_optlist);
Py_XDECREF(py_di_options);
Py_XDECREF(py_dec_optkeys);
Py_XDECREF(py_dec_options);
g_free(key);
if (PyErr_Occurred())
srd_exception_catch("Stray exception in srd_inst_option_set().");
return ret;
}
static void python_process_event(int cpu, void *data,
int size __unused,
unsigned long long nsecs, char *comm)
{
PyObject *handler, *retval, *context, *t, *obj, *dict = NULL;
static char handler_name[256];
struct format_field *field;
unsigned long long val;
unsigned long s, ns;
struct event *event;
unsigned n = 0;
int type;
int pid;
t = PyTuple_New(MAX_FIELDS);
if (!t)
Py_FatalError("couldn't create Python tuple");
type = trace_parse_common_type(data);
event = find_cache_event(type);
if (!event)
die("ug! no event found for type %d", type);
pid = trace_parse_common_pid(data);
sprintf(handler_name, "%s__%s", event->system, event->name);
handler = PyDict_GetItemString(main_dict, handler_name);
if (handler && !PyCallable_Check(handler))
handler = NULL;
if (!handler) {
dict = PyDict_New();
if (!dict)
Py_FatalError("couldn't create Python dict");
}
s = nsecs / NSECS_PER_SEC;
ns = nsecs - s * NSECS_PER_SEC;
scripting_context->event_data = data;
context = PyCObject_FromVoidPtr(scripting_context, NULL);
PyTuple_SetItem(t, n++, PyString_FromString(handler_name));
PyTuple_SetItem(t, n++,
PyCObject_FromVoidPtr(scripting_context, NULL));
if (handler) {
PyTuple_SetItem(t, n++, PyInt_FromLong(cpu));
PyTuple_SetItem(t, n++, PyInt_FromLong(s));
PyTuple_SetItem(t, n++, PyInt_FromLong(ns));
PyTuple_SetItem(t, n++, PyInt_FromLong(pid));
PyTuple_SetItem(t, n++, PyString_FromString(comm));
} else {
PyDict_SetItemString(dict, "common_cpu", PyInt_FromLong(cpu));
PyDict_SetItemString(dict, "common_s", PyInt_FromLong(s));
PyDict_SetItemString(dict, "common_ns", PyInt_FromLong(ns));
PyDict_SetItemString(dict, "common_pid", PyInt_FromLong(pid));
PyDict_SetItemString(dict, "common_comm", PyString_FromString(comm));
}
for (field = event->format.fields; field; field = field->next) {
if (field->flags & FIELD_IS_STRING) {
int offset;
if (field->flags & FIELD_IS_DYNAMIC) {
offset = *(int *)(data + field->offset);
offset &= 0xffff;
} else
offset = field->offset;
obj = PyString_FromString((char *)data + offset);
} else { /* FIELD_IS_NUMERIC */
val = read_size(data + field->offset, field->size);
if (field->flags & FIELD_IS_SIGNED) {
if ((long long)val >= LONG_MIN &&
(long long)val <= LONG_MAX)
obj = PyInt_FromLong(val);
else
obj = PyLong_FromLongLong(val);
} else {
if (val <= LONG_MAX)
obj = PyInt_FromLong(val);
else
obj = PyLong_FromUnsignedLongLong(val);
}
}
if (handler)
PyTuple_SetItem(t, n++, obj);
else
PyDict_SetItemString(dict, field->name, obj);
}
if (!handler)
PyTuple_SetItem(t, n++, dict);
if (_PyTuple_Resize(&t, n) == -1)
Py_FatalError("error resizing Python tuple");
if (handler) {
retval = PyObject_CallObject(handler, t);
if (retval == NULL)
handler_call_die(handler_name);
} else {
handler = PyDict_GetItemString(main_dict, "trace_unhandled");
if (handler && PyCallable_Check(handler)) {
retval = PyObject_CallObject(handler, t);
if (retval == NULL)
handler_call_die("trace_unhandled");
}
Py_DECREF(dict);
}
Py_DECREF(t);
}
static PyObject *
Util_func_hrtime(PyObject *obj)
{
UNUSED_ARG(obj);
return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)uv_hrtime());
}
PyObject* cpu_get_exception(JitCpu* self, PyObject* args)
{
return PyLong_FromUnsignedLongLong((uint64_t)(((vm_cpu_t*)self->cpu)->exception_flags));
}
static PyObject *
Util_func_get_free_memory(PyObject *obj)
{
UNUSED_ARG(obj);
return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)uv_get_free_memory());
}
PyObject* vm_get_exception(VmMngr* self, PyObject* args)
{
return PyLong_FromUnsignedLongLong((uint64_t)self->vm_mngr.exception_flags);
}
PyObject *qd_field_to_py(qd_parsed_field_t *field)
{
qd_python_check_lock();
PyObject *result = 0;
uint8_t tag = qd_parse_tag(field);
switch (tag) {
case QD_AMQP_NULL:
Py_INCREF(Py_None);
result = Py_None;
break;
case QD_AMQP_BOOLEAN:
case QD_AMQP_TRUE:
case QD_AMQP_FALSE:
result = qd_parse_as_uint(field) ? Py_True : Py_False;
break;
case QD_AMQP_UBYTE:
case QD_AMQP_USHORT:
case QD_AMQP_UINT:
case QD_AMQP_SMALLUINT:
case QD_AMQP_UINT0:
result = PyInt_FromLong((long) qd_parse_as_uint(field));
break;
case QD_AMQP_ULONG:
case QD_AMQP_SMALLULONG:
case QD_AMQP_ULONG0:
case QD_AMQP_TIMESTAMP:
result = PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) qd_parse_as_ulong(field));
break;
case QD_AMQP_BYTE:
case QD_AMQP_SHORT:
case QD_AMQP_INT:
case QD_AMQP_SMALLINT:
result = PyInt_FromLong((long) qd_parse_as_int(field));
break;
case QD_AMQP_LONG:
case QD_AMQP_SMALLLONG:
result = PyLong_FromLongLong((PY_LONG_LONG)qd_parse_as_long(field));
break;
case QD_AMQP_FLOAT:
case QD_AMQP_DOUBLE:
case QD_AMQP_DECIMAL32:
case QD_AMQP_DECIMAL64:
case QD_AMQP_DECIMAL128:
case QD_AMQP_UTF32:
case QD_AMQP_UUID:
break;
case QD_AMQP_VBIN8:
case QD_AMQP_VBIN32:
case QD_AMQP_STR8_UTF8:
case QD_AMQP_STR32_UTF8:
case QD_AMQP_SYM8:
case QD_AMQP_SYM32:
result = parsed_to_py_string(field);
break;
case QD_AMQP_LIST0:
case QD_AMQP_LIST8:
case QD_AMQP_LIST32: {
uint32_t count = qd_parse_sub_count(field);
result = PyList_New(count);
for (uint32_t idx = 0; idx < count; idx++) {
qd_parsed_field_t *sub = qd_parse_sub_value(field, idx);
PyObject *pysub = qd_field_to_py(sub);
if (pysub == 0)
return 0;
PyList_SetItem(result, idx, pysub);
}
break;
}
case QD_AMQP_MAP8:
case QD_AMQP_MAP32: {
uint32_t count = qd_parse_sub_count(field);
result = PyDict_New();
for (uint32_t idx = 0; idx < count; idx++) {
qd_parsed_field_t *key = qd_parse_sub_key(field, idx);
qd_parsed_field_t *val = qd_parse_sub_value(field, idx);
PyObject *pykey = parsed_to_py_string(key);
PyObject *pyval = qd_field_to_py(val);
if (pyval == 0)
return 0;
PyDict_SetItem(result, pykey, pyval);
Py_DECREF(pykey);
Py_DECREF(pyval);
}
break;
}
case QD_AMQP_ARRAY8:
case QD_AMQP_ARRAY32:
break;
}
if (!result)
Py_RETURN_NONE;
return result;
}
