void
Parrot_schedule_interp_qentry(Parrot_Interp interpreter, QUEUE_ENTRY* entry)
{
parrot_event* event;
event = entry->data;
/*
* sleep checks events when it awakes
*/
edebug((stderr, "got entry - schedule_inter_qentry %s\n", et(event)));
if (event->type != EVENT_TYPE_SLEEP)
enable_event_checking(interpreter);
/*
* do push_entry last - this signales the queue condition so the
* interpreter might starting process that event immediately
*
* we should better use a priority for placing the event
* in front or at the end of the queue
*/
switch (event->type) {
case EVENT_TYPE_CALL_BACK:
case EVENT_TYPE_SIGNAL:
unshift_entry(interpreter->task_queue, entry);
break;
default:
push_entry(interpreter->task_queue, entry);
break;
}
}
int
list_unshift_value(linked_list_t *list, void *val)
{
int res;
list_entry_t *new_entry = create_entry();
if(!new_entry)
return -1;
new_entry->value = val;
res = unshift_entry(list, new_entry);
if(res != 0)
destroy_entry(new_entry);
return res;
}
/*
* Instert an entry at a specified position in a linked_list_t
*/
static inline int
insert_entry(linked_list_t *list, list_entry_t *entry, size_t pos)
{
list_entry_t *prev, *next;
int ret = -1;
MUTEX_LOCK(list->lock);
if(pos == 0) {
ret = unshift_entry(list, entry);
} else if(pos == list->length) {
ret = push_entry(list, entry);
} else if (pos > list->length) {
unsigned int i;
for (i = list->length; i < pos; i++) {
list_entry_t *emptyEntry = create_entry();
if (!emptyEntry || push_entry(list, emptyEntry) != 0)
{
if (emptyEntry)
destroy_entry(emptyEntry);
MUTEX_UNLOCK(list->lock);
return -1;
}
}
ret = push_entry(list, entry);
}
if (ret == 0) {
MUTEX_UNLOCK(list->lock);
return ret;
}
prev = pick_entry(list, pos-1);
if(prev)
{
next = prev->next;
prev->next = entry;
entry->prev = prev;
entry->next = next;
if (next)
next->prev = entry;
list->length++;
ret = 0;
}
MUTEX_UNLOCK(list->lock);
return ret;
}
int
list_unshift_tagged_value(linked_list_t *list, tagged_value_t *tval)
{
int res = 0;
list_entry_t *new_entry;
if(tval)
{
new_entry = create_entry();
if(new_entry)
{
new_entry->tagged = 1;
new_entry->value = tval;
res = unshift_entry(list, new_entry);
if(res != 0)
destroy_entry(new_entry);
}
}
return res;
}
void
Parrot_schedule_event(Parrot_Interp interpreter, parrot_event* ev)
{
QUEUE_ENTRY* entry = mem_sys_allocate(sizeof(QUEUE_ENTRY));
entry->next = NULL;
ev->interp = interpreter;
entry->data = ev;
switch (ev->type) {
case EVENT_TYPE_TIMER:
case EVENT_TYPE_SLEEP:
entry->type = QUEUE_ENTRY_TYPE_TIMED_EVENT;
insert_entry(event_queue, entry);
break;
case EVENT_TYPE_CALL_BACK:
case EVENT_TYPE_SIGNAL:
entry->type = QUEUE_ENTRY_TYPE_EVENT;
unshift_entry(event_queue, entry);
break;
default:
entry->type = QUEUE_ENTRY_TYPE_EVENT;
push_entry(event_queue, entry);
break;
}
}
