cleanups and more test cases

src/lib/runtime/o_nfunc.c

@@ -0,0 +1,170 @@
+
+/* +--------------------------------------------------------------------------+
+** |                          _   _       _                                   |
+** |                         | \ | |     (_)                                  |
+** |                         |  \| | ___  _  __ _                             |
+** |                         | . ` |/ _ \| |/ _` |                            |
+** |                         | |\  | (_) | | (_| |                            |
+** |                         |_| \_|\___/| |\__,_|                            |
+** |                                    _/ |                                  |
+** |                                   |__/                                   |
+** +--------------------------------------------------------------------------+
+** | Copyright (c) 2022 Francesco Cozzuto <francesco.cozzuto@gmail.com>       |
+** +--------------------------------------------------------------------------+
+** | This file is part of The Noja Interpreter.                               |
+** |                                                                          |
+** | The Noja Interpreter is free software: you can redistribute it and/or    |
+** | modify it under the terms of the GNU General Public License as published |
+** | by the Free Software Foundation, either version 3 of the License, or (at |
+** | your option) any later version.                                          |
+** |                                                                          |
+** | The Noja Interpreter is distributed in the hope that it will be useful,  |
+** | but WITHOUT ANY WARRANTY; without even the implied warranty of           |
+** | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General |
+** | Public License for more details.                                         |
+** |                                                                          |
+** | You should have received a copy of the GNU General Public License along  |
+** | with The Noja Interpreter. If not, see <http://www.gnu.org/licenses/>.   |
+** +--------------------------------------------------------------------------+ 
+*/
+
+/*
+ * WHAT IS THIS FILE?
+ * This file implements an object that makes it possible
+ * to call native functions from within noja code.
+ *
+ */
+#include <assert.h>
+#include <stdlib.h>
+#include "../utils/defs.h"
+#include "../objects/objects.h"
+#include "runtime.h"
+
+typedef struct {
+	Object base;
+	Runtime *runtime;
+	int (*callback)(Runtime *runtime, Object **argv, unsigned int argc, Object **rets, unsigned int maxretc, Error *error);
+	int argc;
+} NativeFunctionObject;
+
+static int call(Object *self, Object **argv, unsigned int argc, Object **rets, unsigned int maxretc,  Heap *heap, Error *error)
+{
+	assert(self != NULL);
+	assert(heap != NULL);
+	assert(error != NULL);
+			
+	NativeFunctionObject *func = (NativeFunctionObject*) self;
+
+	// If the function isn't variadic, make sure
+	// the right amount of arguments is provided.
+
+	Object **argv2;
+	int 	 argc2;
+
+	int expected_argc = func->argc;
+
+	if(expected_argc < 0 || expected_argc == (int) argc)
+	{
+		// The function is variadic or the right 
+		// amount of arguments was provided.
+		argv2 = argv;
+		argc2 = argc;
+	}
+	else if(expected_argc < (int) argc)
+	{
+		// Nothing to be done. By using
+		// the right argc the additional
+		// arguments are ignored implicitly.
+		argv2 = argv;
+		argc2 = expected_argc;
+	}
+	else if(expected_argc > (int) argc)
+	{
+		// Some arguments are missing.
+		argv2 = malloc(sizeof(Object*) * expected_argc);
+		argc2 = expected_argc;
+			
+		if(argv2 == NULL)
+		{
+			Error_Report(error, 1, "No memory");
+			return -1;
+		}
+
+		// Copy the provided arguments.
+		for(int i = 0; i < (int) argc; i += 1)
+			argv2[i] = argv[i];
+
+		// Set the unspecified arguments to none.
+		for(int i = argc; i < expected_argc; i += 1)
+		{
+			argv2[i] = Object_NewNone(heap, error);
+
+			if(argv2[i] == NULL)
+			{
+				free(argv2);
+				return -1;
+			}
+		}
+	}
+	else UNREACHABLE;
+
+	assert(func->callback != NULL);
+	int retc = func->callback(func->runtime, argv2, argc2, rets, maxretc, error);
+
+	// NOTE: Since the callback may have executed some bytecode, a GC
+	//       cycle may have been triggered, therefore we must assume
+	//       every object reference that was locally saved is invalidated 
+	//       from here (the returned object is good tho).
+
+	if(argv2 != argv)
+		free(argv2);
+
+	return retc;
+}
+
+static TypeObject t_nfunc = {
+	.base = (Object) { .type = &t_type, .flags = Object_STATIC },
+	.name = "native function",
+	.size = sizeof (NativeFunctionObject),
+	.call = call,	
+};
+
+/* Symbol: Object_FromNativeFunction
+ *
+ *   Creates an object from a function pointer.
+ *
+ * Args:
+ *   - runtime: The reference to an instanciated Runtime. This must be
+ *              provided so that the callback can also access it.
+ *
+ *   - callback: The native function to be executed when this object
+ *               is called.
+ *
+ *   - argc: The number of arguments the function expects. If -1 is
+ *           provided, then the function is considered to be variadic.
+ *
+ *   - heap: The heap that will be used to allocate the object.
+ *           It can't be NULL.
+ *
+ *   - error: Output parameter where error information is stored.
+ *            It can't be NULL.
+ *
+ * Returns:
+ *   The newly created object. If an error occurred, NULL is returned
+ *   and information about the error is stored in the [error] argument.
+ */
+Object *Object_FromNativeFunction(Runtime *runtime, int (*callback)(Runtime*, Object**, unsigned int, Object**, unsigned int, Error*), int argc, Heap *heap, Error *error)
+{
+	assert(callback != NULL);
+
+	NativeFunctionObject *func = (NativeFunctionObject*) Heap_Malloc(heap, &t_nfunc, error);
+
+	if(func == NULL)
+		return NULL;
+
+	func->runtime = runtime;
+	func->callback = callback;
+	func->argc = argc;
+
+	return (Object*) func;
+}