Changeset 509

Timestamp:

01/14/11 19:46:57 (1 year ago)

Author:

Don Clugston

Message:

Improvement to Exception Chaining: When an exception is thrown and not caught before a previously thrown exception is caught, the later exception is chained to the previous one via the 'next' member of Throwable. The original exception must be caught, and this results in the capture of the entire chain.
Thrown objects derived from Error are treated differently. They bypass the normal chaining mechanism, such that the chain can only be caught by catching the first Error.
A new member of Error, 'bypassedException', points to the original exception (the head of the chain) if a bypass occurred, otherwise it is null.

Files:

• trunk/import/object.di (modified) (1 diff)
• trunk/src/object_.d (modified) (2 diffs)
• trunk/src/rt/deh.d (modified) (9 diffs)

trunk/import/object.di

@@ -326 +326 @@
-    this(string msg, Throwable next = null);
-    this(string msg, string file, size_t line, Throwable next = null);
+    Throwable   bypassedException;
-}
-

trunk/src/object_.d

@@ -1341 +1341 @@
-    {
-        super(msg, next);
+        bypassedException = null;
-    }
-
@@ -1346 +1347 @@
-    {
-        super(msg, file, line, next);
-
+
+
+
+
+
-}
-

trunk/src/rt/deh.d

@@ -351 +351 @@
- * exception, having its EXCEPTION_COLLATERAL bit set, or else will be caught.
- * If it is caught, a D exception object is created, containing all of the
-,
+.
- *
- * There are many subtleties in this design:
@@ -363 +363 @@
- * So we cannot store the collision information in the exception record.
- * (4) it's important that this list is thread-local.
- *
- * Every member of this list will suffer one of two fates:
- * (1) it will be caught successfully.
- *    In this case it is popped from the list.
- *    The previous head of the list, and the previous Throwable chain, are restored.
- * (2) it will collide with the previous exception.
- *    In this case, it gets added to the active Throwable chain, and then discarded.
- * (in which case its Throwable chain will be added to the Throwable chain of
- * the previous exception, and then this exception will be popped from the list).
- *
- * Note:
- */
-
@@ -424 +413 @@
-        DCatchBlock *pcb;
-        uint ncatches;              // number of catches in the current handler
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-        // walk through handler table, checking each handler
@@ -440 +437 @@
-                pci = cast(DCatchInfo *)(cast(ubyte *)handlerTable + phi.cioffset);
-                ncatches = pci.ncatches;
+                
-                for (i = 0; i < ncatches; i++)
-                {
-                    pcb = &pci.catch_block[i];
-                    // If there are collided unwinds, they must ALL match the translation code
-                    int match = 0;
-                    EXCEPTION_RECORD * er = exceptionRecord;
-
+
+
-                    {
-!ci
+er.ExceptionCode == STATUS_DIGITAL_MARS_D_EXCEPTION
-                        {
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                        }
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-                        }
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                    {
-
-
+
+
+
+
+
+
+
+
-                        // We need to add this exception to the list of in-flight
-                        // exceptions, in case something collides with it.
@@ -487 +500 @@
-                            originalException.ExceptionRecord = inflightExceptionList;
-                        }
-
-                        inflightExceptionList = exceptionRecord;
-
@@ -495 +507 @@
-                        // Call all the finally blocks skipped in this frame
-                        _d_local_unwind(handlerTable, frame, ndx, &searchCollisionExceptionHandler);
-
+
+
-                        frame.table_index = prev_ndx;  // we are out of this handler
-
+
-                        // Now create the D exception from the SEH exception record chain.
-                        // Note that since non-Throwables are throwable(!), the chain might be incomplete.
-                        EXCEPTION_RECORD * z = exceptionRecord;
-                        Throwable prev = null;
-
+
+
+
+
-                        {
-
-
-
-
-
+
+
+
+
-                            }
+                            Throwable a = w;
+                            while (a.next)
+                                a = a.next;
+                            a.next = prev;
+                            prev = w;
+                            if (!(z.ExceptionFlags & EXCEPTION_COLLATERAL))
+                                break;
-                            z = z.ExceptionRecord;
-                        }
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-                        // Pop the exception from the list of in-flight exceptions
-                        inflightExceptionList = z.ExceptionRecord;
@@ -568 +594 @@
-void _d_throwc(Object h)
-{
+    // @@@ TODO @@@ Signature should change: h will always be a Throwable.
+    
-    //printf("_d_throw(h = %p, &h = %p)\n", h, &h);
-    //printf("\tvptr = %p\n", *(void **)h);
@@ -578 +606 @@
-
-/***********************************
-Exception
-
-
-Object
-
-Object
+Throwable
+
+
+Throwable
+
+Throwable
-   // BUG: what if _d_newclass() throws an out of memory exception?
-
@@ -589 +617 @@
-        case STATUS_DIGITAL_MARS_D_EXCEPTION:
-            // Generated D exception
-Object
+Throwable
-            break;
-