Changeset 509

Timestamp:

01/15/11 00:46:57 (14 years 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) (1 diff)
• trunk/src/rt/deh.d (modified) (3 diffs)

trunk/import/object.di

@@ -318 +318 @@
-{
-    this(string msg, Throwable next = null);
-    this(string msg, string file, size_t line, Throwable next = null);
-}
-
-
-class Error : Throwable
-{
-    this(string msg, Throwable next = null);
-    this(string msg, string file, size_t line, Throwable next = null);
+    Throwable   bypassedException;
-}
-
-extern (C)
-{
-    // from druntime/src/compiler/dmd/aaA.d
-
-    size_t _aaLen(void* p);
-    void*  _aaGet(void** pp, TypeInfo keyti, size_t valuesize, ...);
-    void*  _aaGetRvalue(void* p, TypeInfo keyti, size_t valuesize, ...);
-    void*  _aaIn(void* p, TypeInfo keyti);

trunk/src/object_.d

@@ -1333 +1333 @@
-        super(msg, file, line, next);
-    }
-}
-
-
-class Error : Throwable
-{
-    this(string msg, Throwable next = null)
-    {
-        super(msg, next);
+        bypassedException = null;
-    }
-
-    this(string msg, string file, size_t line, Throwable next = null)
-    {
-        super(msg, file, line, next);
-
+
+
+
+
+
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-// ModuleInfo
-///////////////////////////////////////////////////////////////////////////////
-
-
-enum
-{

trunk/src/rt/deh.d

@@ -343 +343 @@
- * The 'ExceptionRecord' member of the EXCEPTION_RECORD struct is used to
- * store a link to the earlier member on the list.
- * All exceptions which have found their catch handler are linked into this
- * list. The exceptions which collided are marked by setting a bit in the
- * ExceptionFlags. I've called this bit EXCEPTION_COLLATERAL. It has never
- * been used by Microsoft.
- *
- * Every member of the list will either eventually collide with the next earlier
- * 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:
- * (1) The exception records are all on the stack, so it's not possible to
- * modify them very much. In particular, we have very little choice about how
- * unwinding works, so we have to leave all the exception records essentially
- * intact.
- * (2) The length of an exception record is not constant. System exceptions
- * are shorter than D exceptions, for example.
- * (3) System exceptions don't have any space for a pointer to a D object.
- * 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:
- */
-
-EXCEPTION_RECORD * inflightExceptionList = null;
-
-/***********************************
- * Find the first non-collateral exception in the list. If the last
- * entry in the list has the EXCEPTION_COLLATERAL bit set, it means
- * that this fragment will collide with the top exception in the
- * inflightException list.
- */
@@ -416 +405 @@
-         _d_local_unwind(handlerTable, frame, -1, &unwindCollisionExceptionHandler);
-    }
-    else
-    {
-        // Jump to catch block if matching one is found
-        int ndx,prev_ndx,i;
-        DHandlerInfo *phi;
-        DCatchInfo *pci;
-        DCatchBlock *pcb;
-        uint ncatches;              // number of catches in the current handler
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-        // walk through handler table, checking each handler
-        // with an index smaller than the current table_index
-        for (ndx = frame.table_index; ndx != -1; ndx = prev_ndx)
-        {
-            phi = &handlerTable.handler_info[ndx];
-            prev_ndx = phi.prev_index;
-            if (phi.cioffset)
-            {
-                // this is a catch handler (no finally)
-                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.
-                        EXCEPTION_RECORD * originalException = skipCollateralExceptions(exceptionRecord);
-                        if (originalException.ExceptionRecord is null
-                            && !(exceptionRecord is inflightExceptionList))
-                        {
-                            originalException.ExceptionRecord = inflightExceptionList;
-                        }
-
-                        inflightExceptionList = exceptionRecord;
-
-                        // Have system call all finally blocks in intervening frames
-                        _d_global_unwind(frame, exceptionRecord);
-
-                        // 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;
-
-                        int regebp;
-                        // Initialize catch variable
-                        regebp = cast(int)&frame.ebp;              // EBP for this frame
-                        *cast(Object *)(regebp + (pcb.bpoffset)) = pti;
-
-                        // Jump to catch block. Does not return.
-                        {
@@ -560 +586 @@
-    *exceptionObject = _d_translate_se_to_d_exception(eptrs.ExceptionRecord);
-    return retval;
-}
-
-/***********************************
- * Throw a D object.
- */
-extern(C)
-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);
-    _d_createTrace(h);
-    //_d_setUnhandled(h);
-    RaiseException(STATUS_DIGITAL_MARS_D_EXCEPTION,
-                   EXCEPTION_NONCONTINUABLE,
-                   1, cast(void *)&h);
-}
-
-/***********************************
-Exception
-
-
-Object
-
-Object
+Throwable
+
+
+Throwable
+
+Throwable
-   // BUG: what if _d_newclass() throws an out of memory exception?
-
-    switch (exceptionRecord.ExceptionCode) {
-        case STATUS_DIGITAL_MARS_D_EXCEPTION:
-            // Generated D exception
-Object
+Throwable
-            break;
-
-        case STATUS_INTEGER_DIVIDE_BY_ZERO:
-            pti = new Error("Integer Divide by Zero");
-            break;
-
-        case STATUS_FLOAT_DIVIDE_BY_ZERO:
-            pti = new Error("Float Divide by Zero");
-            break;
-