Index: doc/working/exception/impl/exception.c
===================================================================
--- doc/working/exception/impl/exception.c	(revision 35ba584cb40f59438cfa1e47833b128d765ee2c9)
+++ doc/working/exception/impl/exception.c	(revision c529a2401708d5302e11e1dbc16486d61c0b73e9)
@@ -44,4 +44,26 @@
 	__throw_terminate(except);
 	// TODO: Default handler for resumption.
+}
+
+/* QUESTION: Could interupts interact with exception handling?
+Ex. could an context switch stop execution, and we get an exception when we
+come back? Is so resumption has to go:
++ create node (init next and handler)
++ prepare cleanup (add a cleanup hook with the ..._cleaup function)
+  also the cleanup has to be the next node, not just a pop from the list.
++ push node on the list (change the existing node)
+Which if an exception can come from anywhere, might just be required to ensure
+the list is valid.
+
+void __try_resume_setup(struct __try_resume_node * node,
+                        bool (*handler)(exception except) {
+	node->next = shared_stack.top_resume;
+	node->try_to_handle = handler;
+	shared_stack.top_resume = node;
+}*/
+
+// We have a single cleanup function
+void __try_resume_cleanup(struct __try_resume_node * node) {
+	shared_stack.top_resume = node->next;
 }
 
Index: doc/working/exception/impl/exception.h
===================================================================
--- doc/working/exception/impl/exception.h	(revision 35ba584cb40f59438cfa1e47833b128d765ee2c9)
+++ doc/working/exception/impl/exception.h	(revision c529a2401708d5302e11e1dbc16486d61c0b73e9)
@@ -6,5 +6,4 @@
 
 
-// These might be given simpler names and made public.
 void __throw_terminate(exception except) __attribute__((noreturn));
 void __rethrow_terminate(void) __attribute__((noreturn));
@@ -20,4 +19,6 @@
 };
 
+void __try_resume_cleanup(struct __try_resume_node * node);
+
 struct __cleanup_hook {};
 
@@ -27,7 +28,8 @@
  * and threads means that... well I'm going to get it working ignoring those
  * first, then get it working with concurrency.
+ * Eventually there should be some global name that just gets you the right
+ * data block.
  */
 struct shared_stack_t {
-	//struct lock lock;
 	struct __try_resume_node * top_resume;
 	struct __try_resume_node * current_resume;
Index: doc/working/exception/impl/test-main.c
===================================================================
--- doc/working/exception/impl/test-main.c	(revision 35ba584cb40f59438cfa1e47833b128d765ee2c9)
+++ doc/working/exception/impl/test-main.c	(revision c529a2401708d5302e11e1dbc16486d61c0b73e9)
@@ -6,13 +6,6 @@
 #include <stdbool.h>
 
-// Translation Helpers:
-#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)
-
+// Helps with manual translation. It may or may not get folded into the
+// header, that depends on how it interacts with concurancy.
 void __try_resume_node_new(struct __try_resume_node * node,
         _Bool (*handler)(exception except)) {
@@ -20,8 +13,4 @@
     shared_stack.top_resume = node;
     node->try_to_handle = handler;
-}
-
-void __try_resume_node_delete(struct __try_resume_node * node) {
-    shared_stack.top_resume = node->next;
 }
 
@@ -122,5 +111,5 @@
 		}
 		struct __try_resume_node node
-			__attribute__((cleanup(__try_resume_node_delete)));
+			__attribute__((cleanup(__try_resume_cleanup)));
 		__try_resume_node_new(&node, beta_handle1);
 		{
@@ -144,5 +133,5 @@
 		}
 		struct __try_resume_node node
-			__attribute__((cleanup(__try_resume_node_delete)));
+			__attribute__((cleanup(__try_resume_cleanup)));
 		__try_resume_node_new(&node, alpha_handle1);
 		{
@@ -260,5 +249,5 @@
 		}
 		struct __try_resume_node node
-			__attribute__((cleanup(__try_resume_node_delete)));
+			__attribute__((cleanup(__try_resume_cleanup)));
 		__try_resume_node_new(&node, fn_handle1);
 		{
@@ -279,5 +268,5 @@
 		}
 		struct __try_resume_node node
-			__attribute__((cleanup(__try_resume_node_delete)));
+			__attribute__((cleanup(__try_resume_cleanup)));
 		__try_resume_node_new(&node, fn_handle1);
 		{
@@ -349,5 +338,5 @@
 		}
 		struct __try_resume_node node
