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; }