Merge branch 'release/0.41.6'

build/ultratiny.flx

@@ -109,8 +109,6 @@ class B : A
 }
 
 
-
-
 @entry fn main()
 {
 	fn foo(x: int = 3, y: int = 7) -> int => x * y

makefile

@@ -46,7 +46,7 @@ CFLAGS			+= -std=c11 -O0 -g -c -Wall -fno-omit-frame-pointer -Wno-overlength-str
 
 LDFLAGS			+= $(SANITISE)
 
-FLXFLAGS		+= -sysroot $(SYSROOT)
+FLXFLAGS		+= -sysroot $(SYSROOT) --ffi-escape
 
 
 SUPERTINYBIN	:= build/supertiny

source/fir/interp/interpreter.cpp

@@ -9,6 +9,7 @@
 #include "ir/function.h"
 #include "ir/instruction.h"
 
+#include "frontend.h"
 #include "gluecode.h"
 #include "platform.h"
 
@@ -918,11 +919,32 @@ namespace interp
 
 
 
+	static void complainAboutFFIEscape(void* fnptr, fir::Type* fnty, const std::string& name)
+	{
+		if(frontend::getCanFFIEscape())
+			return;
 
+		BareError* e = 0;
+		if(name.empty())
+		{
+			e = BareError::make("interp: cannot call external function (name unavailable; symbol address %p, function type '%s')",
+					fnptr, fnty->str());
+		}
+		else
+		{
+			e = BareError::make("interp: cannot call external function '%s'", name);
+		}
+
+		e->append(BareError::make(MsgType::Note, "to call external functions (ffi), pass '--ffi-escape' as a command-line flag"));
+		e->postAndQuit();
+	}
 
 
-	static interp::Value runFunctionWithLibFFI(InterpState* is, void* fnptr, fir::FunctionType* fnty, const std::vector<interp::Value>& args)
+	static interp::Value runFunctionWithLibFFI(InterpState* is, void* fnptr, fir::FunctionType* fnty, const std::vector<interp::Value>& args,
+		const std::string& nameIfAvailable = "")
 	{
+		complainAboutFFIEscape(fnptr, fnty, nameIfAvailable);
+
 		// we are assuming the values in 'args' are correct!
 		ffi_type** arg_types = new ffi_type*[args.size()];
 		{
@@ -998,15 +1020,15 @@ namespace interp
 		void* fnptr = platform::compiler::getSymbol(fn->getName().str());
 		if(!fnptr) error("interp: failed to find symbol named '%s'\n", fn->getName().str());
 
-		return runFunctionWithLibFFI(is, fnptr, fn->getType(), args);
+		return runFunctionWithLibFFI(is, fnptr, fn->getType(), args, /* name: */ fn->getName().str());
 	}
 
 	static interp::Value runFunctionWithLibFFI(InterpState* is, const interp::Function& fn, const std::vector<interp::Value>& args)
 	{
 		void* fnptr = platform::compiler::getSymbol(fn.func->getName().str());
 		if(!fnptr) error("interp: failed to find symbol named '%s'\n", fn.func->getName().str());
 
-		return runFunctionWithLibFFI(is, fnptr, fn.func->getType(), args);
+		return runFunctionWithLibFFI(is, fnptr, fn.func->getType(), args, /* name: */ fn.extFuncName);
 	}
 
 
@@ -1134,7 +1156,8 @@ namespace interp
 						else
 							error("interp: call to function pointer with invalid type '%s'", targ.type);
 
-						is->stackFrames.back().values[res.callResultValue] = runFunctionWithLibFFI(is, (void*) ptr, fnty, res.callArguments);
+						is->stackFrames.back().values[res.callResultValue] = runFunctionWithLibFFI(is, (void*) ptr, fnty, res.callArguments,
+							/* name: */ res.callTarget->extFuncName);
 						i += 1;
 					}
 				} break;

source/frontend/arguments.cpp

