Index: doc/working/exception/impl/exception.c
===================================================================
--- doc/working/exception/impl/exception.c	(revision e4e9173c6c7fdb2b9d8cc160814b41074aaf2f7a)
+++ doc/working/exception/impl/exception.c	(revision 6a48cc99246032383e91b8f51147a1e389f1786b)
@@ -222,5 +222,4 @@
 						? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
 					shared_stack.current_handler_index = index;
-
 
 					// Based on the return value, check if we matched the exception
Index: doc/working/exception/impl/test-main.c
===================================================================
--- doc/working/exception/impl/test-main.c	(revision e4e9173c6c7fdb2b9d8cc160814b41074aaf2f7a)
+++ doc/working/exception/impl/test-main.c	(revision 6a48cc99246032383e91b8f51147a1e389f1786b)
@@ -9,4 +9,9 @@
 #define CLEANUP(function) \
 	struct __cleanup_hook __hidden_hook __attribute__((cleanup(function)))
+
+#define SET_UP_RESUME_NODE(handler_function) \
+	struct __try_resume_node node \
+		__attribute__((cleanup(__try_resume_node_delete))); \
+	__try_resume_node_new(&node, handler_function)
 
 void __try_resume_node_new(struct __try_resume_node * node,
@@ -153,7 +158,8 @@
 			printf("See you next time\n");
 		}
-		CLEANUP(farewell_finally1);
-		{
-			printf("jump out of farewell\n");
+		struct __cleanup_hook __hidden_hook
+			__attribute__((cleanup(farewell_finally1)));
+		{
+			printf("walk out of farewell\n");
 		}
 	}
