1 #ifndef Py_ERRORS_H

     2 #define Py_ERRORS_H

     3 #ifdef __cplusplus

     4 extern "C" {

     5 #endif

     6 

     7 /* Error objects */

     8 

     9 typedef struct {

    10     PyObject_HEAD

    11     PyObject *dict;

    12     PyObject *args;

    13     PyObject *message;

    14 } PyBaseExceptionObject;

    15 

    16 typedef struct {

    17     PyObject_HEAD

    18     PyObject *dict;

    19     PyObject *args;

    20     PyObject *message;

    21     PyObject *msg;

    22     PyObject *filename;

    23     PyObject *lineno;

    24     PyObject *offset;

    25     PyObject *text;

    26     PyObject *print_file_and_line;

    27 } PySyntaxErrorObject;

    28 

    29 #ifdef Py_USING_UNICODE

    30 typedef struct {

    31     PyObject_HEAD

    32     PyObject *dict;

    33     PyObject *args;

    34     PyObject *message;

    35     PyObject *encoding;

    36     PyObject *object;

    37     PyObject *start;

    38     PyObject *end;

    39     PyObject *reason;

    40 } PyUnicodeErrorObject;

    41 #endif

    42 

    43 typedef struct {

    44     PyObject_HEAD

    45     PyObject *dict;

    46     PyObject *args;

    47     PyObject *message;

    48     PyObject *code;

    49 } PySystemExitObject;

    50 

    51 typedef struct {

    52     PyObject_HEAD

    53     PyObject *dict;

    54     PyObject *args;

    55     PyObject *message;

    56     PyObject *myerrno;

    57     PyObject *strerror;

    58     PyObject *filename;

    59 } PyEnvironmentErrorObject;

    60 

    61 #ifdef MS_WINDOWS

    62 typedef struct {

    63     PyObject_HEAD

    64     PyObject *dict;

    65     PyObject *args;

    66     PyObject *message;

    67     PyObject *myerrno;

    68     PyObject *strerror;

    69     PyObject *filename;

    70     PyObject *winerror;

    71 } PyWindowsErrorObject;

    72 #endif

    73 

    74 /* Error handling definitions */

    75 

    76 PyAPI_FUNC(void) PyErr_SetNone(PyObject *);

    77 PyAPI_FUNC(void) PyErr_SetObject(PyObject *, PyObject *);

    78 PyAPI_FUNC(void) PyErr_SetString(PyObject *, const char *);

    79 PyAPI_FUNC(PyObject *) PyErr_Occurred(void);

    80 PyAPI_FUNC(void) PyErr_Clear(void);

    81 PyAPI_FUNC(void) PyErr_Fetch(PyObject **, PyObject **, PyObject **);

    82 PyAPI_FUNC(void) PyErr_Restore(PyObject *, PyObject *, PyObject *);

    83 

    84 #ifdef Py_DEBUG

    85 #define _PyErr_OCCURRED() PyErr_Occurred()

    86 #else

    87 #define _PyErr_OCCURRED() (_PyThreadState_Current->curexc_type)

    88 #endif

    89 

    90 /* Error testing and normalization */

    91 PyAPI_FUNC(int) PyErr_GivenExceptionMatches(PyObject *, PyObject *);

    92 PyAPI_FUNC(int) PyErr_ExceptionMatches(PyObject *);

    93 PyAPI_FUNC(void) PyErr_NormalizeException(PyObject**, PyObject**, PyObject**);

    94 

    95 /* */

    96 

    97 #define PyExceptionClass_Check(x)					\

    98 	(PyClass_Check((x))						\

    99 	 || (PyType_Check((x)) && PyType_IsSubtype(			\

   100 		     (PyTypeObject*)(x), (PyTypeObject*)PyExc_BaseException)))

   101 

   102 

   103 #define PyExceptionInstance_Check(x)			\

   104 	(PyInstance_Check((x)) ||			\

   105 	 (PyType_IsSubtype((x)->ob_type, (PyTypeObject*)PyExc_BaseException)))

   106 

   107 #define PyExceptionClass_Name(x)				   \

   108 	(PyClass_Check((x))					   \

   109 	 ? PyString_AS_STRING(((PyClassObject*)(x))->cl_name)	   \

   110 	 : (char *)(((PyTypeObject*)(x))->tp_name))

   111 

   112 #define PyExceptionInstance_Class(x)					\

   113 	((PyInstance_Check((x))						\

   114 	  ? (PyObject*)((PyInstanceObject*)(x))->in_class		\

   115 	  : (PyObject*)((x)->ob_type)))

   116 

   117 	

   118 /* Predefined exceptions */

   119 

   120 PyAPI_DATA(PyObject *) PyExc_BaseException;

   121 PyAPI_DATA(PyObject *) PyExc_Exception;

   122 PyAPI_DATA(PyObject *) PyExc_StopIteration;

   123 PyAPI_DATA(PyObject *) PyExc_GeneratorExit;

   124 PyAPI_DATA(PyObject *) PyExc_StandardError;

   125 PyAPI_DATA(PyObject *) PyExc_ArithmeticError;

   126 PyAPI_DATA(PyObject *) PyExc_LookupError;

   127 

   128 PyAPI_DATA(PyObject *) PyExc_AssertionError;

   129 PyAPI_DATA(PyObject *) PyExc_AttributeError;

   130 PyAPI_DATA(PyObject *) PyExc_EOFError;

   131 PyAPI_DATA(PyObject *) PyExc_FloatingPointError;

   132 PyAPI_DATA(PyObject *) PyExc_EnvironmentError;

   133 PyAPI_DATA(PyObject *) PyExc_IOError;

   134 PyAPI_DATA(PyObject *) PyExc_OSError;

   135 PyAPI_DATA(PyObject *) PyExc_ImportError;

   136 PyAPI_DATA(PyObject *) PyExc_IndexError;

   137 PyAPI_DATA(PyObject *) PyExc_KeyError;

   138 PyAPI_DATA(PyObject *) PyExc_KeyboardInterrupt;

   139 PyAPI_DATA(PyObject *) PyExc_MemoryError;

   140 PyAPI_DATA(PyObject *) PyExc_NameError;

   141 PyAPI_DATA(PyObject *) PyExc_OverflowError;

   142 PyAPI_DATA(PyObject *) PyExc_RuntimeError;

   143 PyAPI_DATA(PyObject *) PyExc_NotImplementedError;

   144 PyAPI_DATA(PyObject *) PyExc_SyntaxError;

   145 PyAPI_DATA(PyObject *) PyExc_IndentationError;

   146 PyAPI_DATA(PyObject *) PyExc_TabError;

   147 PyAPI_DATA(PyObject *) PyExc_ReferenceError;

   148 PyAPI_DATA(PyObject *) PyExc_SystemError;

   149 PyAPI_DATA(PyObject *) PyExc_SystemExit;

   150 PyAPI_DATA(PyObject *) PyExc_TypeError;

   151 PyAPI_DATA(PyObject *) PyExc_UnboundLocalError;

   152 PyAPI_DATA(PyObject *) PyExc_UnicodeError;

   153 PyAPI_DATA(PyObject *) PyExc_UnicodeEncodeError;

   154 PyAPI_DATA(PyObject *) PyExc_UnicodeDecodeError;

   155 PyAPI_DATA(PyObject *) PyExc_UnicodeTranslateError;

   156 PyAPI_DATA(PyObject *) PyExc_ValueError;

   157 PyAPI_DATA(PyObject *) PyExc_ZeroDivisionError;

   158 #ifdef MS_WINDOWS

   159 PyAPI_DATA(PyObject *) PyExc_WindowsError;

   160 #endif

   161 #ifdef __VMS

   162 PyAPI_DATA(PyObject *) PyExc_VMSError;

   163 #endif

   164 

   165 PyAPI_DATA(PyObject *) PyExc_MemoryErrorInst;

   166 

   167 /* Predefined warning categories */

   168 PyAPI_DATA(PyObject *) PyExc_Warning;

   169 PyAPI_DATA(PyObject *) PyExc_UserWarning;

   170 PyAPI_DATA(PyObject *) PyExc_DeprecationWarning;

   171 PyAPI_DATA(PyObject *) PyExc_PendingDeprecationWarning;

   172 PyAPI_DATA(PyObject *) PyExc_SyntaxWarning;

   173 PyAPI_DATA(PyObject *) PyExc_RuntimeWarning;

   174 PyAPI_DATA(PyObject *) PyExc_FutureWarning;

   175 PyAPI_DATA(PyObject *) PyExc_ImportWarning;

   176 PyAPI_DATA(PyObject *) PyExc_UnicodeWarning;

   177 

   178 

   179 /* Convenience functions */

   180 

   181 PyAPI_FUNC(int) PyErr_BadArgument(void);

   182 PyAPI_FUNC(PyObject *) PyErr_NoMemory(void);

   183 PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *);

   184 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject(

   185 	PyObject *, PyObject *);

   186 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename(PyObject *, char *);

   187 #ifdef Py_WIN_WIDE_FILENAMES

   188 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename(

   189 	PyObject *, Py_UNICODE *);

   190 #endif /* Py_WIN_WIDE_FILENAMES */

   191 

   192 PyAPI_FUNC(PyObject *) PyErr_Format(PyObject *, const char *, ...)

   193 			Py_GCC_ATTRIBUTE((format(printf, 2, 3)));

   194 

   195 #ifdef MS_WINDOWS

   196 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilenameObject(

   197 	int, const char *);

   198 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename(

   199 	int, const char *);

   200 #ifdef Py_WIN_WIDE_FILENAMES

   201 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename(

   202 	int, const Py_UNICODE *);

   203 #endif /* Py_WIN_WIDE_FILENAMES */

   204 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int);

   205 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject(

   206 	PyObject *,int, PyObject *);

   207 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename(

   208 	PyObject *,int, const char *);

   209 #ifdef Py_WIN_WIDE_FILENAMES

   210 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename(

   211 	PyObject *,int, const Py_UNICODE *);

   212 #endif /* Py_WIN_WIDE_FILENAMES */

   213 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int);

   214 #endif /* MS_WINDOWS */

   215 

   216 /* Export the old function so that the existing API remains available: */

   217 PyAPI_FUNC(void) PyErr_BadInternalCall(void);

   218 PyAPI_FUNC(void) _PyErr_BadInternalCall(char *filename, int lineno);

   219 /* Mask the old API with a call to the new API for code compiled under

   220    Python 2.0: */

   221 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)

   222 

   223 /* Function to create a new exception */

   224 PyAPI_FUNC(PyObject *) PyErr_NewException(char *name, PyObject *base,

   225                                          PyObject *dict);

   226 PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject *);

   227 

   228 /* Issue a warning or exception */

   229 PyAPI_FUNC(int) PyErr_WarnEx(PyObject *category, const char *msg,

   230 			     Py_ssize_t stack_level);

   231 PyAPI_FUNC(int) PyErr_WarnExplicit(PyObject *, const char *,

   232 				   const char *, int, 

   233 				   const char *, PyObject *);

   234 /* PyErr_Warn is only for backwards compatability and will be removed.

   235    Use PyErr_WarnEx instead. */

   236 #define PyErr_Warn(category, msg) PyErr_WarnEx(category, msg, 1)

   237 

   238 /* In sigcheck.c or signalmodule.c */

   239 PyAPI_FUNC(int) PyErr_CheckSignals(void);

   240 PyAPI_FUNC(void) PyErr_SetInterrupt(void);

   241 

   242 /* Support for adding program text to SyntaxErrors */

   243 PyAPI_FUNC(void) PyErr_SyntaxLocation(const char *, int);

   244 PyAPI_FUNC(PyObject *) PyErr_ProgramText(const char *, int);

   245 

   246 #ifdef Py_USING_UNICODE

   247 /* The following functions are used to create and modify unicode

   248    exceptions from C */

   249 

   250 /* create a UnicodeDecodeError object */

   251 PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create(

   252 	const char *, const char *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);

   253 

   254 /* create a UnicodeEncodeError object */

   255 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create(

   256 	const char *, const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);

   257 

   258 /* create a UnicodeTranslateError object */

   259 PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create(

   260 	const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);

   261 

   262 /* get the encoding attribute */

   263 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *);

   264 PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetEncoding(PyObject *);

   265 

   266 /* get the object attribute */

   267 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetObject(PyObject *);

   268 PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetObject(PyObject *);

   269 PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetObject(PyObject *);

   270 

   271 /* get the value of the start attribute (the int * may not be NULL)

   272    return 0 on success, -1 on failure */

   273 PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *);

   274 PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *);

   275 PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *);

   276 

   277 /* assign a new value to the start attribute

   278    return 0 on success, -1 on failure */

   279 PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t);

   280 PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t);

   281 PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t);

   282 

   283 /* get the value of the end attribute (the int *may not be NULL)

   284  return 0 on success, -1 on failure */

   285 PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *);

   286 PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *);

   287 PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *);

   288 

   289 /* assign a new value to the end attribute

   290    return 0 on success, -1 on failure */

   291 PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t);

   292 PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t);

   293 PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t);

   294 

   295 /* get the value of the reason attribute */

   296 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetReason(PyObject *);

   297 PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetReason(PyObject *);

   298 PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetReason(PyObject *);

   299 

   300 /* assign a new value to the reason attribute

   301    return 0 on success, -1 on failure */

   302 PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason(

   303 	PyObject *, const char *);

   304 PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason(

   305 	PyObject *, const char *);

   306 PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(

   307 	PyObject *, const char *);

   308 #endif

   309 

   310 

   311 /* These APIs aren't really part of the error implementation, but

   312    often needed to format error messages; the native C lib APIs are

   313    not available on all platforms, which is why we provide emulations

   314    for those platforms in Python/mysnprintf.c,

   315    WARNING:  The return value of snprintf varies across platforms; do

   316    not rely on any particular behavior; eventually the C99 defn may

   317    be reliable.

   318 */

   319 #if defined(MS_WIN32) && !defined(HAVE_SNPRINTF)

   320 # define HAVE_SNPRINTF

   321 # define snprintf _snprintf

   322 # define vsnprintf _vsnprintf

   323 #endif

   324 

   325 #include <stdarg.h>

   326 PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char  *format, ...)

   327 			Py_GCC_ATTRIBUTE((format(printf, 3, 4)));

   328 PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char  *format, va_list va)

   329 			Py_GCC_ATTRIBUTE((format(printf, 3, 0)));

   330 

   331 #ifdef __cplusplus

   332 }

   333 #endif

   334 #endif /* !Py_ERRORS_H */