home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 15 / AACD15.ISO / AACD / Programming / Python2 / Python20_source / Python / errors.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-10-25  |  12.4 KB  |  591 lines
  1.  
  2. /* Error handling */
  3.  
  4. #include "Python.h"
  5.  
  6. #ifdef macintosh
  7. extern char *PyMac_StrError(int);
  8. #undef strerror
  9. #define strerror PyMac_StrError
  10. #endif /* macintosh */
  11.  
  12. #ifndef __STDC__
  13. #ifndef MS_WINDOWS
  14. extern char *strerror(int);
  15. #endif
  16. #endif
  17.  
  18. #ifdef MS_WIN32
  19. #include "windows.h"
  20. #include "winbase.h"
  21. #endif
  22.  
  23. #include <ctype.h>
  24.  
  25. void
  26. PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
  27. {
  28.     PyThreadState *tstate = PyThreadState_GET();
  29.     PyObject *oldtype, *oldvalue, *oldtraceback;
  30.  
  31.     if (traceback != NULL && !PyTraceBack_Check(traceback)) {
  32.         /* XXX Should never happen -- fatal error instead? */
  33.         Py_DECREF(traceback);
  34.         traceback = NULL;
  35.     }
  36.  
  37.     /* Save these in locals to safeguard against recursive
  38.        invocation through Py_XDECREF */
  39.     oldtype = tstate->curexc_type;
  40.     oldvalue = tstate->curexc_value;
  41.     oldtraceback = tstate->curexc_traceback;
  42.  
  43.     tstate->curexc_type = type;
  44.     tstate->curexc_value = value;
  45.     tstate->curexc_traceback = traceback;
  46.  
  47.     Py_XDECREF(oldtype);
  48.     Py_XDECREF(oldvalue);
  49.     Py_XDECREF(oldtraceback);
  50. }
  51.  
  52. void
  53. PyErr_SetObject(PyObject *exception, PyObject *value)
  54. {
  55.     Py_XINCREF(exception);
  56.     Py_XINCREF(value);
  57.     PyErr_Restore(exception, value, (PyObject *)NULL);
  58. }
  59.  
  60. void
  61. PyErr_SetNone(PyObject *exception)
  62. {
  63.     PyErr_SetObject(exception, (PyObject *)NULL);
  64. }
  65.  
  66. void
  67. PyErr_SetString(PyObject *exception, const char *string)
  68. {
  69.     PyObject *value = PyString_FromString(string);
  70.     PyErr_SetObject(exception, value);
  71.     Py_XDECREF(value);
  72. }
  73.  
  74.  
  75. PyObject *
  76. PyErr_Occurred(void)
  77. {
  78.     PyThreadState *tstate = PyThreadState_Get();
  79.  
  80.     return tstate->curexc_type;
  81. }
  82.  
  83.  
  84. int
  85. PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
  86. {
  87.     if (err == NULL || exc == NULL) {
  88.         /* maybe caused by "import exceptions" that failed early on */
  89.         return 0;
  90.     }
  91.     if (PyTuple_Check(exc)) {
  92.         int i, n;
  93.         n = PyTuple_Size(exc);
  94.         for (i = 0; i < n; i++) {
  95.             /* Test recursively */
  96.              if (PyErr_GivenExceptionMatches(
  97.                  err, PyTuple_GET_ITEM(exc, i)))
  98.              {
  99.                  return 1;
  100.              }
  101.         }
  102.         return 0;
  103.     }
  104.     /* err might be an instance, so check its class. */
  105.     if (PyInstance_Check(err))
  106.         err = (PyObject*)((PyInstanceObject*)err)->in_class;
  107.  
  108.     if (PyClass_Check(err) && PyClass_Check(exc))
  109.         return PyClass_IsSubclass(err, exc);
  110.  
  111.     return err == exc;
  112. }
  113.  
  114.  
  115. int
  116. PyErr_ExceptionMatches(PyObject *exc)
  117. {
  118.     return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
  119. }
  120.  
  121.  
  122. /* Used in many places to normalize a raised exception, including in
  123.    eval_code2(), do_raise(), and PyErr_Print()
  124. */
  125. void
  126. PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb)
  127. {
  128.     PyObject *type = *exc;
  129.     PyObject *value = *val;
  130.     PyObject *inclass = NULL;
  131.  
  132.     if (type == NULL) {
  133.         /* This is a bug.  Should never happen.  Don't dump core. */
  134.         PyErr_SetString(PyExc_SystemError,
  135.             "PyErr_NormalizeException() called without exception");
  136.     }
  137.  
  138.     /* If PyErr_SetNone() was used, the value will have been actually
  139.        set to NULL.
  140.     */
  141.     if (!value) {
  142.         value = Py_None;
  143.         Py_INCREF(value);
  144.     }
  145.  
  146.     if (PyInstance_Check(value))
  147.         inclass = (PyObject*)((PyInstanceObject*)value)->in_class;
  148.  
  149.     /* Normalize the exception so that if the type is a class, the
  150.        value will be an instance.
  151.     */
  152.     if (PyClass_Check(type)) {
  153.         /* if the value was not an instance, or is not an instance
  154.            whose class is (or is derived from) type, then use the
  155.            value as an argument to instantiation of the type
  156.            class.
  157.         */
  158.         if (!inclass || !PyClass_IsSubclass(inclass, type)) {
  159.             PyObject *args, *res;
  160.  
  161.             if (value == Py_None)
  162.                 args = Py_BuildValue("()");
  163.             else if (PyTuple_Check(value)) {
  164.                 Py_INCREF(value);
  165.                 args = value;
  166.             }
  167.             else
  168.                 args = Py_BuildValue("(O)", value);
  169.  
  170.             if (args == NULL)
  171.                 goto finally;
  172.             res = PyEval_CallObject(type, args);
  173.             Py_DECREF(args);
  174.             if (res == NULL)
  175.                 goto finally;
  176.             Py_DECREF(value);
  177.             value = res;
  178.         }
  179.         /* if the class of the instance doesn't exactly match the
  180.            class of the type, believe the instance
  181.         */
  182.         else if (inclass != type) {
  183.              Py_DECREF(type);
  184.             type = inclass;
  185.             Py_INCREF(type);
  186.         }
  187.     }
  188.     *exc = type;
  189.     *val = value;
  190.     return;
  191. finally:
  192.     Py_DECREF(type);
  193.     Py_DECREF(value);
  194.     Py_XDECREF(*tb);
  195.     PyErr_Fetch(exc, val, tb);
  196.     /* normalize recursively */
  197.     PyErr_NormalizeException(exc, val, tb);
  198. }
  199.  
  200.  
  201. void
  202. PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
  203. {
  204.     PyThreadState *tstate = PyThreadState_Get();
  205.  
  206.     *p_type = tstate->curexc_type;
  207.     *p_value = tstate->curexc_value;
  208.     *p_traceback = tstate->curexc_traceback;
  209.  
  210.     tstate->curexc_type = NULL;
  211.     tstate->curexc_value = NULL;
  212.     tstate->curexc_traceback = NULL;
  213. }
  214.  
  215. void
  216. PyErr_Clear(void)
  217. {
  218.     PyErr_Restore(NULL, NULL, NULL);
  219. }
  220.  
  221. /* Convenience functions to set a type error exception and return 0 */
  222.  
  223. int
  224. PyErr_BadArgument(void)
  225. {
  226.     PyErr_SetString(PyExc_TypeError,
  227.             "illegal argument type for built-in operation");
  228.     return 0;
  229. }
  230.  
  231. PyObject *
  232. PyErr_NoMemory(void)
  233. {
  234.     if (PyErr_ExceptionMatches(PyExc_MemoryError))
  235.         /* already current */
  236.         return NULL;
  237.  
  238.     /* raise the pre-allocated instance if it still exists */
  239.     if (PyExc_MemoryErrorInst)
  240.         PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
  241.     else
  242.         /* this will probably fail since there's no memory and hee,
  243.            hee, we have to instantiate this class
  244.         */
  245.         PyErr_SetNone(PyExc_MemoryError);
  246.  
  247.     return NULL;
  248. }
  249.  
  250. PyObject *
  251. PyErr_SetFromErrnoWithFilename(PyObject *exc, char *filename)
  252. {
  253.     PyObject *v;
  254.     char *s;
  255.     int i = errno;
  256. #ifdef MS_WIN32
  257.     char *s_buf = NULL;
  258. #endif
  259. #ifdef EINTR
  260.     if (i == EINTR && PyErr_CheckSignals())
  261.         return NULL;
  262. #endif
  263.     if (i == 0)
  264.         s = "Error"; /* Sometimes errno didn't get set */
  265.     else
  266. #ifndef MS_WIN32
  267.         s = strerror(i);
  268. #else
  269.     {
  270.         /* Note that the Win32 errors do not lineup with the
  271.            errno error.  So if the error is in the MSVC error
  272.            table, we use it, otherwise we assume it really _is_ 
  273.            a Win32 error code
  274.         */
  275.         if (i > 0 && i < _sys_nerr) {
  276.             s = _sys_errlist[i];
  277.         }
  278.         else {
  279.             int len = FormatMessage(
  280.                 FORMAT_MESSAGE_ALLOCATE_BUFFER |
  281.                 FORMAT_MESSAGE_FROM_SYSTEM |
  282.                 FORMAT_MESSAGE_IGNORE_INSERTS,
  283.                 NULL,    /* no message source */
  284.                 i,
  285.                 MAKELANGID(LANG_NEUTRAL,
  286.                        SUBLANG_DEFAULT),
  287.                            /* Default language */
  288.                 (LPTSTR) &s_buf,
  289.                 0,    /* size not used */
  290.                 NULL);    /* no args */
  291.             s = s_buf;
  292.             /* remove trailing cr/lf and dots */
  293.             while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
  294.                 s[--len] = '\0';
  295.         }
  296.     }
  297. #endif
  298.     if (filename != NULL)
  299.         v = Py_BuildValue("(iss)", i, s, filename);
  300.     else
  301.         v = Py_BuildValue("(is)", i, s);
  302.     if (v != NULL) {
  303.         PyErr_SetObject(exc, v);
  304.         Py_DECREF(v);
  305.     }
  306. #ifdef MS_WIN32
  307.     LocalFree(s_buf);
  308. #endif
  309.     return NULL;
  310. }
  311.  
  312.  
  313. PyObject *
  314. PyErr_SetFromErrno(PyObject *exc)
  315. {
  316.     return PyErr_SetFromErrnoWithFilename(exc, NULL);
  317. }
  318.  
  319. #ifdef MS_WINDOWS 
  320. /* Windows specific error code handling */
  321. PyObject *PyErr_SetFromWindowsErrWithFilename(
  322.     int ierr,
  323.     const char *filename)
  324. {
  325.     int len;
  326.     char *s;
  327.     PyObject *v;
  328.     DWORD err = (DWORD)ierr;
  329.     if (err==0) err = GetLastError();
  330.     len = FormatMessage(
  331.         /* Error API error */
  332.         FORMAT_MESSAGE_ALLOCATE_BUFFER |
  333.         FORMAT_MESSAGE_FROM_SYSTEM |
  334.         FORMAT_MESSAGE_IGNORE_INSERTS,
  335.         NULL,    /* no message source */
  336.         err,
  337.         MAKELANGID(LANG_NEUTRAL,
  338.         SUBLANG_DEFAULT), /* Default language */
  339.         (LPTSTR) &s,
  340.         0,    /* size not used */
  341.         NULL);    /* no args */
  342.     /* remove trailing cr/lf and dots */
  343.     while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
  344.         s[--len] = '\0';
  345.     if (filename != NULL)
  346.         v = Py_BuildValue("(iss)", err, s, filename);
  347.     else
  348.         v = Py_BuildValue("(is)", err, s);
  349.     if (v != NULL) {
  350.         PyErr_SetObject(PyExc_WindowsError, v);
  351.         Py_DECREF(v);
  352.     }
  353.     LocalFree(s);
  354.     return NULL;
  355. }
  356.  
  357. PyObject *PyErr_SetFromWindowsErr(int ierr)
  358. {
  359.     return PyErr_SetFromWindowsErrWithFilename(ierr, NULL);
  360. }
  361. #endif /* MS_WINDOWS */
  362.  
  363. void
  364. _PyErr_BadInternalCall(char *filename, int lineno)
  365. {
  366.     PyErr_Format(PyExc_SystemError,
  367.              "%s:%d: bad argument to internal function",
  368.              filename, lineno);
  369. }
  370.  
  371. /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can
  372.    export the entry point for existing object code: */
  373. #undef PyErr_BadInternalCall
  374. void
  375. PyErr_BadInternalCall(void)
  376. {
  377.     PyErr_Format(PyExc_SystemError,
  378.              "bad argument to internal function");
  379. }
  380. #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
  381.  
  382.  
  383.  
  384. PyObject *
  385. PyErr_Format(PyObject *exception, const char *format, ...)
  386. {
  387.     va_list vargs;
  388.     int n, i;
  389.     const char* f;
  390.     char* s;
  391.     PyObject* string;
  392.  
  393.     /* step 1: figure out how large a buffer we need */
  394.  
  395. #ifdef HAVE_STDARG_PROTOTYPES
  396.     va_start(vargs, format);
  397. #else
  398.     va_start(vargs);
  399. #endif
  400.  
  401.     n = 0;
  402.     for (f = format; *f; f++) {
  403.         if (*f == '%') {
  404.             const char* p = f;
  405.             while (*++f && *f != '%' && !isalpha(*f))
  406.                 ;
  407.             switch (*f) {
  408.             case 'c':
  409.                 (void) va_arg(vargs, int);
  410.                 /* fall through... */
  411.             case '%':
  412.                 n++;
  413.                 break;
  414.             case 'd': case 'i': case 'x':
  415.                 (void) va_arg(vargs, int);
  416.                 /* 20 bytes should be enough to hold a 64-bit
  417.                    integer */
  418.                 n = n + 20;
  419.                 break;
  420.             case 's':
  421.                 s = va_arg(vargs, char*);
  422.                 n = n + strlen(s);
  423.                 break;
  424.             default:
  425.                 /* if we stumble upon an unknown
  426.                    formatting code, copy the rest of
  427.                    the format string to the output
  428.                    string. (we cannot just skip the
  429.                    code, since there's no way to know
  430.                    what's in the argument list) */ 
  431.                 n = n + strlen(p);
  432.                 goto expand;
  433.             }
  434.         } else
  435.             n = n + 1;
  436.     }
  437.     
  438.  expand:
  439.     
  440.     string = PyString_FromStringAndSize(NULL, n);
  441.     if (!string)
  442.         return NULL;
  443.     
  444. #ifdef HAVE_STDARG_PROTOTYPES
  445.     va_start(vargs, format);
  446. #else
  447.     va_start(vargs);
  448. #endif
  449.  
  450.     /* step 2: fill the buffer */
  451.  
  452.     s = PyString_AsString(string);
  453.  
  454.     for (f = format; *f; f++) {
  455.         if (*f == '%') {
  456.             const char* p = f++;
  457.             /* parse the width.precision part (we're only
  458.                interested in the precision value, if any) */
  459.             n = 0;
  460.             while (isdigit(*f))
  461.                 n = (n*10) + *f++ - '0';
  462.             if (*f == '.') {
  463.                 f++;
  464.                 n = 0;
  465.                 while (isdigit(*f))
  466.                     n = (n*10) + *f++ - '0';
  467.             }
  468.             while (*f && *f != '%' && !isalpha(*f))
  469.                 f++;
  470.             switch (*f) {
  471.             case 'c':
  472.                 *s++ = va_arg(vargs, int);
  473.                 break;
  474.             case 'd': 
  475.                 sprintf(s, "%d", va_arg(vargs, int));
  476.                 s = s + strlen(s);
  477.                 break;
  478.             case 'i':
  479.                 sprintf(s, "%i", va_arg(vargs, int));
  480.                 s = s + strlen(s);
  481.                 break;
  482.             case 'x':
  483.                 sprintf(s, "%x", va_arg(vargs, int));
  484.                 s = s + strlen(s);
  485.                 break;
  486.             case 's':
  487.                 p = va_arg(vargs, char*);
  488.                 i = strlen(p);
  489.                 if (n > 0 && i > n)
  490.                     i = n;
  491.                 memcpy(s, p, i);
  492.                 s = s + i;
  493.                 break;
  494.             case '%':
  495.                 *s++ = '%';
  496.                 break;
  497.             default:
  498.                 strcpy(s, p);
  499.                 s = s + strlen(s);
  500.                 goto end;
  501.             }
  502.         } else
  503.             *s++ = *f;
  504.     }
  505.     
  506.  end:
  507.     
  508.     _PyString_Resize(&string, s - PyString_AsString(string));
  509.     
  510.     PyErr_SetObject(exception, string);
  511.     Py_XDECREF(string);
  512.     
  513.     return NULL;
  514. }
  515.  
  516.  
  517. PyObject *
  518. PyErr_NewException(char *name, PyObject *base, PyObject *dict)
  519. {
  520.     char *dot;
  521.     PyObject *modulename = NULL;
  522.     PyObject *classname = NULL;
  523.     PyObject *mydict = NULL;
  524.     PyObject *bases = NULL;
  525.     PyObject *result = NULL;
  526.     dot = strrchr(name, '.');
  527.     if (dot == NULL) {
  528.         PyErr_SetString(PyExc_SystemError,
  529.             "PyErr_NewException: name must be module.class");
  530.         return NULL;
  531.     }
  532.     if (base == NULL)
  533.         base = PyExc_Exception;
  534.     if (!PyClass_Check(base)) {
  535.         /* Must be using string-based standard exceptions (-X) */
  536.         return PyString_FromString(name);
  537.     }
  538.     if (dict == NULL) {
  539.         dict = mydict = PyDict_New();
  540.         if (dict == NULL)
  541.             goto failure;
  542.     }
  543.     if (PyDict_GetItemString(dict, "__module__") == NULL) {
  544.         modulename = PyString_FromStringAndSize(name, (int)(dot-name));
  545.         if (modulename == NULL)
  546.             goto failure;
  547.         if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
  548.             goto failure;
  549.     }
  550.     classname = PyString_FromString(dot+1);
  551.     if (classname == NULL)
  552.         goto failure;
  553.     bases = Py_BuildValue("(O)", base);
  554.     if (bases == NULL)
  555.         goto failure;
  556.     result = PyClass_New(bases, dict, classname);
  557.   failure:
  558.     Py_XDECREF(bases);
  559.     Py_XDECREF(mydict);
  560.     Py_XDECREF(classname);
  561.     Py_XDECREF(modulename);
  562.     return result;
  563. }
  564.  
  565. /* Call when an exception has occurred but there is no way for Python
  566.    to handle it.  Examples: exception in __del__ or during GC. */
  567. void
  568. PyErr_WriteUnraisable(PyObject *obj)
  569. {
  570.     PyObject *f, *t, *v, *tb;
  571.     PyErr_Fetch(&t, &v, &tb);
  572.     f = PySys_GetObject("stderr");
  573.     if (f != NULL) {
  574.         PyFile_WriteString("Exception ", f);
  575.         if (t) {
  576.             PyFile_WriteObject(t, f, Py_PRINT_RAW);
  577.             if (v && v != Py_None) {
  578.                 PyFile_WriteString(": ", f);
  579.                 PyFile_WriteObject(v, f, 0);
  580.             }
  581.         }
  582.         PyFile_WriteString(" in ", f);
  583.         PyFile_WriteObject(obj, f, 0);
  584.         PyFile_WriteString(" ignored\n", f);
  585.         PyErr_Clear(); /* Just in case */
  586.     }
  587.     Py_XDECREF(t);
  588.     Py_XDECREF(v);
  589.     Py_XDECREF(tb);
  590. }
  591.