svn+ssh://pythondev@svn.python.org/python/trunk ........ r53899 | neal.norwitz | 2007-02-25 16:52:27 +0100 (Sun, 25 Feb 2007) | 1 line Add more details when releasing interned strings ........ r53900 | neal.norwitz | 2007-02-25 16:53:36 +0100 (Sun, 25 Feb 2007) | 1 line Whitespace only changes ........ r53901 | jeremy.hylton | 2007-02-25 16:57:45 +0100 (Sun, 25 Feb 2007) | 8 lines Fix crash in exec when unicode filename can't be decoded. I can't think of an easy way to test this behavior. It only occurs when the file system default encoding and the interpreter default encoding are different, such that you can open the file but not decode its name. ........ r53902 | jeremy.hylton | 2007-02-25 17:01:58 +0100 (Sun, 25 Feb 2007) | 2 lines Put declarations before code. ........ r53910 | fred.drake | 2007-02-25 18:56:27 +0100 (Sun, 25 Feb 2007) | 3 lines - SF patch #1657613: add documentation for the Element interface - clean up bogus use of the {datadescni} environment everywhere ........ r53911 | neal.norwitz | 2007-02-25 20:44:48 +0100 (Sun, 25 Feb 2007) | 17 lines Variation of patch # 1624059 to speed up checking if an object is a subclass of some of the common builtin types. Use a bit in tp_flags for each common builtin type. Check the bit to determine if any instance is a subclass of these common types. The check avoids a function call and O(n) search of the base classes. The check is done in the various Py*_Check macros rather than calling PyType_IsSubtype(). All the bits are set in tp_flags when the type is declared in the Objects/*object.c files because PyType_Ready() is not called for all the types. Should PyType_Ready() be called for all types? If so and the change is made, the changes to the Objects/*object.c files can be reverted (remove setting the tp_flags). Objects/typeobject.c would also have to be modified to add conditions for Py*_CheckExact() in addition to each the PyType_IsSubtype check. ........
327 lines
11 KiB
C
327 lines
11 KiB
C
#ifndef Py_ERRORS_H
|
|
#define Py_ERRORS_H
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/* Error objects */
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
PyObject *dict;
|
|
PyObject *args;
|
|
PyObject *message;
|
|
} PyBaseExceptionObject;
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
PyObject *dict;
|
|
PyObject *args;
|
|
PyObject *message;
|
|
PyObject *msg;
|
|
PyObject *filename;
|
|
PyObject *lineno;
|
|
PyObject *offset;
|
|
PyObject *text;
|
|
PyObject *print_file_and_line;
|
|
} PySyntaxErrorObject;
|
|
|
|
#ifdef Py_USING_UNICODE
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
PyObject *dict;
|
|
PyObject *args;
|
|
PyObject *message;
|
|
PyObject *encoding;
|
|
PyObject *object;
|
|
PyObject *start;
|
|
PyObject *end;
|
|
PyObject *reason;
|
|
} PyUnicodeErrorObject;
|
|
#endif
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
PyObject *dict;
|
|
PyObject *args;
|
|
PyObject *message;
|
|
PyObject *code;
|
|
} PySystemExitObject;
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
PyObject *dict;
|
|
PyObject *args;
|
|
PyObject *message;
|
|
PyObject *myerrno;
|
|
PyObject *strerror;
|
|
PyObject *filename;
|
|
} PyEnvironmentErrorObject;
|
|
|
|
#ifdef MS_WINDOWS
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
PyObject *dict;
|
|
PyObject *args;
|
|
PyObject *message;
|
|
PyObject *myerrno;
|
|
PyObject *strerror;
|
|
PyObject *filename;
|
|
PyObject *winerror;
|
|
} PyWindowsErrorObject;
|
|
#endif
|
|
|
|
/* Error handling definitions */
|
|
|
|
PyAPI_FUNC(void) PyErr_SetNone(PyObject *);
|
|
PyAPI_FUNC(void) PyErr_SetObject(PyObject *, PyObject *);
|
|
PyAPI_FUNC(void) PyErr_SetString(PyObject *, const char *);
|
|
PyAPI_FUNC(PyObject *) PyErr_Occurred(void);
|
|
PyAPI_FUNC(void) PyErr_Clear(void);
|
|
PyAPI_FUNC(void) PyErr_Fetch(PyObject **, PyObject **, PyObject **);
|
|
PyAPI_FUNC(void) PyErr_Restore(PyObject *, PyObject *, PyObject *);
|
|
|
|
#ifdef Py_DEBUG
|
|
#define _PyErr_OCCURRED() PyErr_Occurred()
|
|
#else
|
|
#define _PyErr_OCCURRED() (_PyThreadState_Current->curexc_type)
|
|
#endif
|
|
|
|
/* Error testing and normalization */
|
|
PyAPI_FUNC(int) PyErr_GivenExceptionMatches(PyObject *, PyObject *);
|
|
PyAPI_FUNC(int) PyErr_ExceptionMatches(PyObject *);
|
|
PyAPI_FUNC(void) PyErr_NormalizeException(PyObject**, PyObject**, PyObject**);
|
|
|
|
/* */
|
|
|
|
#define PyExceptionClass_Check(x) \
|
|
(PyType_Check((x)) && \
|
|
PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
|
|
|
|
#define PyExceptionInstance_Check(x) \
|
|
PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS)
|
|
|
|
#define PyExceptionClass_Name(x) \
|
|
((char *)(((PyTypeObject*)(x))->tp_name))
|
|
|
|
#define PyExceptionInstance_Class(x) ((PyObject*)((x)->ob_type))
|
|
|
|
|
|
/* Predefined exceptions */
|
|
|
|
PyAPI_DATA(PyObject *) PyExc_BaseException;
|
|
PyAPI_DATA(PyObject *) PyExc_Exception;
|
|
PyAPI_DATA(PyObject *) PyExc_StopIteration;
|
|
PyAPI_DATA(PyObject *) PyExc_GeneratorExit;
|
|
PyAPI_DATA(PyObject *) PyExc_StandardError;
|
|
PyAPI_DATA(PyObject *) PyExc_ArithmeticError;
|
|
PyAPI_DATA(PyObject *) PyExc_LookupError;
|
|
|
|
PyAPI_DATA(PyObject *) PyExc_AssertionError;
|
|
PyAPI_DATA(PyObject *) PyExc_AttributeError;
|
|
PyAPI_DATA(PyObject *) PyExc_EOFError;
|
|
PyAPI_DATA(PyObject *) PyExc_FloatingPointError;
|
|
PyAPI_DATA(PyObject *) PyExc_EnvironmentError;
|
|
PyAPI_DATA(PyObject *) PyExc_IOError;
|
|
PyAPI_DATA(PyObject *) PyExc_OSError;
|
|
PyAPI_DATA(PyObject *) PyExc_ImportError;
|
|
PyAPI_DATA(PyObject *) PyExc_IndexError;
|
|
PyAPI_DATA(PyObject *) PyExc_KeyError;
|
|
PyAPI_DATA(PyObject *) PyExc_KeyboardInterrupt;
|
|
PyAPI_DATA(PyObject *) PyExc_MemoryError;
|
|
PyAPI_DATA(PyObject *) PyExc_NameError;
|
|
PyAPI_DATA(PyObject *) PyExc_OverflowError;
|
|
PyAPI_DATA(PyObject *) PyExc_RuntimeError;
|
|
PyAPI_DATA(PyObject *) PyExc_NotImplementedError;
|
|
PyAPI_DATA(PyObject *) PyExc_SyntaxError;
|
|
PyAPI_DATA(PyObject *) PyExc_IndentationError;
|
|
PyAPI_DATA(PyObject *) PyExc_TabError;
|
|
PyAPI_DATA(PyObject *) PyExc_ReferenceError;
|
|
PyAPI_DATA(PyObject *) PyExc_SystemError;
|
|
PyAPI_DATA(PyObject *) PyExc_SystemExit;
|
|
PyAPI_DATA(PyObject *) PyExc_TypeError;
|
|
PyAPI_DATA(PyObject *) PyExc_UnboundLocalError;
|
|
PyAPI_DATA(PyObject *) PyExc_UnicodeError;
|
|
PyAPI_DATA(PyObject *) PyExc_UnicodeEncodeError;
|
|
PyAPI_DATA(PyObject *) PyExc_UnicodeDecodeError;
|
|
PyAPI_DATA(PyObject *) PyExc_UnicodeTranslateError;
|
|
PyAPI_DATA(PyObject *) PyExc_ValueError;
|
|
PyAPI_DATA(PyObject *) PyExc_ZeroDivisionError;
|
|
#ifdef MS_WINDOWS
|
|
PyAPI_DATA(PyObject *) PyExc_WindowsError;
|
|
#endif
|
|
#ifdef __VMS
|
|
PyAPI_DATA(PyObject *) PyExc_VMSError;
|
|
#endif
|
|
|
|
PyAPI_DATA(PyObject *) PyExc_MemoryErrorInst;
|
|
|
|
/* Predefined warning categories */
|
|
PyAPI_DATA(PyObject *) PyExc_Warning;
|
|
PyAPI_DATA(PyObject *) PyExc_UserWarning;
|
|
PyAPI_DATA(PyObject *) PyExc_DeprecationWarning;
|
|
PyAPI_DATA(PyObject *) PyExc_PendingDeprecationWarning;
|
|
PyAPI_DATA(PyObject *) PyExc_SyntaxWarning;
|
|
PyAPI_DATA(PyObject *) PyExc_RuntimeWarning;
|
|
PyAPI_DATA(PyObject *) PyExc_FutureWarning;
|
|
PyAPI_DATA(PyObject *) PyExc_ImportWarning;
|
|
PyAPI_DATA(PyObject *) PyExc_UnicodeWarning;
|
|
|
|
|
|
/* Convenience functions */
|
|
|
|
PyAPI_FUNC(int) PyErr_BadArgument(void);
|
|
PyAPI_FUNC(PyObject *) PyErr_NoMemory(void);
|
|
PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *);
|
|
PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject(
|
|
PyObject *, PyObject *);
|
|
PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename(PyObject *, char *);
|
|
#ifdef Py_WIN_WIDE_FILENAMES
|
|
PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename(
|
|
PyObject *, Py_UNICODE *);
|
|
#endif /* Py_WIN_WIDE_FILENAMES */
|
|
|
|
PyAPI_FUNC(PyObject *) PyErr_Format(PyObject *, const char *, ...)
|
|
Py_GCC_ATTRIBUTE((format(printf, 2, 3)));
|
|
|
|
#ifdef MS_WINDOWS
|
|
PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilenameObject(
|
|
int, const char *);
|
|
PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename(
|
|
int, const char *);
|
|
#ifdef Py_WIN_WIDE_FILENAMES
|
|
PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename(
|
|
int, const Py_UNICODE *);
|
|
#endif /* Py_WIN_WIDE_FILENAMES */
|
|
PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int);
|
|
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject(
|
|
PyObject *,int, PyObject *);
|
|
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename(
|
|
PyObject *,int, const char *);
|
|
#ifdef Py_WIN_WIDE_FILENAMES
|
|
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename(
|
|
PyObject *,int, const Py_UNICODE *);
|
|
#endif /* Py_WIN_WIDE_FILENAMES */
|
|
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int);
|
|
#endif /* MS_WINDOWS */
|
|
|
|
/* Export the old function so that the existing API remains available: */
|
|
PyAPI_FUNC(void) PyErr_BadInternalCall(void);
|
|
PyAPI_FUNC(void) _PyErr_BadInternalCall(char *filename, int lineno);
|
|
/* Mask the old API with a call to the new API for code compiled under
|
|
Python 2.0: */
|
|
#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
|
|
|
|
/* Function to create a new exception */
|
|
PyAPI_FUNC(PyObject *) PyErr_NewException(char *name, PyObject *base,
|
|
PyObject *dict);
|
|
PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject *);
|
|
|
|
/* Issue a warning or exception */
|
|
PyAPI_FUNC(int) PyErr_WarnEx(PyObject *category, const char *msg,
|
|
Py_ssize_t stack_level);
|
|
PyAPI_FUNC(int) PyErr_WarnExplicit(PyObject *, const char *,
|
|
const char *, int,
|
|
const char *, PyObject *);
|
|
/* PyErr_Warn is only for backwards compatability and will be removed.
|
|
Use PyErr_WarnEx instead. */
|
|
#define PyErr_Warn(category, msg) PyErr_WarnEx(category, msg, 1)
|
|
|
|
/* In sigcheck.c or signalmodule.c */
|
|
PyAPI_FUNC(int) PyErr_CheckSignals(void);
|
|
PyAPI_FUNC(void) PyErr_SetInterrupt(void);
|
|
|
|
/* Support for adding program text to SyntaxErrors */
|
|
PyAPI_FUNC(void) PyErr_SyntaxLocation(const char *, int);
|
|
PyAPI_FUNC(PyObject *) PyErr_ProgramText(const char *, int);
|
|
|
|
#ifdef Py_USING_UNICODE
|
|
/* The following functions are used to create and modify unicode
|
|
exceptions from C */
|
|
|
|
/* create a UnicodeDecodeError object */
|
|
PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create(
|
|
const char *, const char *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
|
|
|
|
/* create a UnicodeEncodeError object */
|
|
PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create(
|
|
const char *, const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
|
|
|
|
/* create a UnicodeTranslateError object */
|
|
PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create(
|
|
const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
|
|
|
|
/* get the encoding attribute */
|
|
PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *);
|
|
PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetEncoding(PyObject *);
|
|
|
|
/* get the object attribute */
|
|
PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetObject(PyObject *);
|
|
PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetObject(PyObject *);
|
|
PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetObject(PyObject *);
|
|
|
|
/* get the value of the start attribute (the int * may not be NULL)
|
|
return 0 on success, -1 on failure */
|
|
PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *);
|
|
PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *);
|
|
PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *);
|
|
|
|
/* assign a new value to the start attribute
|
|
return 0 on success, -1 on failure */
|
|
PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t);
|
|
PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t);
|
|
PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t);
|
|
|
|
/* get the value of the end attribute (the int *may not be NULL)
|
|
return 0 on success, -1 on failure */
|
|
PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *);
|
|
PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *);
|
|
PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *);
|
|
|
|
/* assign a new value to the end attribute
|
|
return 0 on success, -1 on failure */
|
|
PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t);
|
|
PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t);
|
|
PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t);
|
|
|
|
/* get the value of the reason attribute */
|
|
PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetReason(PyObject *);
|
|
PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetReason(PyObject *);
|
|
PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetReason(PyObject *);
|
|
|
|
/* assign a new value to the reason attribute
|
|
return 0 on success, -1 on failure */
|
|
PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason(
|
|
PyObject *, const char *);
|
|
PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason(
|
|
PyObject *, const char *);
|
|
PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(
|
|
PyObject *, const char *);
|
|
#endif
|
|
|
|
|
|
/* These APIs aren't really part of the error implementation, but
|
|
often needed to format error messages; the native C lib APIs are
|
|
not available on all platforms, which is why we provide emulations
|
|
for those platforms in Python/mysnprintf.c,
|
|
WARNING: The return value of snprintf varies across platforms; do
|
|
not rely on any particular behavior; eventually the C99 defn may
|
|
be reliable.
|
|
*/
|
|
#if defined(MS_WIN32) && !defined(HAVE_SNPRINTF)
|
|
# define HAVE_SNPRINTF
|
|
# define snprintf _snprintf
|
|
# define vsnprintf _vsnprintf
|
|
#endif
|
|
|
|
#include <stdarg.h>
|
|
PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char *format, ...)
|
|
Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
|
|
PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va)
|
|
Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif /* !Py_ERRORS_H */
|