Fix an issue where the args list would get corrupted if Procs were used.

The issue seems to center around the union types that mruby uses.
Examining the anomaly I noticed the proc values were getting truncated
-- they are a part of a union and maybe mruby is doing something weird
here.

Either way, copying the struct (leaving the data unaltered) as opposed
to passing the pointer, seems to preserve the width information which is
what was causign the issue. I strongly believe this fixes two bugs; one
in argument handling of proc and another where certain values would get
corrupted and could not be extracted as string.

The rest of this is cleanup and rearch for simpler code.

Signed-off-by: Erik Hollensbe <[email protected]>

Author: Erik Hollensbe

args.go

@@ -1,8 +1,6 @@
 package mruby
 
-import (
-	"sync"
-)
+import "sync"
 
 // #include "gomruby.h"
 import "C"
@@ -45,10 +43,10 @@ func ArgsOpt(n int) ArgSpec {
 
 // The global accumulator when Mrb.GetArgs is called. There is a
 // global lock around this so that the access to it is safe.
-var getArgAccumulator []*C.mrb_value
-var getArgLock sync.Mutex
+var getArgAccumulator []C.mrb_value
+var getArgLock = new(sync.Mutex)
 
 //export goGetArgAppend
-func goGetArgAppend(v *C.mrb_value) {
+func goGetArgAppend(v C.mrb_value) {
 	getArgAccumulator = append(getArgAccumulator, v)
 }

gomruby.h

@@ -7,6 +7,7 @@
 #ifndef _GOMRUBY_H_INCLUDED
 #define _GOMRUBY_H_INCLUDED
 
+#include <errno.h>
 #include <mruby.h>
 #include <mruby/array.h>
 #include <mruby/class.h>
@@ -21,6 +22,13 @@
 #include <mruby/value.h>
 #include <mruby/variable.h>
 
+// (erikh) this can be set in mruby/mrbconfig.h so we can default it here.
+// XXX I don't know how this actually plays out when the config is modified.
+// I'm taking a WAG here. Either way, the default is 16 in vm.c.
+#ifndef MRB_FUNCALL_ARGC_MAX
+  #define MRB_FUNCALL_ARGC_MAX 16
+#endif // MRB_FUNCALL_ARGC_MAX
+
 //-------------------------------------------------------------------
 // Helpers to deal with calling back into Go.
 //-------------------------------------------------------------------
@@ -90,24 +98,32 @@ static mrb_value _go_mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, c
 // Helpers to deal with getting arguments
 //-------------------------------------------------------------------
 // This is declard in args.go
-extern void goGetArgAppend(mrb_value*);
+extern void goGetArgAppend(mrb_value);
 
 // This gets all arguments given to a function call and adds them to
 // the accumulator in Go.
 static inline int _go_mrb_get_args_all(mrb_state *s) {
     mrb_value *argv;
     mrb_value block;
+    mrb_bool append;
     int argc, i, count;
 
-    count = mrb_get_args(s, "*&", &argv, &argc, &block);
+    count = mrb_get_args(s, "*&?", &argv, &argc, &block, &append);
+    if (count < 0 || errno != 0) {
+        return count;
+    }
+
     for (i = 0; i < argc; i++) {
-        goGetArgAppend(&argv[i]);
+        goGetArgAppend(argv[i]);
     }
 
-    if (!mrb_nil_p(block)) {
-        goGetArgAppend(&block);
+    if (append == FALSE || mrb_type(block) == MRB_TT_FALSE) {
+        return count;
     }
 
+    count++;
+    goGetArgAppend(block);
+
     return count;
 }
 
@@ -198,6 +214,10 @@ static inline void _go_enable_gc(mrb_state *m) {
   _go_set_gc(m, 0);
 }
 
+static inline int _go_get_max_funcall_args() {
+  return MRB_FUNCALL_ARGC_MAX;
+}
+
 // this function returns 1 if the value is dead, aka reaped or otherwise
 // terminated by the GC.
 static inline int _go_isdead(mrb_state *m, mrb_value o) {

mruby.go

@@ -147,23 +147,18 @@ func (m *Mrb) GetArgs() []*MrbValue {
 	getArgLock.Lock()
 	defer getArgLock.Unlock()
 
-	// If we haven't initialized the accumulator yet, do it. We then
-	// keep this slice cached around forever.
-	if getArgAccumulator == nil {
-		getArgAccumulator = make([]*C.mrb_value, 0, 5)
-	}
+	// Clear reset the accumulator to zero length
+	getArgAccumulator = make([]C.mrb_value, 0, C._go_get_max_funcall_args())
 
 	// Get all the arguments and put it into our accumulator
-	C._go_mrb_get_args_all(m.state)
+	count := C._go_mrb_get_args_all(m.state)
 
 	// Convert those all to values
-	values := make([]*MrbValue, len(getArgAccumulator))
-	for i, v := range getArgAccumulator {
-		values[i] = newValue(m.state, *v)
-	}
+	values := make([]*MrbValue, count)
 
-	// Clear reset the accumulator to zero length
-	getArgAccumulator = make([]*C.mrb_value, 0, 5)
+	for i := 0; i < int(count); i++ {
+		values[i] = newValue(m.state, getArgAccumulator[i])
+	}
 
 	return values
 }