POVMSResult POVMS_MessageReceiver::ReceiveHandler(POVMSObjectPtr msg, POVMSObjectPtr result, int mode, void *privatedataptr)
{
POVMS_MessageReceiver *self = (POVMS_MessageReceiver *)privatedataptr;
HandlerNode *nodeptr = nullptr;
POVMSType hclass = kPOVMSType_Null;
POVMSType hid = kPOVMSType_Null;
POVMSResult err = pov_base::kNoErr;
if (self == nullptr)
err = pov_base::kParamErr;
if(err == pov_base::kNoErr)
err = POVMSMsg_GetMessageClass(msg, &hclass);
if(err == pov_base::kNoErr)
err = POVMSUtil_GetType(msg, kPOVMSMessageIdentID, &hid);
for (nodeptr = self->receivers; nodeptr != nullptr && err == pov_base::kNoErr; nodeptr = nodeptr->next)
{
if((nodeptr->hclass == hclass) && ((nodeptr->hid == hid) || (nodeptr->hid == kPOVMSType_WildCard)))
{
if (nodeptr->handleroo != nullptr)
{
POVMS_Message result_obj(result);
POVMS_Message msg_obj(msg);
// Note: This try-catch block is only required because msg_obj.DetachData always has to be executed! [trf]
try
{
nodeptr->handleroo->Call(msg_obj, result_obj, mode);
}
catch(...)
{
// result and msg no longer own their resources; if we don't clear them here,
// we can get a double-free in a parent method when this method throws an exception.
// an example of this is when create scene fails with an out-of-memory exception.
memset(result, 0, sizeof(*result));
memset(msg, 0, sizeof(*msg));
msg_obj.DetachData();
throw;
}
msg_obj.DetachData();
if ((result != nullptr) && (result_obj.IsNull() == false))
*result = result_obj();
}
else if (nodeptr->handler != nullptr)
nodeptr->handler->Call(msg, result, mode);
else
err = pov_base::kNullPointerErr;
}
}
return err;
}
int POVMS_MessageReceiver::ReceiveHandler(POVMSObjectPtr msg, POVMSObjectPtr result, int mode, void *privatedataptr)
{
POVMS_MessageReceiver *self = (POVMS_MessageReceiver *)privatedataptr;
HandlerNode *nodeptr = NULL;
POVMSType hclass = kPOVMSType_Null;
POVMSType hid = kPOVMSType_Null;
int err = kNoErr;
if(self == NULL)
err = kParamErr;
if(err == kNoErr)
err = POVMSMsg_GetMessageClass(msg, &hclass);
if(err == kNoErr)
err = POVMSUtil_GetType(msg, kPOVMSMessageIdentID, &hid);
if(err == kNoErr)
{
for(nodeptr = self->receivers; nodeptr != NULL; nodeptr = nodeptr->next)
{
if((nodeptr->hclass == hclass) && ((nodeptr->hid == hid) || (nodeptr->hid == kPOVMSType_WildCard)))
{
try
{
if(nodeptr->handleroo != NULL)
{
POVMS_Message msg_obj(msg);
POVMS_Message result_obj(result);
nodeptr->handleroo->Call(msg_obj, result_obj, mode);
msg_obj.DetachData();
if(result != NULL)
*result = result_obj();
result_obj.DetachData();
}
else if(nodeptr->handler != NULL)
nodeptr->handler->Call(msg, result, mode);
else
err = kNullPointerErr;
}
catch(int e)
{
err = e;
}
catch(...)
{
err = kParamErr;
}
}
}
}
return err;
}
long list_base::index(object_cref value) const
{
object result_obj(this->attr("index")(value));
long result = PyInt_AsLong(result_obj.ptr());
if (result == -1)
throw_error_already_set();
return result;
}
long list_base::index(object_cref value) const
{
object result_obj(this->attr("index")(value));
#if PY_VERSION_HEX >= 0x03000000
ssize_t result = PyLong_AsSsize_t(result_obj.ptr());
#else
long result = PyInt_AsLong(result_obj.ptr());
#endif
if (result == -1)
throw_error_already_set();
return result;
}
// Dump stack trace of threads specified in the given threads array.
// Returns StackTraceElement[][] each element is the stack trace of a thread in
// the corresponding entry in the given threads array
Handle ThreadService::dump_stack_traces(GrowableArray<instanceHandle>* threads,
int num_threads,
TRAPS) {
assert(num_threads > 0, "just checking");
ThreadDumpResult dump_result;
VM_ThreadDump op(&dump_result,
threads,
num_threads,
-1, /* entire stack */
false, /* with locked monitors */
false /* with locked synchronizers */);
VMThread::execute(&op);
// Allocate the resulting StackTraceElement[][] object
ResourceMark rm(THREAD);
Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_StackTraceElement_array(), true, CHECK_NH);
ObjArrayKlass* ik = ObjArrayKlass::cast(k);
objArrayOop r = oopFactory::new_objArray(ik, num_threads, CHECK_NH);
objArrayHandle result_obj(THREAD, r);
int num_snapshots = dump_result.num_snapshots();
assert(num_snapshots == num_threads, "Must have num_threads thread snapshots");
int i = 0;
for (ThreadSnapshot* ts = dump_result.snapshots(); ts != NULL; i++, ts = ts->next()) {
ThreadStackTrace* stacktrace = ts->get_stack_trace();
if (stacktrace == NULL) {
// No stack trace
result_obj->obj_at_put(i, NULL);
} else {
// Construct an array of java/lang/StackTraceElement object
Handle backtrace_h = stacktrace->allocate_fill_stack_trace_element_array(CHECK_NH);
result_obj->obj_at_put(i, backtrace_h());
}
}
return result_obj;
}
