exceptions :check:

Author: dvtate

vm/async.hpp

@@ -16,17 +16,23 @@
  * tfw using functions instead of objects
  */
 
+// TODO should probably split into .hpp and .cpp
+
 /// Resumes execution of frame after async result received
 class AsyncResultMsg : public RTMessage {
 public:
 	Value ret;
 	std::shared_ptr<SyncCallStack> stack_target;
+	bool is_error;
 
-	AsyncResultMsg(std::shared_ptr<Value> ret, std::shared_ptr<SyncCallStack> stack_target):
-		ret(*ret), stack_target(std::move(stack_target)) {}
+	AsyncResultMsg(std::shared_ptr<Value> ret, std::shared_ptr<SyncCallStack> stack_target, bool is_error):
+		ret(*ret), stack_target(std::move(stack_target)), is_error(is_error) {}
 
 	void action(Runtime& rt) override {
-		stack_target->stack.back()->eval_stack.emplace_back(ret);
+		if (!this->is_error)
+			stack_target->stack.back()->eval_stack.emplace_back(ret);
+		else
+			stack_target->throw_error(ret);
 
 		// run it again bc should have been stopped when the Future was invoked
 		rt.set_active(this->stack_target);
@@ -42,6 +48,9 @@ class AsyncReturnNativeFn : public NativeFunction {
 	// store return value if frame_target not set
 	std::shared_ptr<Value> ret{nullptr};
 
+	// does ret store an error?
+	bool is_error{false};
+
 	// this gets set when user invokes the future functor
 	std::shared_ptr<SyncCallStack> stack_target{nullptr}; //
 
@@ -51,13 +60,15 @@ class AsyncReturnNativeFn : public NativeFunction {
 
 	void operator()(Frame& f) override {
 		this->ret = std::make_shared<Value>(f.eval_stack.back());
+		this->kill_thread(f);
+	}
+	void kill_thread(Frame& f) {
 		f.rt->kill_running();
 		if (this->stack_target == nullptr)
 			return;
 		this->stack_target->stack[0]->rt->recv_msg(
-				new AsyncResultMsg(this->ret, this->stack_target));
+			new AsyncResultMsg(this->ret, this->stack_target, is_error));
 	}
-
 	void mark() override {
 		if (ret)
 			GC::mark(*ret);
@@ -74,7 +85,11 @@ class AsyncFutureNativeFn : public NativeFunction {
 	void operator()(Frame& f) override {
 		this->ofn->stack_target = f.rt->running;
 		if (this->ofn->ret != nullptr) {
-			f.eval_stack.emplace_back(*this->ofn->ret);
+			if (this->ofn->is_error) {
+				f.rt->running->throw_error(*this->ofn->ret);
+			} else {
+				f.eval_stack.emplace_back(*this->ofn->ret);
+			}
 		} else {
 			f.rt->freeze_running();
 		}
@@ -85,6 +100,37 @@ class AsyncFutureNativeFn : public NativeFunction {
 	}
 };
 
+// By default errors thrown in async tasks will
+class AsyncDefaultCatchFn : public NativeFunction {
+	AsyncReturnNativeFn* ret;
+public:
+
+	explicit AsyncDefaultCatchFn(AsyncReturnNativeFn* ret): ret(ret) {}
+
+	void operator()(Frame& f) override {
+		// Copy the error
+		std::shared_ptr<Value> err = std::make_shared<Value>(f.eval_stack.back());
+		// Print a message
+		std::cout <<"WARNING: Uncaught Exception in async task:\n";
+
+		// Convert the error to a string and print it
+		(*std::get<ValueTypes::n_fn_t>(get_global_id((int64_t) GlobalId::STR).v))(f);
+		(*std::get<ValueTypes::n_fn_t>(get_global_id((int64_t) GlobalId::PRINT).v))(f);
+
+		// Put the error into the return closure and mark that it's an error
+		// This way the future will throw
+		this->ret->ret = err;
+		this->ret->is_error = true;
+
+		// Transfer control
+		this->ret->kill_thread(f);
+	}
+
+	void mark() override {
+		this->ret->mark();
+	}
+};
+
 /// typeof async(fn)
 class AsyncWrapperNativeFn : public NativeFunction {
 public:
@@ -119,6 +165,8 @@ class AsyncWrapperNativeFn : public NativeFunction {
 			auto rcs = f.rt->running;
 			f.rt->spawn_thread();
 			f.rt->running->stack.emplace_back(std::make_shared<Frame>(f.rt, c));
+			f.rt->running->stack.back()->error_handler = ::new(GC::alloc<Value>()) Value(
+					(NativeFunction*)::new(GC::alloc<AsyncDefaultCatchFn>()) AsyncDefaultCatchFn(ofn));
 		} else {
 			std::cerr <<"async only accepts closures for now :/\n";
 			// todo: typerror

vm/bc/fault_table.cpp

@@ -8,6 +8,7 @@
 
 #include "fault_table.hpp"
 
+#ifdef SCL_DEBUG
 static inline void debug_fault_table(FaultTable& ft) {
 	std::cout <<"\nRead Fault Table:\n- relocations: ";
 	for (auto& p : ft.relocations)
@@ -23,6 +24,7 @@ static inline void debug_fault_table(FaultTable& ft) {
 
 	std::cout <<std::endl <<std::endl;
 }
+#endif
 
 
 

vm/closure.cpp

@@ -2,6 +2,5 @@
 // Created by tate on 17-05-20.
 //
 
-
-#include "closure.hpp"
 #include "value.hpp"
+#include "closure.hpp"

vm/error.cpp

@@ -66,7 +66,8 @@ class ErrorTrace {
 		// ...
 
 		// For each item in the trace...
-		for (auto& p : this->trace) {
+		for (int i = this->trace.size() - 1; i >= 0; i--) {
+			auto& p = this->trace[i];
 			ret += "\tat ";
 			auto macro_start_pos = get_macro_start_pos(vm.literals, p.second);
 			auto pos = p.first + macro_start_pos;

vm/global_ids.cpp

@@ -98,7 +98,19 @@ class IfFn : public NativeFunction {
 // Any -> Str
 class StrFn : public NativeFunction {
 	void operator()(Frame& f) override {
-		f.eval_stack.back() = Value(f.eval_stack.back().to_string());
+		Value& v = f.eval_stack.back();
+
+		// if object has a __str method, call that
+		if (v.type() == ValueTypes::VType::OBJ) {
+			auto& o = *std::get<ValueTypes::obj_t*>(v.v);
+			if (o.find("__str") != o.end()) {
+				vm_util::invoke_value_sync(f, o["__str"], true);
+				return;
+			}
+		}
+
+		// Otherwise convert it to a string manually
+		f.eval_stack.back() = Value(v.to_string());
 	}
 
 	void mark() override {}
@@ -257,7 +269,9 @@ class CopyFn : public NativeFunction {
 // Throw an error
 class ThrowFn : public NativeFunction {
 	void operator()(Frame& f) override {
-
+		Value e = f.eval_stack.back();
+		f.eval_stack.pop_back();
+		f.rt->running->throw_error(e);
 	}
 	void mark() override {}
 };

vm/global_ids.hpp

@@ -7,6 +7,24 @@
 
 #include <cinttypes>
 
+
+// Using these internally too
+enum class GlobalId : int64_t {
+	EMPTY = 0,
+	PRINT = 1,
+	INPUT = 2,
+	IF = 3,
+	STR = 4,
+	NUM = 5,
+	VARS = 6,
+	ASYNC = 7,
+	IMPORT = 8,
+	SIZE = 9,
+	COPY = 10,
+	ERROR = 11,
+	THROW = 12,
+};
+
 class Value;
 const Value& get_global_id(int64_t id);
 constexpr unsigned short global_ids_count = 12;

vm/vm.cpp

@@ -11,18 +11,56 @@
 #include "value.hpp"
 #include "bc/exec_bc_instr.hpp"
 #include "global_ids.hpp"
+#include "operators/internal_tools.hpp"
+
+
+inline void fatal_exception(Frame& f) {
+	std::cout <<"Fatal Exception:\n";
+	(*std::get<ValueTypes::n_fn_t>(get_global_id((int64_t) GlobalId::STR).v))(f);
+	(*std::get<ValueTypes::n_fn_t>(get_global_id((int64_t) GlobalId::PRINT).v))(f);
+	exit(1);
+}
+
 
 void SyncCallStack::mark() {
 	for (auto& f : this->stack)
 		f->mark();
 }
 
-class ExitProgramReturn : public virtual NativeFunction {
+void SyncCallStack::throw_error(Value thrown)  {
+	for (int i = this->stack.size() - 1; i >= 0; i--) {
+		auto* h = this->stack[i]->error_handler;
+		if (h != nullptr) {
+			// Pop the stack back one level behind that of the handler
+			// Replace the bad function call(stack) with the error handler
+			// Note that this destroys back until the i-1-th frame
+			// Note that the position of that frame will be the call that caused the error
+
+			std::shared_ptr<Frame> f;
+			if (i != 0) {
+				this->stack.resize(i);
+				f = this->stack.back();
+			} else {
+				this->stack.resize(1);
+				f = this->stack.back();
+//				f->pos = f->closure.body->size();
+			}
+
+			f->eval_stack.emplace_back(thrown);
+			vm_util::invoke_value_sync(*f, *h, true);
+			return;
+		}
+	}
+
+	// No handlers, die
+	this->stack.back()->eval_stack.emplace_back(thrown);
+	fatal_exception(*this->stack.back());
+}
+
+class ExitProgramReturn : public NativeFunction {
 public:
 
 	void operator()(Frame& f) override {
-		// TODO: convert stack.back() to int and return it
-		// f.eval_stack.back();
 		if (std::holds_alternative<Value::int_t>(f.eval_stack.back().v))
 			exit(std::get<Value::int_t>(f.eval_stack.back().v));
 		else
@@ -32,6 +70,12 @@ class ExitProgramReturn : public virtual NativeFunction {
 };
 static_assert(sizeof(ExitProgramReturn) == sizeof(NativeFunction), "Should be same size for convenience");
 
+//class FatalExceptionHandler : public NativeFunction {
+//public:
+//	void operator()(Frame& f) override {
+//		fatal_exception(f, f.eval_stack.back());
+//	}
+//};
 
 VM::VM(std::vector<Literal> lit_header, const std::vector<std::string>& argv, std::istream& bytecode_source):
 	bytecode_source(bytecode_source)
@@ -53,7 +97,6 @@ VM::VM(std::vector<Literal> lit_header, const std::vector<std::string>& argv, st
 	// capture global variables
 	for (const int64_t id : entry.capture_ids) {
 		SCL_DEBUG_MSG("capture global id # " << id << std::endl);
-//		std::cout <<"cid" <<id <<std::endl;
 		main.vars[id] = ::new(GC::alloc<Value>()) Value(get_global_id(id));
 	}
 
@@ -68,9 +111,6 @@ VM::VM(std::vector<Literal> lit_header, const std::vector<std::string>& argv, st
 	// TODO: capture command-line args
 	Value argv_list{std::string("cmd args coming soon")};
 	main.vars[main.i_id] = ::new(GC::alloc<Value>()) Value(argv_list);
-
-	// declare locals
-//	main.declare_empty_locals(entry.decl_ids);
 }
 
 void VM::run() {

vm/vm.hpp

@@ -40,7 +40,14 @@ class RTMessage {
 class SyncCallStack  {
 public:
 	std::vector<std::shared_ptr<Frame>> stack;
+
+	SyncCallStack() {
+		this->stack.reserve(32);
+	}
+
 	void mark();
+
+	void throw_error(Value thrown);
 };