-			__attribute__((cleanup(__try_resume_node_delete)));
+			__attribute__((cleanup(__try_resume_cleanup)));
 		__try_resume_node_new(&node, reresume_handle1);
 		{
@@ -361,5 +350,5 @@
 			}
 			struct __try_resume_node node
-				__attribute__((cleanup(__try_resume_node_delete)));
+				__attribute__((cleanup(__try_resume_cleanup)));
 			__try_resume_node_new(&node, reresume_handle2);
 			{
@@ -409,5 +398,5 @@
 		}
 		struct __try_resume_node node
-			__attribute__((cleanup(__try_resume_node_delete)));
+			__attribute__((cleanup(__try_resume_cleanup)));
 		__try_resume_node_new(&node, foe_handle1);
 		{
@@ -456,5 +445,5 @@
 		}
 		struct __try_resume_node node
-			__attribute__((cleanup(__try_resume_node_delete)));
+			__attribute__((cleanup(__try_resume_cleanup)));
 		__try_resume_node_new(&node, fee_handle1);
 		{
Index: doc/working/exception/translate.c
===================================================================
--- doc/working/exception/translate.c	(revision 35ba584cb40f59438cfa1e47833b128d765ee2c9)
+++ doc/working/exception/translate.c	(revision c529a2401708d5302e11e1dbc16486d61c0b73e9)
@@ -17,4 +17,5 @@
 
 void __throw_terminate(exception except) __attribute__((noreturn));
+void __rethrow_terminate() __attribute__((noreturn));
 void __throw_resume(exception except);
 
@@ -27,4 +28,6 @@
 	bool (*try_to_handle)(exception except);
 };
+
+void __try_resume_cleanup(struct __try_resume_node * node);
 
 struct __cleanup_hook {};
@@ -147,5 +150,5 @@
 void try_resume() {
 	{
-		bool catch1(exception except) {
+		bool handle1(exception except) {
 			OtherException inner_except;
 			if (dynamic_cast__SomeException(except)) {
@@ -161,5 +164,5 @@
 		}
 		struct __try_resume_node data =
-			{.next = stack.except.top_resume, .try_to_handle = catch1};
+			{.next = stack.except.top_resume, .try_to_handle = handle1};
 		stack.except.top_resume = &data;
 
@@ -204,5 +207,48 @@
 
 
-// Combining the Above:
+// Resume + Finally:
+"Cforall"
+
+void try_resume_finally() {
+	try {
+		insideTry();
+	}
+	catch resume (SomeException) {
+		fiddleThing();
+	}
+	finally {
+		twiddleWidget();
+	}
+}
+
+"C"
+
+void try_resume_finally() {
+	{
+		void finally1() {
+			twiddleWidget();
+		}
+		bool handle1(exception except) {
+			if (dynamic_cast__SomeException(except)) {
+				fiddleThing();
+				return true;
+			} else {
+				return false;
+			}
+		}
+		struct __cleanup_hook generated_name
+			__attribute__((cleanup(finally1)));
+
+		struct __try_resume_node data =
+			{.next = stack.except.top_resume, .try_to_handle = handle1};
+		stack.except.top_resume = &data;
+
+		struct __cleanup_hook generated_name
+			__attribute__((cleanup(__try_resume_cleanup)));
+	}
+}
+
+
+// Terminate + Resume + Finally:
 "Cforall"
 
@@ -226,5 +272,17 @@
 void try_all() {
 	{
+		bool handle1() {
+			if (dynamic_cast__OtherException(except)) {
+				twiddleWidget();
+				return true;
+			}
+			return false;
+		}
 		void try1 () {
+			struct __try_resume_node generated_name =
+				{.next = stack.except.top_resume, .try_to_handle = handle1}
+				__attribute__((cleanup(__try_resume_cleanup)));
+			stack.except.top_resume = &data;
+
 			insideTry();
 		}
@@ -244,22 +302,8 @@
 			return 0;
 		}
-		bool catch2() {
-			if (dynamic_cast__OtherException(except)) {
-				twiddleWidget();
-				return true;
-			}
-			return false;
-		}
 		void finally1() {
-			// Finally, because of timing, also works for resume.
-			// However this might not actually be better in any way.
-			__try_resume_cleanup();
 
 			twiddleWidget();
 		}
-
-		struct __try_resume_node generated_name =
-			{.next = stack.except.top_resume, .try_to_handle = catch2};
-		stack.except.top_resume = &data;
 		struct __cleanup_hook generated_name
 			__attribute__((cleanup(finally1)));