code: func goMRBFuncCall(s *C.mrb_state, v C.mrb_value) C.mrb_value {
  	// Lookup the classes that we've registered methods for in this state
  	stateMethodTable.Mutex.Lock()
  	classTable := stateMethodTable.Map[s]
  	stateMethodTable.Mutex.Unlock()
  	if classTable == nil {
  		panic(fmt.Sprintf("func call from unknown state: %p", s))
  	}
  
  	// Get the call info, which we use to lookup the proc
  	ci := s.c.ci
  
  	// Lookup the class itself
  	classTable.Mutex.Lock()
  	methodTable := classTable.Map[ci.proc.target_class]
  	classTable.Mutex.Unlock()
  	if methodTable == nil {
  		panic(fmt.Sprintf("func call on unknown class"))
  	}
  
  	// Lookup the method
  	methodTable.Mutex.Lock()
  	f := methodTable.Map[ci.mid]
  	methodTable.Mutex.Unlock()
  	if f == nil {
  		panic(fmt.Sprintf("func call on unknown method"))
  	}
  
  	// Call the method to get our *Value
  	// TODO(mitchellh): reuse the Mrb instead of allocating every time
  	mrb := &Mrb{s}
  	result, exc := f(mrb, newValue(s, v))
  
  	if result == nil {
  		result = mrb.NilValue()
  	}
  
  	if exc != nil {
  		s.exc = C._go_mrb_getobj(exc.MrbValue(mrb).value)
  		return mrb.NilValue().value
  	}
  
  	return result.MrbValue(mrb).value
  }
docs: //export goMRBFuncCall