struct forkable_stack_state saved_data_stack;
struct forkable_stack_state saved_call_stack;
int path_len, subexp_nest;
+ uint16_t* return_address;
};
-void stack_save(jq_state *jq){
+void stack_save(jq_state *jq, uint16_t* retaddr){
struct forkpoint* fork = forkable_stack_push(&jq->fork_stk, sizeof(struct forkpoint));
forkable_stack_save(&jq->data_stk, &fork->saved_data_stack);
forkable_stack_save(&jq->frame_stk, &fork->saved_call_stack);
fork->path_len =
jv_get_kind(jq->path) == JV_KIND_ARRAY ? jv_array_length(jv_copy(jq->path)) : 0;
fork->subexp_nest = jq->subexp_nest;
+ fork->return_address = retaddr;
}
void stack_switch(jq_state *jq) {
}
}
-int stack_restore(jq_state *jq){
+uint16_t* stack_restore(jq_state *jq){
while (!forkable_stack_empty(&jq->data_stk) &&
forkable_stack_pop_will_free(&jq->data_stk)) {
jv_free(stack_pop(jq));
}
struct forkpoint* fork = forkable_stack_peek(&jq->fork_stk);
+ uint16_t* retaddr = fork->return_address;
forkable_stack_restore(&jq->data_stk, &fork->saved_data_stack);
forkable_stack_restore(&jq->frame_stk, &fork->saved_call_stack);
int path_len = fork->path_len;
}
jq->subexp_nest = fork->subexp_nest;
forkable_stack_pop(&jq->fork_stk);
- return 1;
+ return retaddr;
}
jv jq_next(jq_state *jq) {
jv cfunc_input[MAX_CFUNCTION_ARGS];
- assert(!forkable_stack_empty(&jq->frame_stk));
- uint16_t* pc = *frame_current_retaddr(&jq->frame_stk);
- frame_pop(&jq->frame_stk);
-
- assert(!forkable_stack_empty(&jq->frame_stk));
+ uint16_t* pc = stack_restore(jq);
+ assert(pc);
int backtracking = 0;
while (1) {
jv v = stack_pop(jq);
stack_push(jq, jq->path);
- stack_save(jq);
- frame_push_backtrack(&jq->frame_stk, pc - 1);
+ stack_save(jq, pc - 1);
stack_switch(jq);
stack_push(jq, jv_number(jq->subexp_nest));
jv path = jq->path;
jq->path = stack_pop(jq);
- stack_save(jq);
+ stack_save(jq, pc - 1);
stack_push(jq, jv_copy(path));
- frame_push_backtrack(&jq->frame_stk, pc - 1);
stack_switch(jq);
stack_push(jq, path);
jv_free(container);
goto do_backtrack;
} else {
- stack_save(jq);
+ stack_save(jq, pc - 1);
stack_push(jq, container);
stack_push(jq, jv_number(idx));
- frame_push_backtrack(&jq->frame_stk, pc - 1);
stack_switch(jq);
path_append(jq, key);
stack_push(jq, value);
do_backtrack:
case BACKTRACK: {
- if (!stack_restore(jq)) {
+ pc = stack_restore(jq);
+ if (!pc) {
return jv_invalid();
}
- pc = *frame_current_retaddr(&jq->frame_stk);
- frame_pop(&jq->frame_stk);
backtracking = 1;
break;
}
case FORK: {
- stack_save(jq);
- frame_push_backtrack(&jq->frame_stk, pc - 1);
+ stack_save(jq, pc - 1);
stack_switch(jq);
pc++; // skip offset this time
break;
case YIELD: {
jv value = stack_pop(jq);
- frame_push_backtrack(&jq->frame_stk, pc);
+ stack_save(jq, pc);
+ stack_switch(jq);
return value;
}
stack_push(new_jq, input);
struct closure top = {bc, -1};
frame_push(&new_jq->frame_stk, top, 0);
- frame_push_backtrack(&new_jq->frame_stk, bc->code);
+ stack_save(new_jq, bc->code);
+ stack_switch(new_jq);
if (flags & JQ_DEBUG_TRACE) {
new_jq->debug_trace_enabled = 1;
} else {
struct bytecode* bc;
stack_idx env;
uint16_t* retaddr;
- // FIXME: probably not necessary as a separate field
- int is_backtrack_frame;
};
typedef union frame_elem {
cc->bc = cl.bc;
cc->env = cl.env;
cc->retaddr = retaddr;
- cc->is_backtrack_frame = 0;
for (int i=0; i<cl.bc->nlocals; i++) {
*frame_local_var(fp, i) = jv_invalid();
}
return fp;
}
-static frame_ptr frame_push_backtrack(struct forkable_stack* stk, uint16_t* retaddr) {
- struct continuation cc = *frame_self(frame_current(stk));
- frame_ptr fp = forkable_stack_push(stk, sizeof(union frame_elem) * 2);
- assert(!cc.is_backtrack_frame);
- cc.is_backtrack_frame = 1;
- cc.retaddr = retaddr;
- *frame_self(fp) = cc;
- return fp;
-}
-
static void frame_pop(struct forkable_stack* stk) {
frame_ptr fp = frame_current(stk);
- if (forkable_stack_pop_will_free(stk) &&
- !frame_self(fp)->is_backtrack_frame) {
+ if (forkable_stack_pop_will_free(stk)) {
int nlocals = frame_self(fp)->bc->nlocals;
for (int i=0; i<nlocals; i++) {
jv_free(*frame_local_var(fp, i));