Index: doc/working/exception/impl/exception.c
===================================================================
--- doc/working/exception/impl/exception.c	(revision 78372fd040519faa5dc84429b8be7e3337b10029)
+++ doc/working/exception/impl/exception.c	(revision 35ba584cb40f59438cfa1e47833b128d765ee2c9)
@@ -73,5 +73,4 @@
 }
 
-// Example throw routine
 void __throw_terminate( int val ) {
 	// Store the current exception
@@ -107,4 +106,12 @@
 	printf("UNWIND ERROR %d after raise exception\n", ret);
 	abort();
+}
+
+// Nesting this the other way would probably be faster.
+void __rethrow_terminate(void) {
+	// DEBUG
+	printf("Rethrowing termination exception\n");
+
+	__throw_terminate(shared_stack.current_exception);
 }
 
Index: doc/working/exception/impl/exception.h
===================================================================
--- doc/working/exception/impl/exception.h	(revision 78372fd040519faa5dc84429b8be7e3337b10029)
+++ doc/working/exception/impl/exception.h	(revision 35ba584cb40f59438cfa1e47833b128d765ee2c9)
@@ -8,4 +8,5 @@
 // These might be given simpler names and made public.
 void __throw_terminate(exception except) __attribute__((noreturn));
+void __rethrow_terminate(void) __attribute__((noreturn));
 void __throw_resume(exception except);
 
@@ -22,5 +23,9 @@
 
 
-// When I have it working in a single threaded environment.
+
+/* The following code is temperary. How exceptions interact with coroutines
+ * and threads means that... well I'm going to get it working ignoring those
+ * first, then get it working with concurrency.
+ */
 struct shared_stack_t {
 	//struct lock lock;
Index: doc/working/exception/impl/test-main.c
===================================================================
--- doc/working/exception/impl/test-main.c	(revision 78372fd040519faa5dc84429b8be7e3337b10029)
+++ doc/working/exception/impl/test-main.c	(revision 35ba584cb40f59438cfa1e47833b128d765ee2c9)
@@ -289,4 +289,51 @@
 // Terminate Rethrow:
 // I don't have an implementation for this.
+void reterminate() {
+	{
+		void fn_try1() {
+			void fn_try2() {
+				terminate(1);
+			}
+			void fn_catch2(int index, exception except) {
+				switch (index) {
+				case 1:
+					printf("reterminate 2 caught and "
+					       "will rethrow exception 1\n");
+					__rethrow_terminate();
+					break;
+				default:
+					printf("INVALID INDEX in reterminate 2: %d (%d)\n",
+						index, except);
+				}
+			}
+			int fn_match2(exception except) {
+				if (1 == except) {
+					return 1;
+				} else {
+					return 0;
+				}
+			}
+			__try_terminate(fn_try2, fn_catch2, fn_match2);
+		}
+		void fn_catch1(int index, exception except) {
+			switch (index) {
+			case 1:
+				printf("reterminate 1 caught exception 1\n");
+				break;
+			default:
+				printf("INVALID INDEX in reterminate 1: %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 Rethrow:
@@ -428,4 +475,5 @@
 	terminate_swapped(); printf("\n");
 	resume_swapped(); printf("\n");
+	reterminate(); printf("\n");
 	reresume(); printf("\n");
 	fee(); printf("\n");