@@ -32,10 +32,11 @@
 #define ARG_SHOW_CLANG_OUTPUT                   "-show-clang"
 #define ARG_SYSROOT                             "-sysroot"
 #define ARG_TARGET                              "-target"
-#define ARG_FREESTANDING                        "-ffreestanding"
-#define ARG_NOSTDLIB                            "-nostdlib"
-#define ARG_NO_RUNTIME_CHECKS                   "-no-runtime-checks"
-#define ARG_NO_RUNTIME_ERROR_STRINGS            "-no-runtime-error-strings"
+#define ARG_FFI_ESCAPE                          "--ffi-escape"
+#define ARG_FREESTANDING                        "--freestanding"
+#define ARG_NOSTDLIB                            "--nostdlib"
+#define ARG_NO_RUNTIME_CHECKS                   "--no-runtime-checks"
+#define ARG_NO_RUNTIME_ERROR_STRINGS            "--no-runtime-error-strings"
 
 // for internal use!
 #define ARG_ABORT_ON_ERROR                      "-abort-on-error"
@@ -72,6 +73,7 @@ static void setupMap()
 
 	list.push_back({ ARG_FREESTANDING, "generate a freestanding executable or object file" });
 	list.push_back({ ARG_NOSTDLIB, "do not link with default libraries (libc/libm/msvcrt)" });
+	list.push_back({ ARG_FFI_ESCAPE, "allow calling external functions (eg. libc) at compile-time" });
 
 	list.push_back({ ARG_POSINDEPENDENT, "generate position independent code" });
 	list.push_back({ ARG_PRINT_FIR, "print the FlaxIR before compilation" });
@@ -171,6 +173,7 @@ namespace frontend
 	bool _noStandardLibraries = false;
 	bool _noAutoGlobalConstructor = false;
 	bool _abortOnError = false;
+	bool _ffiEscape = false;
 
 	bool _noRuntimeChecks = false;
 	bool _noRuntimeErrorStrings = false;
@@ -223,6 +226,10 @@ namespace frontend
 		return _abortOnError;
 	}
 
+	bool getCanFFIEscape()
+	{
+		return _ffiEscape;
+	}
 
 	bool getPrintFIR()
 	{
@@ -436,6 +443,10 @@ namespace frontend
 				{
 					frontend::_noRuntimeErrorStrings = true;
 				}
+				else if(!strcmp(argv[i], ARG_FFI_ESCAPE))
+				{
+					frontend::_ffiEscape = true;
+				}
 				else if(!strcmp(argv[i], ARG_BACKEND))
 				{
 					if(i != argc - 1)

source/include/frontend.h

@@ -48,6 +48,7 @@ namespace frontend
 	bool getPrintProfileStats();
 	bool getAbortOnError();
 
+	bool getCanFFIEscape();
 	bool getIsFreestanding();
 	bool getIsNoStandardLibraries();
 	bool getIsPositionIndependent();

source/include/utils.h

@@ -195,10 +195,8 @@ namespace util
 	template <typename T, typename U>
 	std::vector<std::pair<T, U>> zip(const std::vector<T>& a, const std::vector<U>& b)
 	{
-		assert(a.size() == b.size());
-
 		std::vector<std::pair<T, U>> ret;
-		for(size_t i = 0; i < a.size(); i++)
+		for(size_t i = 0; i < std::min(a.size(), b.size()); i++)
 			ret.push_back({ a[i], b[i] });
 
 		return ret;

source/typecheck/classes.cpp

@@ -48,6 +48,10 @@ TCResult ast::ClassDefn::generateDeclaration(sst::TypecheckState* fs, fir::Type*
 	auto cls = fir::ClassType::createWithoutBody(defn->id);
 	defn->type = cls;
 
+
+	// why do we do this when generating the declaration instead of only when we typecheck?
+	// as it currently stands, this means that our base class + any traits must appear before
+	// this class definition in the source code, which is kinda dumb.
 	if(this->bases.size() > 0)
 	{
 		auto base = fs->convertParserTypeToFIR(this->bases[0]);