]> granicus.if.org Git - python/commitdiff
Merged revisions 71906 via svnmerge from
authorThomas Heller <theller@ctypes.org>
Sat, 25 Apr 2009 16:49:23 +0000 (16:49 +0000)
committerThomas Heller <theller@ctypes.org>
Sat, 25 Apr 2009 16:49:23 +0000 (16:49 +0000)
svn+ssh://pythondev@svn.python.org/python/trunk

........
  r71906 | thomas.heller | 2009-04-25 18:37:18 +0200 (Sa, 25 Apr 2009) | 1 line

  Issue #5078: Avoid redundant call to FormatError()
........

Modules/_ctypes/callproc.c

index 6ff7850d589dafa07edde1c898b6eb8b44aba159..3300cdedd0f52626448a948f11294e362822aeed 100644 (file)
@@ -229,154 +229,150 @@ static WCHAR *FormatError(DWORD code)
 }
 
 #ifndef DONT_USE_SEH
-void SetException(DWORD code, EXCEPTION_RECORD *pr)
+static void SetException(DWORD code, EXCEPTION_RECORD *pr)
 {
-       WCHAR *lpMsgBuf;
-       lpMsgBuf = FormatError(code);
-       if(lpMsgBuf) {
-               PyErr_SetFromWindowsErr(code);
-               LocalFree(lpMsgBuf);
-       } else {
-               switch (code) {
-               case EXCEPTION_ACCESS_VIOLATION:
-                       /* The thread attempted to read from or write
-                          to a virtual address for which it does not
-                          have the appropriate access. */
-                       if (pr->ExceptionInformation[0] == 0)
-                               PyErr_Format(PyExc_WindowsError,
-                                            "exception: access violation reading %p",
-                                            pr->ExceptionInformation[1]);
-                       else
-                               PyErr_Format(PyExc_WindowsError,
-                                            "exception: access violation writing %p",
-                                            pr->ExceptionInformation[1]);
-                       break;
-               case EXCEPTION_BREAKPOINT:
-                       /* A breakpoint was encountered. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: breakpoint encountered");
-                       break;
-                       
-               case EXCEPTION_DATATYPE_MISALIGNMENT:
-                       /* The thread attempted to read or write data that is
-                          misaligned on hardware that does not provide
-                          alignment. For example, 16-bit values must be
-                          aligned on 2-byte boundaries, 32-bit values on
-                          4-byte boundaries, and so on. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: datatype misalignment");
-                       break;
-
-               case EXCEPTION_SINGLE_STEP:
-                       /* A trace trap or other single-instruction mechanism
-                          signaled that one instruction has been executed. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: single step");
-                       break;
-
-               case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: 
-                       /* The thread attempted to access an array element
-                          that is out of bounds, and the underlying hardware
-                          supports bounds checking. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: array bounds exceeded");
-                       break;
-
-               case EXCEPTION_FLT_DENORMAL_OPERAND:
-                       /* One of the operands in a floating-point operation
-                          is denormal. A denormal value is one that is too
-                          small to represent as a standard floating-point
-                          value. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: floating-point operand denormal");
-                       break;
-
-               case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-                       /* The thread attempted to divide a floating-point
-                          value by a floating-point divisor of zero. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: float divide by zero");
-                       break;
-
-               case EXCEPTION_FLT_INEXACT_RESULT:
-                       /* The result of a floating-point operation cannot be
-                          represented exactly as a decimal fraction. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: float inexact");
-                       break;
-
-               case EXCEPTION_FLT_INVALID_OPERATION:
-                       /* This exception represents any floating-point
-                          exception not included in this list. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: float invalid operation");
-                       break;
-
-               case EXCEPTION_FLT_OVERFLOW:
-                       /* The exponent of a floating-point operation is
-                          greater than the magnitude allowed by the
-                          corresponding type. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: float overflow");
-                       break;
-
-               case EXCEPTION_FLT_STACK_CHECK:
-                       /* The stack overflowed or underflowed as the result
-                          of a floating-point operation. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: stack over/underflow");
-                       break;
-
-               case EXCEPTION_STACK_OVERFLOW:
-                       /* The stack overflowed or underflowed as the result
-                          of a floating-point operation. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: stack overflow");
-                       break;
-
-               case EXCEPTION_FLT_UNDERFLOW:
-                       /* The exponent of a floating-point operation is less
-                          than the magnitude allowed by the corresponding
-                          type. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: float underflow");
-                       break;
-
-               case EXCEPTION_INT_DIVIDE_BY_ZERO:
-                       /* The thread attempted to divide an integer value by
-                          an integer divisor of zero. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: integer divide by zero");
-                       break;
-
-               case EXCEPTION_INT_OVERFLOW:
-                       /* The result of an integer operation caused a carry
-                          out of the most significant bit of the result. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: integer overflow");
-                       break;
-
-               case EXCEPTION_PRIV_INSTRUCTION:
-                       /* The thread attempted to execute an instruction
-                          whose operation is not allowed in the current
-                          machine mode. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: priviledged instruction");
-                       break;
-
-               case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-                       /* The thread attempted to continue execution after a
-                          noncontinuable exception occurred. */
-                       PyErr_SetString(PyExc_WindowsError,
-                                       "exception: nocontinuable");
-                       break;
-               default:
-                       printf("error %d\n", code);
+       /* The 'code' is a normal win32 error code so it could be handled by
+       PyErr_SetFromWindowsErr(). However, for some errors, we have additional
+       information not included in the error code. We handle those here and
+       delegate all others to the generic function. */
+       switch (code) {
+       case EXCEPTION_ACCESS_VIOLATION:
+               /* The thread attempted to read from or write
+                  to a virtual address for which it does not
+                  have the appropriate access. */
+               if (pr->ExceptionInformation[0] == 0)
                        PyErr_Format(PyExc_WindowsError,
-                                    "exception code 0x%08x",
-                                    code);
-                       break;
-               }
+                                    "exception: access violation reading %p",
+                                    pr->ExceptionInformation[1]);
+               else
+                       PyErr_Format(PyExc_WindowsError,
+                                    "exception: access violation writing %p",
+                                    pr->ExceptionInformation[1]);
+               break;
+
+       case EXCEPTION_BREAKPOINT:
+               /* A breakpoint was encountered. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: breakpoint encountered");
+               break;
+
+       case EXCEPTION_DATATYPE_MISALIGNMENT:
+               /* The thread attempted to read or write data that is
+                  misaligned on hardware that does not provide
+                  alignment. For example, 16-bit values must be
+                  aligned on 2-byte boundaries, 32-bit values on
+                  4-byte boundaries, and so on. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: datatype misalignment");
+               break;
+
+       case EXCEPTION_SINGLE_STEP:
+               /* A trace trap or other single-instruction mechanism
+                  signaled that one instruction has been executed. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: single step");
+               break;
+
+       case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: 
+               /* The thread attempted to access an array element
+                  that is out of bounds, and the underlying hardware
+                  supports bounds checking. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: array bounds exceeded");
+               break;
+
+       case EXCEPTION_FLT_DENORMAL_OPERAND:
+               /* One of the operands in a floating-point operation
+                  is denormal. A denormal value is one that is too
+                  small to represent as a standard floating-point
+                  value. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: floating-point operand denormal");
+               break;
+
+       case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+               /* The thread attempted to divide a floating-point
+                  value by a floating-point divisor of zero. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: float divide by zero");
+               break;
+
+       case EXCEPTION_FLT_INEXACT_RESULT:
+               /* The result of a floating-point operation cannot be
+                  represented exactly as a decimal fraction. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: float inexact");
+               break;
+
+       case EXCEPTION_FLT_INVALID_OPERATION:
+               /* This exception represents any floating-point
+                  exception not included in this list. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: float invalid operation");
+               break;
+
+       case EXCEPTION_FLT_OVERFLOW:
+               /* The exponent of a floating-point operation is
+                  greater than the magnitude allowed by the
+                  corresponding type. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: float overflow");
+               break;
+
+       case EXCEPTION_FLT_STACK_CHECK:
+               /* The stack overflowed or underflowed as the result
+                  of a floating-point operation. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: stack over/underflow");
+               break;
+
+       case EXCEPTION_STACK_OVERFLOW:
+               /* The stack overflowed or underflowed as the result
+                  of a floating-point operation. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: stack overflow");
+               break;
+
+       case EXCEPTION_FLT_UNDERFLOW:
+               /* The exponent of a floating-point operation is less
+                  than the magnitude allowed by the corresponding
+                  type. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: float underflow");
+               break;
+
+       case EXCEPTION_INT_DIVIDE_BY_ZERO:
+               /* The thread attempted to divide an integer value by
+                  an integer divisor of zero. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: integer divide by zero");
+               break;
+
+       case EXCEPTION_INT_OVERFLOW:
+               /* The result of an integer operation caused a carry
+                  out of the most significant bit of the result. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: integer overflow");
+               break;
+
+       case EXCEPTION_PRIV_INSTRUCTION:
+               /* The thread attempted to execute an instruction
+                  whose operation is not allowed in the current
+                  machine mode. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: priviledged instruction");
+               break;
+
+       case EXCEPTION_NONCONTINUABLE_EXCEPTION:
+               /* The thread attempted to continue execution after a
+                  noncontinuable exception occurred. */
+               PyErr_SetString(PyExc_WindowsError,
+                               "exception: nocontinuable");
+               break;
+
+       default:
+               PyErr_SetFromWindowsErr(code);
+               break;
        }
 }