const char* orcaForStack::cont(int* lv1, orcaData* d1, int *lv2, orcaData* d2)
{
FOR f2 = *top();
FOR* f = top();
int depth = m_stack.size();
f->idx++;
*d2 = NIL;
// check limit (per for parallel for sub group)
if (f->limit >= 0) {
f->limit--;
if (f->limit < 0) {
return 0;
}
}
try {
orcaVM* vm = get_current_vm();
vm->push_stack(f->next);
vm->call(0); // iter.next();
orcaData result = vm->m_stack->pop();
if (f->lv2 > 0) {
if (f->is_iter2) {
orcaTuple* tp = castobj<orcaTuple>(result);
if (tp == NULL || tp->size() != 2) {
throw orcaException(NULL, "orca.type", "iter2 should return tuple (pair)");
}
*d1 = tp->at(0);
*d2 = tp->at(1);
}
else {
*d1 = f->idx;
*d2 = result;
}
}
else {
*d1 = result;
}
}
catch(orcaException& e) {
if (string("orca.iter.end") != e.who()) {
throw e;
}
e.rc_dec();
get_current_vm()->m_curr = f->m_curr_back;
return 0;
}
*lv1 = f->lv1;
*lv2 = f->lv2;
return f->code;
}
bool orcaForStack::push(const char* code, int lv, orcaObject* obj, orcaData& out, orcaObject* curr)
{
FOR* f = new FOR(code, lv, -1, curr);
orcaData next, iter;
if (obj->has_member((char*)"iter", iter)) {
orcaVM* vm = get_current_vm();
vm->push_stack(iter);
vm->call(0); // iter()
obj = vm->m_stack->pop().Object();
}
if (obj->has_member((char*)"next", next) == false) {
throw orcaException(NULL, "orca.type", string("not iterable type ") + obj->dump_str());
}
if (!is<TYPE_OBJ>(next) && !is<TYPE_NATIVE>(next)) {
throw orcaException(NULL, "orca.type", "next is not runable");
}
f->iter = obj;
f->next = next;
push(f);
int dummy_i;
orcaData dummy_d;
const char* dummy_code = cont(&lv, &out, &dummy_i, &dummy_d);
if (dummy_code == 0) {
pop();
return false;
}
return true;
}
static void gui_callback(GtkWidget* widget, gpointer param)/*{{{*/
{
orcaVM* vm = get_current_vm();
vm->m_stack->push((orcaObject*)param);
vm->call(0);
vm->m_stack->pop();
}
static void gui_toggled_callback(GtkWidget* widget, gpointer param)/*{{{*/
{
bool active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
orcaVM* vm = get_current_vm();
vm->m_stack->push((orcaObject*)param);
vm->push_param(active);
vm->call(1);
vm->m_stack->pop();
}
static void gui_combo_changed_callback(GtkWidget* widget, gpointer param)/*{{{*/
{
gchar* text = gtk_combo_box_get_active_text(GTK_COMBO_BOX(widget));
string str = text;
g_free(text);
orcaVM* vm = get_current_vm();
vm->m_stack->push((orcaObject*)param);
vm->push_param(str);
vm->call(1);
vm->m_stack->pop();
}
static void gui_list_tree_toggled_callback (GtkCellRendererToggle *cell, gchar *path_str, gpointer data, bool list)/*{{{*/
{
signal_t* p = (signal_t*)data;
orcaObject* fun = p->fun;
GtkTreeModel *model = p->tree;
orcaGtk *owner = p->owner;
GtkTreeIter iter;
GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
gboolean fixed;
/* get toggled iter */
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, 0, &fixed, -1);
/* do something with the value */
fixed ^= 1;
/* set new value */
if (list)
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, fixed, -1);
else
gtk_tree_store_set (GTK_TREE_STORE (model), &iter, 0, fixed, -1);
/* clean up */
gtk_tree_path_free (path);
orcaGtkIter* ip = new orcaGtkIter();
ip->m_gp = owner;
ip->m_iter = iter;
ip->m_type = list ? GUI_LIST : GUI_TREE;
orcaVM* vm = get_current_vm();
vm->m_stack->push((orcaObject*)fun);
vm->push_param(fixed?true:false);
vm->push_param(ip);
vm->call(2);
vm->m_stack->pop();
}
static void gui_list_tree_changed_callback(GtkWidget* widget, gpointer param, bool list)/*{{{*/
{
GtkTreeIter iter;
GtkTreeModel *model;
char *value;
if (gtk_tree_selection_get_selected(GTK_TREE_SELECTION(widget), &model, &iter)) {
orcaGtkIter* ip = new orcaGtkIter();
signal_t* s = (signal_t*)param;
ip->m_gp = s->owner;
ip->m_iter = iter;
if (list)
ip->m_type = GUI_LIST;
else
ip->m_type = GUI_TREE;
orcaVM* vm = get_current_vm();
vm->m_stack->push(s->fun);
vm->push_param(ip);
vm->call(1);
vm->m_stack->pop();
}
}
// the string of course.
inline value v_string(const WCHAR* str, unsigned len = 0) { HVM vm = get_current_vm(); assert(vm); return v_string(vm,str,len); }
array_ref():pinned(get_current_vm()) { }
inline value value_by_path(const char* path) { HVM vm = get_current_vm(); assert(vm); value r = v_undefined(); ni()->get_value_by_path(vm, &r, path); return r; }
inline std::ustring to_string(value v) { HVM vm = get_current_vm(); assert(vm);
return to_string(vm,v); }
// make instance of Bytes object in script -
// sequence of bytes.
// Be notified: Bytes is a citizen of GCable heap. Use pinned thing to hold it
inline value v_bytes(const unsigned char* data, unsigned datalen) { HVM vm = get_current_vm(); assert(vm);
return v_bytes(vm,data,datalen); }
