Merge pull request #43 from erikh/run-with-context

Implement mrb_context_run.

gomruby.h

@@ -231,4 +231,10 @@ static inline void _go_mrb_context_set_capture_errors(struct mrbc_context *ctx,
   }
 }
 
+static inline mrb_value _go_mrb_context_run(mrb_state *m, struct RProc *proc, mrb_value self, int *stack_keep) {
+  mrb_value result = mrb_context_run(m, proc, self, *stack_keep);
+  *stack_keep = proc->body.irep->nlocals;
+  return result;
+}
+
 #endif

mruby.go

@@ -216,6 +216,32 @@ func (m *Mrb) Run(v Value, self Value) (*MrbValue, error) {
 	return newValue(m.state, value), nil
 }
 
+// RunWithContext is a context-aware parser (aka, it does not discard state
+// between runs). It returns a magic integer that describes the stack in place,
+// so that it can be re-used on the next call. This is how local variables can
+// traverse ruby parse invocations.
+//
+// Otherwise, it is very similar in function to Run()
+func (m *Mrb) RunWithContext(v Value, self Value, stackKeep int) (int, *MrbValue, error) {
+	if self == nil {
+		self = m.TopSelf()
+	}
+
+	mrbV := v.MrbValue(m)
+	mrbSelf := self.MrbValue(m)
+	proc := C._go_mrb_proc_ptr(mrbV.value)
+
+	i := C.int(stackKeep)
+
+	value := C._go_mrb_context_run(m.state, proc, mrbSelf.value, &i)
+
+	if exc := checkException(m.state); exc != nil {
+		return stackKeep, nil, exc
+	}
+
+	return int(i), newValue(m.state, value), nil
+}
+
 // Yield yields to a block with the given arguments.
 //
 // This should be called within the context of a Func.

mruby_test.go

@@ -444,4 +444,28 @@ func TestMrbRun(t *testing.T) {
 	if rval.String() != "rval" {
 		t.Fatalf("expected return value 'rval', got %#v", rval)
 	}
+
+	parser.Parse(`a = 10`, context)
+	proc = parser.GenerateCode()
+
+	stackKeep, ret, err := mrb.RunWithContext(proc, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if stackKeep != 2 {
+		t.Fatalf("stack value was %d not 2; some variables may not have been captured", stackKeep)
+	}
+
+	parser.Parse(`a`, context)
+	proc = parser.GenerateCode()
+
+	stackKeep, ret, err = mrb.RunWithContext(proc, nil, stackKeep)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if ret.String() != "10" {
+		t.Fatalf("Captured variable was not expected value: was %q", ret.String())
+	}
 }