@@ -162,5 +168,4 @@
 // Resume-to-Terminate Test:
 void fallback() {
-	//raii_t a = {"fallback function\n"};
 	{
 		void fallback_try1() {
@@ -186,4 +191,230 @@
 	}
 }
+
+// Terminate Throw New Exception:
+void terminate_swap() {
+	raii_t a = {"terminate_swap"};
+	{
+		void fn_try1() {
+			terminate(2);
+		}
+		void fn_catch1(int index, exception except) {
+			switch (index) {
+			case 1:
+				terminate(1);
+				break;
+			default:
+				printf("INVALID INDEX in terminate_swap: %d (%d)\n",
+					index, except);
+			}
+		}
+		int fn_match1(exception except) {
+			if (2 == except) {
+				return 1;
+			} else {
+				return 0;
+			}
+		}
+		__try_terminate(fn_try1, fn_catch1, fn_match1);
+	}
+}
+
+void terminate_swapped() {
+	raii_t a = {"terminate_swapped"};
+	{
+		void fn_try1() {
+			terminate_swap();
+		}
+		void fn_catch1(int index, exception except) {
+			switch (index) {
+			case 1:
+				printf("terminate_swapped caught exception 1\n");
+				break;
+			default:
+				printf("INVALID INDEX in terminate_swapped: %d (%d)\n",
+					index, except);
+			}
+		}
+		int fn_match1(exception except) {
+			if (1 == except) {
+				return 1;
+			} else {
+				return 0;
+			}
+		}
+		__try_terminate(fn_try1, fn_catch1, fn_match1);
+	}
+}
+
+// Resume Throw New Exception:
+void resume_swap() {
+	raii_t a = {"terminate_swap"};
+	{
+		bool fn_handle1(exception except) {
+			if (2 == except) {
+				resume(1);
+				return true;
+			} else {
+				return false;
+			}
+		}
+		struct __try_resume_node node
+			__attribute__((cleanup(__try_resume_node_delete)));
+		__try_resume_node_new(&node, fn_handle1);
+		{
+			resume(2);
+		}
+	}
+}
+
+void resume_swapped() {
+	{
+		bool fn_handle1(exception except) {
+			if (1 == except) {
+				printf("resume_swapped caught exception 1\n");
+				return true;
+			} else {
+				return false;
+			}
+		}
+		struct __try_resume_node node
+			__attribute__((cleanup(__try_resume_node_delete)));
+		__try_resume_node_new(&node, fn_handle1);
+		{
+			resume_swap();
+		}
+	}
+}
+
+// Terminate Rethrow:
+// I don't have an implementation for this.
+
+// Resume Rethrow:
+void reresume() {
+	{
+		bool reresume_handle1(exception except) {
+			if (1 == except) {
+				printf("reresume 1 caught exception 1\n");
+				return true;
+			} else {
+				return false;
+			}
+		}
+		struct __try_resume_node node
+			__attribute__((cleanup(__try_resume_node_delete)));
+		__try_resume_node_new(&node, reresume_handle1);
+		{
+			bool reresume_handle2(exception except) {
+				if (1 == except) {
+					printf("reresume 2 caught and rethrows exception 1\n");
+					return false;
+				} else {
+					return false;
+				}
+			}
+			struct __try_resume_node node
+				__attribute__((cleanup(__try_resume_node_delete)));
+			__try_resume_node_new(&node, reresume_handle2);
+			{
+				resume(1);
+			}
+		}
+	}
+}
+
+// Terminate-Resume interaction:
+void fum() {
+	// terminate block, call resume
+	{
+		void fum_try1() {
+			resume(3);
+		}
+		void fum_catch1(int index, exception except) {
+			switch (index) {
+			case 1:
+				printf("fum caught exception 3\n");
+				break;
+			default:
+				printf("INVALID INDEX in fum: %d (%d)\n", index, except);
+			}
+		}
+		int fum_match1(exception except) {
+			if (3 == except) {
+				return 1;
+			} else {
+				return 0;
+			}
+		}
+		__try_terminate(fum_try1, fum_catch1, fum_match1);
+	}
+}
+
+void foe() {
+	// resume block, call terminate
+	{
+		bool foe_handle1(exception except) {
+			if (3 == except) {
+				printf("foe caught exception 3\n");
+				return true;
+			} else {
+				return false;
+			}
+		}
+		struct __try_resume_node node
+			__attribute__((cleanup(__try_resume_node_delete)));
+		__try_resume_node_new(&node, foe_handle1);
+		{
+			terminate(3);
+		}
+	}
+}
+
+void fy() {
+	// terminate block calls fum, call foe
+	{
+		void fy_try1() {
+			foe();
+		}
+		void fy_catch1(int index, exception except) {
+			switch (index) {
+			case 1:
+				printf("fy caught exception 3\n");
+				fum();
+				break;
+			default:
+				printf("INVALID INDEX in fy: %d (%d)\n", index, except);
+			}
+		}
+		int fy_match1(exception except) {
+			if (3 == except) {
+				return 1;
+			} else {
+				return 0;
+			}
+		}
+		__try_terminate(fy_try1, fy_catch1, fy_match1);
+	}
+}
+
+void fee() {
+	// resume block, call fy
+	{
+		bool fee_handle1(exception except) {
+			if (3 == except) {
+				printf("fee caught exception 3\n");
+				return true;
+			} else {
+				return false;
+			}
+		}
+		struct __try_resume_node node
+			__attribute__((cleanup(__try_resume_node_delete)));
+		__try_resume_node_new(&node, fee_handle1);
+		{
+			fy();
+		}
+	}
+}
+
 
 // main: choose which tests to run
@@ -195,4 +426,8 @@
 	farewell(); printf("\n");
 	fallback(); printf("\n");
+	terminate_swapped(); printf("\n");
+	resume_swapped(); printf("\n");
+	reresume(); printf("\n");
+	fee(); printf("\n");
 	// Uncaught termination test.
 	terminate(7);
Index: doc/working/exception/translate.c
===================================================================
--- doc/working/exception/translate.c	(revision e4e9173c6c7fdb2b9d8cc160814b41074aaf2f7a)
+++ doc/working/exception/translate.c	(revision 6a48cc99246032383e91b8f51147a1e389f1786b)
@@ -237,5 +237,6 @@
 		}
 		void finally1() {
-			// (Finally, because of timing, also work for resume.)
+			// Finally, because of timing, also works for resume.
+			// However this might not actually be better in any way.
 			__try_resume_cleanup();