// Tests for providing new default operations.

#include <fstream.hfa>
#include <string.h>

exception log_message {
	char * msg;
};

// Manually define the virtual table and helper functions.
void copy(log_message * this, log_message * that) {
	*this = *that;
}

const char * msg(log_message * this) {
	return this->msg;
}

const struct log_message_vtable log_vt @= {
	.__cfavir_typeid = &__cfatid_log_message,
	.size = sizeof(struct log_message),
	.copy = copy,
	.^?{} = ^?{},
	.msg = msg,
};

// Logging messages don't have to be handled.
void defaultResumptionHandler(log_message &) {}

// And should never be used to terminate computation.
void defaultTerminationHandler(log_message &) = void;

void log_test(void) {
	// We can catch log:
	try {
		throwResume (log_message){&log_vt, "Should be printed.\n"};
	} catchResume (log_message * this) {
		sout | this->virtual_table->msg(this) | nonl;
	}
	// But we don't have to:
	throwResume (log_message){&log_vt, "Should not be printed.\n"};
}

// I don't have a good use case for doing the same with termination.
exception jump {};
void defaultTerminationHandler(jump &) {
	sout | "jump default handler.";
}

vtable(jump) jump_vt;

void jump_test(void) {
	try {
		throw (jump){&jump_vt};
	} catch (jump * this) {
		sout | "jump catch handler.";
	}
	throw (jump){&jump_vt};
}

exception first {};
vtable(first) first_vt;

exception unhandled_exception {};
vtable(unhandled_exception) unhandled_vt;

void unhandled_test(void) {
	forall(T &, V & | is_exception(T, V))
	void defaultTerminationHandler(T &) {
		throw (unhandled_exception){&unhandled_vt};
	}
	void defaultTerminationHandler(unhandled_exception &) {
		abort();
	}
	try {
		throw (first){&first_vt};
	} catch (unhandled_exception * t) {
		sout | "Catch unhandled_exception.";
	}
}

exception second {};
vtable(second) second_vt;

void cross_test(void) {
	void defaultTerminationHandler(first &) {
		sout | "cross terminate default";
		throw (second){&second_vt};
	}
	void defaultResumptionHandler(first &) {
		sout | "cross resume default";
		throwResume (second){&second_vt};
	}
	try {
		sout | "cross terminate throw";
		throw (first){&first_vt};
	} catch (second *) {
		sout | "cross terminate catch";
	}
	try {
		sout | "cross resume throw";
		throwResume (first){&first_vt};
	} catchResume (second *) {
		sout | "cross resume catch";
	}
}

int main(int argc, char * argv[]) {
	log_test();
	jump_test();
	unhandled_test();
	cross_test();
}