Implemented Await and LoadFromMemory in Go port, add tests and make it work properly.

Author: viferga

source/metacall/include/metacall/metacall.h

@@ -61,6 +61,15 @@ struct metacall_initialize_configuration_type
 				   // can use a weak API in order to implement this successfully
 };
 
+typedef void *(*metacall_await_callback)(void *, void *);
+
+typedef struct metacall_await_callbacks_type
+{
+	metacall_await_callback resolve;
+	metacall_await_callback reject;
+
+} metacall_await_callbacks;
+
 /* -- Global Variables -- */
 
 METACALL_API extern void *metacall_null_args[1];
@@ -881,6 +890,30 @@ METACALL_API void *metacallfv_await(void *func, void *args[], void *(*resolve_ca
 */
 METACALL_API void *metacallfv_await_s(void *func, void *args[], size_t size, void *(*resolve_callback)(void *, void *), void *(*reject_callback)(void *, void *), void *data);
 
+/**
+*  @brief
+*    Call an asynchronous function anonymously by value array @args and function @func (offered without function pointers for languages without support to function pointers)
+*
+*  @param[in] func
+*    Reference to function to be called
+*
+*  @param[in] args
+*    Array of pointers to values
+*
+*  @param[in] size
+*    Number of elements of the array @args
+*
+*  @param[in] cb
+*    Pointer to struct containing the function pointers to reject and resolve that will be executed when task completion or error
+*
+*  @param[in] data
+*    Pointer to a context that will act as a closure for the chain
+*
+*  @return
+*    Pointer to value containing the result of the call returned by @resolve_callback or @reject_callback wrapped in a future
+*/
+METACALL_API void *metacallfv_await_struct_s(void *func, void *args[], size_t size, metacall_await_callbacks cb, void *data);
+
 /**
 *  @brief
 *    Call an asynchronous function anonymously by value map (@keys -> @values) and function @func

source/metacall/source/metacall.c

@@ -1421,6 +1421,11 @@ void *metacallfv_await_s(void *func, void *args[], size_t size, void *(*resolve_
 	return function_await(func, args, size, resolve_callback, reject_callback, data);
 }
 
+void *metacallfv_await_struct_s(void *func, void *args[], size_t size, metacall_await_callbacks cb, void *data)
+{
+	return function_await(func, args, size, cb.resolve, cb.reject, data);
+}
+
 void *metacallfmv_await(void *func, void *keys[], void *values[], void *(*resolve_callback)(void *, void *), void *(*reject_callback)(void *, void *), void *data)
 {
 	function f = (function)func;

source/ports/go_port/source/README.md

@@ -6,7 +6,17 @@ This project implements a wrapper of MetaCall API for Go.
 
 ## Examples
 
+`test.ts`:
+```ts
+export function concat(left: string, right: string): string {
+        return left + right;
+}
+```
+
+`main.go`:
 ```go
+package main
+
 import (
 	metacall "github.com/metacall/core/source/ports/go_port/source"
 	"os"
@@ -21,14 +31,14 @@ func main() {
 
 	defer metacall.Destroy()
 
-	scripts := []string{ "test.mock" }
+	scripts := []string{ "test.ts" }
 
-	if err := metacall.LoadFromFile("mock", scripts); err != nil {
+	if err := metacall.LoadFromFile("ts", scripts); err != nil {
 		fmt.Println(err)
 		return
 	}
 
-	ret, err := metacall.Call("three_str", "e", "f", "g")
+	ret, err := metacall.Call("concat", "hello", "world")
 
 	if err != nil {
 		fmt.Println(err)

source/ports/go_port/source/await.go

@@ -0,0 +1,35 @@
+/*
+ *	MetaCall Go Port by Parra Studios
+ *	A frontend for Go language bindings in MetaCall.
+ *
+ *	Copyright (C) 2016 - 2021 Vicente Eduardo Ferrer Garcia <[email protected]>
+ *
+ *	Licensed under the Apache License, Version 2.0 (the "License");
+ *	you may not use this file except in compliance with the License.
+ *	You may obtain a copy of the License at
+ *
+ *		http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *	Unless required by applicable law or agreed to in writing, software
+ *	distributed under the License is distributed on an "AS IS" BASIS,
+ *	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *	See the License for the specific language governing permissions and
+ *	limitations under the License.
+ *
+ */
+
+package metacall
+
+/*
+extern void *goResolve(void *, void *);
+extern void *goReject(void *, void *);
+
+void *resolveCgo(void *v, void *ctx) {
+	return goResolve(v, ctx);
+}
+
+void *rejectCgo(void *v, void *ctx) {
+	return goReject(v, ctx);
+}
+*/
+import "C"