blob: 345a345afe4d1498e50992148efd7e262b21bfb3 [file] [log] [blame]
Guido van Rossumf70e43a1991-02-19 12:39:46 +00001
Guido van Rossum373c8691997-04-29 18:22:47 +00002/* Error handling */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00003
Guido van Rossum373c8691997-04-29 18:22:47 +00004#include "Python.h"
Guido van Rossumf22120a1990-12-20 23:05:40 +00005
Guido van Rossum53e8d441995-03-09 12:11:31 +00006#ifndef __STDC__
Guido van Rossum7844e381997-04-11 20:44:04 +00007#ifndef MS_WINDOWS
Tim Petersdbd9ba62000-07-09 03:09:57 +00008extern char *strerror(int);
Guido van Rossum53e8d441995-03-09 12:11:31 +00009#endif
Guido van Rossum7844e381997-04-11 20:44:04 +000010#endif
Guido van Rossumf5401bd1990-11-02 17:50:28 +000011
Martin v. Löwis6238d2b2002-06-30 15:26:10 +000012#ifdef MS_WINDOWS
Martin v. Löwis5d12abe2007-09-03 07:40:24 +000013#include <windows.h>
14#include <winbase.h>
Guido van Rossum743007d1999-04-21 15:27:31 +000015#endif
16
Jeremy Hyltonb69a27e2000-09-01 03:49:47 +000017#include <ctype.h>
18
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000019#ifdef __cplusplus
20extern "C" {
21#endif
22
23
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000024void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +000025PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
Guido van Rossum1ae940a1995-01-02 19:04:15 +000026{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000027 PyThreadState *tstate = PyThreadState_GET();
28 PyObject *oldtype, *oldvalue, *oldtraceback;
Guido van Rossum1ae940a1995-01-02 19:04:15 +000029
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000030 if (traceback != NULL && !PyTraceBack_Check(traceback)) {
31 /* XXX Should never happen -- fatal error instead? */
32 /* Well, it could be None. */
33 Py_DECREF(traceback);
34 traceback = NULL;
35 }
Guido van Rossuma027efa1997-05-05 20:56:21 +000036
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000037 /* 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;
Guido van Rossuma027efa1997-05-05 20:56:21 +000042
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000043 tstate->curexc_type = type;
44 tstate->curexc_value = value;
45 tstate->curexc_traceback = traceback;
Guido van Rossuma027efa1997-05-05 20:56:21 +000046
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000047 Py_XDECREF(oldtype);
48 Py_XDECREF(oldvalue);
49 Py_XDECREF(oldtraceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +000050}
51
52void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +000053PyErr_SetObject(PyObject *exception, PyObject *value)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000054{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000055 PyThreadState *tstate = PyThreadState_GET();
56 PyObject *exc_value;
57 PyObject *tb = NULL;
Guido van Rossumb4fb6e42008-06-14 20:20:24 +000058
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000059 if (exception != NULL &&
60 !PyExceptionClass_Check(exception)) {
61 PyErr_Format(PyExc_SystemError,
62 "exception %R not a BaseException subclass",
63 exception);
64 return;
65 }
66 Py_XINCREF(value);
67 exc_value = tstate->exc_value;
68 if (exc_value != NULL && exc_value != Py_None) {
69 /* Implicit exception chaining */
70 Py_INCREF(exc_value);
71 if (value == NULL || !PyExceptionInstance_Check(value)) {
72 /* We must normalize the value right now */
73 PyObject *args, *fixed_value;
74 if (value == NULL || value == Py_None)
75 args = PyTuple_New(0);
76 else if (PyTuple_Check(value)) {
77 Py_INCREF(value);
78 args = value;
79 }
80 else
81 args = PyTuple_Pack(1, value);
82 fixed_value = args ?
83 PyEval_CallObject(exception, args) : NULL;
84 Py_XDECREF(args);
85 Py_XDECREF(value);
86 if (fixed_value == NULL)
87 return;
88 value = fixed_value;
89 }
90 /* Avoid reference cycles through the context chain.
91 This is O(chain length) but context chains are
92 usually very short. Sensitive readers may try
93 to inline the call to PyException_GetContext. */
94 if (exc_value != value) {
95 PyObject *o = exc_value, *context;
96 while ((context = PyException_GetContext(o))) {
97 Py_DECREF(context);
98 if (context == value) {
99 PyException_SetContext(o, NULL);
100 break;
101 }
102 o = context;
103 }
104 PyException_SetContext(value, exc_value);
105 } else {
106 Py_DECREF(exc_value);
107 }
108 }
109 if (value != NULL && PyExceptionInstance_Check(value))
110 tb = PyException_GetTraceback(value);
111 Py_XINCREF(exception);
112 PyErr_Restore(exception, value, tb);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000113}
114
115void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000116PyErr_SetNone(PyObject *exception)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000117{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000118 PyErr_SetObject(exception, (PyObject *)NULL);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000119}
120
121void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000122PyErr_SetString(PyObject *exception, const char *string)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000123{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000124 PyObject *value = PyUnicode_FromString(string);
125 PyErr_SetObject(exception, value);
126 Py_XDECREF(value);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000127}
128
Guido van Rossum3a241811994-08-29 12:14:12 +0000129
Guido van Rossum373c8691997-04-29 18:22:47 +0000130PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000131PyErr_Occurred(void)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000132{
Jeffrey Yasskin8e0bdfd2010-05-13 18:31:05 +0000133 /* If there is no thread state, PyThreadState_GET calls
134 Py_FatalError, which calls PyErr_Occurred. To avoid the
135 resulting infinite loop, we inline PyThreadState_GET here and
136 treat no thread as no error. */
137 PyThreadState *tstate =
138 ((PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current));
Guido van Rossuma027efa1997-05-05 20:56:21 +0000139
Jeffrey Yasskin8e0bdfd2010-05-13 18:31:05 +0000140 return tstate == NULL ? NULL : tstate->curexc_type;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000141}
142
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000143
144int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000145PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000146{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000147 if (err == NULL || exc == NULL) {
148 /* maybe caused by "import exceptions" that failed early on */
149 return 0;
150 }
151 if (PyTuple_Check(exc)) {
152 Py_ssize_t i, n;
153 n = PyTuple_Size(exc);
154 for (i = 0; i < n; i++) {
155 /* Test recursively */
156 if (PyErr_GivenExceptionMatches(
157 err, PyTuple_GET_ITEM(exc, i)))
158 {
159 return 1;
160 }
161 }
162 return 0;
163 }
164 /* err might be an instance, so check its class. */
165 if (PyExceptionInstance_Check(err))
166 err = PyExceptionInstance_Class(err);
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000167
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000168 if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
169 int res = 0;
170 PyObject *exception, *value, *tb;
171 PyErr_Fetch(&exception, &value, &tb);
172 /* PyObject_IsSubclass() can recurse and therefore is
173 not safe (see test_bad_getattr in test.pickletester). */
174 res = PyType_IsSubtype((PyTypeObject *)err, (PyTypeObject *)exc);
175 /* This function must not fail, so print the error here */
176 if (res == -1) {
177 PyErr_WriteUnraisable(err);
178 res = 0;
179 }
180 PyErr_Restore(exception, value, tb);
181 return res;
182 }
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000183
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000184 return err == exc;
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000185}
Guido van Rossum743007d1999-04-21 15:27:31 +0000186
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000187
188int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000189PyErr_ExceptionMatches(PyObject *exc)
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000190{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000191 return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000192}
193
194
195/* Used in many places to normalize a raised exception, including in
196 eval_code2(), do_raise(), and PyErr_Print()
Benjamin Petersone6528212008-07-15 15:32:09 +0000197
198 XXX: should PyErr_NormalizeException() also call
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000199 PyException_SetTraceback() with the resulting value and tb?
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000200*/
201void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000202PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb)
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000203{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000204 PyObject *type = *exc;
205 PyObject *value = *val;
206 PyObject *inclass = NULL;
207 PyObject *initial_tb = NULL;
208 PyThreadState *tstate = NULL;
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000209
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000210 if (type == NULL) {
211 /* There was no exception, so nothing to do. */
212 return;
213 }
Guido van Rossumed473a42000-08-07 19:18:27 +0000214
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000215 /* If PyErr_SetNone() was used, the value will have been actually
216 set to NULL.
217 */
218 if (!value) {
219 value = Py_None;
220 Py_INCREF(value);
221 }
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000222
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000223 if (PyExceptionInstance_Check(value))
224 inclass = PyExceptionInstance_Class(value);
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000225
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000226 /* Normalize the exception so that if the type is a class, the
227 value will be an instance.
228 */
229 if (PyExceptionClass_Check(type)) {
230 /* if the value was not an instance, or is not an instance
231 whose class is (or is derived from) type, then use the
232 value as an argument to instantiation of the type
233 class.
234 */
235 if (!inclass || !PyObject_IsSubclass(inclass, type)) {
236 PyObject *args, *res;
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000237
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000238 if (value == Py_None)
239 args = PyTuple_New(0);
240 else if (PyTuple_Check(value)) {
241 Py_INCREF(value);
242 args = value;
243 }
244 else
245 args = PyTuple_Pack(1, value);
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000246
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000247 if (args == NULL)
248 goto finally;
249 res = PyEval_CallObject(type, args);
250 Py_DECREF(args);
251 if (res == NULL)
252 goto finally;
253 Py_DECREF(value);
254 value = res;
255 }
256 /* if the class of the instance doesn't exactly match the
257 class of the type, believe the instance
258 */
259 else if (inclass != type) {
260 Py_DECREF(type);
261 type = inclass;
262 Py_INCREF(type);
263 }
264 }
265 *exc = type;
266 *val = value;
267 return;
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000268finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000269 Py_DECREF(type);
270 Py_DECREF(value);
271 /* If the new exception doesn't set a traceback and the old
272 exception had a traceback, use the old traceback for the
273 new exception. It's better than nothing.
274 */
275 initial_tb = *tb;
276 PyErr_Fetch(exc, val, tb);
277 if (initial_tb != NULL) {
278 if (*tb == NULL)
279 *tb = initial_tb;
280 else
281 Py_DECREF(initial_tb);
282 }
283 /* normalize recursively */
284 tstate = PyThreadState_GET();
285 if (++tstate->recursion_depth > Py_GetRecursionLimit()) {
286 --tstate->recursion_depth;
287 /* throw away the old exception... */
288 Py_DECREF(*exc);
289 Py_DECREF(*val);
290 /* ... and use the recursion error instead */
291 *exc = PyExc_RuntimeError;
292 *val = PyExc_RecursionErrorInst;
293 Py_INCREF(*exc);
294 Py_INCREF(*val);
295 /* just keeping the old traceback */
296 return;
297 }
298 PyErr_NormalizeException(exc, val, tb);
299 --tstate->recursion_depth;
Barry Warsawc0dc92a1997-08-22 21:22:58 +0000300}
301
302
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000303void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000304PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000305{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000306 PyThreadState *tstate = PyThreadState_GET();
Guido van Rossuma027efa1997-05-05 20:56:21 +0000307
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000308 *p_type = tstate->curexc_type;
309 *p_value = tstate->curexc_value;
310 *p_traceback = tstate->curexc_traceback;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000311
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000312 tstate->curexc_type = NULL;
313 tstate->curexc_value = NULL;
314 tstate->curexc_traceback = NULL;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000315}
316
317void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000318PyErr_Clear(void)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000319{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000320 PyErr_Restore(NULL, NULL, NULL);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000321}
Guido van Rossum7d310eb1990-10-14 20:00:05 +0000322
323/* Convenience functions to set a type error exception and return 0 */
324
325int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000326PyErr_BadArgument(void)
Guido van Rossum7d310eb1990-10-14 20:00:05 +0000327{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000328 PyErr_SetString(PyExc_TypeError,
329 "bad argument type for built-in operation");
330 return 0;
Guido van Rossum7d310eb1990-10-14 20:00:05 +0000331}
332
Guido van Rossum373c8691997-04-29 18:22:47 +0000333PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000334PyErr_NoMemory(void)
Guido van Rossum7d310eb1990-10-14 20:00:05 +0000335{
Antoine Pitrou07e20ef2010-10-28 22:56:58 +0000336 PyErr_SetNone(PyExc_MemoryError);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000337 return NULL;
Guido van Rossum7d310eb1990-10-14 20:00:05 +0000338}
339
Guido van Rossum373c8691997-04-29 18:22:47 +0000340PyObject *
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000341PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject)
Guido van Rossum7d310eb1990-10-14 20:00:05 +0000342{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000343 PyObject *message;
Antoine Pitrou5d6fbe82011-10-12 19:39:57 +0200344 PyObject *v, *args;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000345 int i = errno;
Victor Stinner1f33f2b2011-12-17 04:45:09 +0100346#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000347 WCHAR *s_buf = NULL;
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000348#endif /* Unix/Windows */
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000349
Guido van Rossume9fbc091995-02-18 14:52:19 +0000350#ifdef EINTR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000351 if (i == EINTR && PyErr_CheckSignals())
352 return NULL;
Guido van Rossume9fbc091995-02-18 14:52:19 +0000353#endif
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000354
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000355#ifndef MS_WINDOWS
Victor Stinner1f33f2b2011-12-17 04:45:09 +0100356 if (i != 0) {
357 char *s = strerror(i);
Victor Stinner1b579672011-12-17 05:47:23 +0100358 message = PyUnicode_DecodeLocale(s, "surrogateescape");
Victor Stinner1f33f2b2011-12-17 04:45:09 +0100359 }
360 else {
361 /* Sometimes errno didn't get set */
362 message = PyUnicode_FromString("Error");
363 }
Guido van Rossum743007d1999-04-21 15:27:31 +0000364#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000365 if (i == 0)
366 message = PyUnicode_FromString("Error"); /* Sometimes errno didn't get set */
367 else
368 {
369 /* Note that the Win32 errors do not lineup with the
370 errno error. So if the error is in the MSVC error
371 table, we use it, otherwise we assume it really _is_
372 a Win32 error code
373 */
374 if (i > 0 && i < _sys_nerr) {
375 message = PyUnicode_FromString(_sys_errlist[i]);
376 }
377 else {
378 int len = FormatMessageW(
379 FORMAT_MESSAGE_ALLOCATE_BUFFER |
380 FORMAT_MESSAGE_FROM_SYSTEM |
381 FORMAT_MESSAGE_IGNORE_INSERTS,
382 NULL, /* no message source */
383 i,
384 MAKELANGID(LANG_NEUTRAL,
385 SUBLANG_DEFAULT),
386 /* Default language */
387 (LPWSTR) &s_buf,
388 0, /* size not used */
389 NULL); /* no args */
390 if (len==0) {
391 /* Only ever seen this in out-of-mem
392 situations */
393 s_buf = NULL;
394 message = PyUnicode_FromFormat("Windows Error 0x%X", i);
395 } else {
396 /* remove trailing cr/lf and dots */
397 while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.'))
398 s_buf[--len] = L'\0';
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200399 message = PyUnicode_FromWideChar(s_buf, len);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000400 }
401 }
402 }
Martin v. Löwis3484a182002-03-09 12:07:51 +0000403#endif /* Unix/Windows */
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000404
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000405 if (message == NULL)
406 {
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000407#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000408 LocalFree(s_buf);
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000409#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000410 return NULL;
411 }
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000412
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000413 if (filenameObject != NULL)
Antoine Pitrou5d6fbe82011-10-12 19:39:57 +0200414 args = Py_BuildValue("(iOO)", i, message, filenameObject);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000415 else
Antoine Pitrou5d6fbe82011-10-12 19:39:57 +0200416 args = Py_BuildValue("(iO)", i, message);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000417 Py_DECREF(message);
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000418
Antoine Pitrou5d6fbe82011-10-12 19:39:57 +0200419 if (args != NULL) {
420 v = PyObject_Call(exc, args, NULL);
421 Py_DECREF(args);
422 if (v != NULL) {
423 PyErr_SetObject((PyObject *) Py_TYPE(v), v);
424 Py_DECREF(v);
425 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000426 }
Martin v. Löwis6238d2b2002-06-30 15:26:10 +0000427#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000428 LocalFree(s_buf);
Guido van Rossum743007d1999-04-21 15:27:31 +0000429#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000430 return NULL;
Guido van Rossum7d310eb1990-10-14 20:00:05 +0000431}
Guido van Rossum743007d1999-04-21 15:27:31 +0000432
Barry Warsaw97d95151998-07-23 16:05:56 +0000433
434PyObject *
Neal Norwitzb382b842007-08-24 20:00:37 +0000435PyErr_SetFromErrnoWithFilename(PyObject *exc, const char *filename)
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000436{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000437 PyObject *name = filename ? PyUnicode_DecodeFSDefault(filename) : NULL;
438 PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
439 Py_XDECREF(name);
440 return result;
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000441}
442
Hirokazu Yamamoto8223c242009-05-17 04:21:53 +0000443#ifdef MS_WINDOWS
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000444PyObject *
Neal Norwitzb382b842007-08-24 20:00:37 +0000445PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, const Py_UNICODE *filename)
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000446{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000447 PyObject *name = filename ?
448 PyUnicode_FromUnicode(filename, wcslen(filename)) :
449 NULL;
450 PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
451 Py_XDECREF(name);
452 return result;
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000453}
Hirokazu Yamamoto8223c242009-05-17 04:21:53 +0000454#endif /* MS_WINDOWS */
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000455
456PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000457PyErr_SetFromErrno(PyObject *exc)
Barry Warsaw97d95151998-07-23 16:05:56 +0000458{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000459 return PyErr_SetFromErrnoWithFilenameObject(exc, NULL);
Barry Warsaw97d95151998-07-23 16:05:56 +0000460}
Guido van Rossum683a0721990-10-21 22:09:12 +0000461
Brett Cannonbf364092006-03-01 04:25:17 +0000462#ifdef MS_WINDOWS
Guido van Rossum795e1892000-02-17 15:19:15 +0000463/* Windows specific error code handling */
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000464PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject(
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000465 PyObject *exc,
466 int ierr,
467 PyObject *filenameObject)
Guido van Rossum795e1892000-02-17 15:19:15 +0000468{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000469 int len;
470 WCHAR *s_buf = NULL; /* Free via LocalFree */
471 PyObject *message;
Victor Stinner9ea8e4c2011-10-17 20:18:58 +0200472 PyObject *args, *v;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000473 DWORD err = (DWORD)ierr;
474 if (err==0) err = GetLastError();
475 len = FormatMessageW(
476 /* Error API error */
477 FORMAT_MESSAGE_ALLOCATE_BUFFER |
478 FORMAT_MESSAGE_FROM_SYSTEM |
479 FORMAT_MESSAGE_IGNORE_INSERTS,
480 NULL, /* no message source */
481 err,
482 MAKELANGID(LANG_NEUTRAL,
483 SUBLANG_DEFAULT), /* Default language */
484 (LPWSTR) &s_buf,
485 0, /* size not used */
486 NULL); /* no args */
487 if (len==0) {
488 /* Only seen this in out of mem situations */
489 message = PyUnicode_FromFormat("Windows Error 0x%X", err);
490 s_buf = NULL;
491 } else {
492 /* remove trailing cr/lf and dots */
493 while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.'))
494 s_buf[--len] = L'\0';
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200495 message = PyUnicode_FromWideChar(s_buf, len);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000496 }
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000497
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000498 if (message == NULL)
499 {
500 LocalFree(s_buf);
501 return NULL;
502 }
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000503
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200504 if (filenameObject == NULL)
505 filenameObject = Py_None;
506 /* This is the constructor signature for passing a Windows error code.
507 The POSIX translation will be figured out by the constructor. */
Victor Stinner9ea8e4c2011-10-17 20:18:58 +0200508 args = Py_BuildValue("(iOOi)", 0, message, filenameObject, err);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000509 Py_DECREF(message);
Martin v. Löwis5d12abe2007-09-03 07:40:24 +0000510
Victor Stinner9ea8e4c2011-10-17 20:18:58 +0200511 if (args != NULL) {
512 v = PyObject_Call(exc, args, NULL);
513 Py_DECREF(args);
514 if (v != NULL) {
515 PyErr_SetObject((PyObject *) Py_TYPE(v), v);
516 Py_DECREF(v);
517 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000518 }
519 LocalFree(s_buf);
520 return NULL;
Guido van Rossum795e1892000-02-17 15:19:15 +0000521}
522
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000523PyObject *PyErr_SetExcFromWindowsErrWithFilename(
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000524 PyObject *exc,
525 int ierr,
526 const char *filename)
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000527{
Victor Stinner92be9392010-12-28 00:28:21 +0000528 PyObject *name = filename ? PyUnicode_DecodeFSDefault(filename) : NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000529 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
530 ierr,
531 name);
532 Py_XDECREF(name);
533 return ret;
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000534}
535
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000536PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename(
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000537 PyObject *exc,
538 int ierr,
539 const Py_UNICODE *filename)
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000540{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000541 PyObject *name = filename ?
542 PyUnicode_FromUnicode(filename, wcslen(filename)) :
543 NULL;
544 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
545 ierr,
546 name);
547 Py_XDECREF(name);
548 return ret;
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000549}
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000550
Thomas Heller085358a2002-07-29 14:27:41 +0000551PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr)
552{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000553 return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL);
Thomas Heller085358a2002-07-29 14:27:41 +0000554}
555
Guido van Rossum795e1892000-02-17 15:19:15 +0000556PyObject *PyErr_SetFromWindowsErr(int ierr)
557{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000558 return PyErr_SetExcFromWindowsErrWithFilename(PyExc_WindowsError,
559 ierr, NULL);
Thomas Heller085358a2002-07-29 14:27:41 +0000560}
561PyObject *PyErr_SetFromWindowsErrWithFilename(
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000562 int ierr,
563 const char *filename)
Thomas Heller085358a2002-07-29 14:27:41 +0000564{
Victor Stinner92be9392010-12-28 00:28:21 +0000565 PyObject *name = filename ? PyUnicode_DecodeFSDefault(filename) : NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000566 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
567 PyExc_WindowsError,
568 ierr, name);
569 Py_XDECREF(name);
570 return result;
Guido van Rossum795e1892000-02-17 15:19:15 +0000571}
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000572
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000573PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename(
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000574 int ierr,
575 const Py_UNICODE *filename)
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000576{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000577 PyObject *name = filename ?
578 PyUnicode_FromUnicode(filename, wcslen(filename)) :
579 NULL;
580 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
581 PyExc_WindowsError,
582 ierr, name);
583 Py_XDECREF(name);
584 return result;
Mark Hammondc2e85bd2002-10-03 05:10:39 +0000585}
Guido van Rossum795e1892000-02-17 15:19:15 +0000586#endif /* MS_WINDOWS */
587
Brett Cannon79ec55e2012-04-12 20:24:54 -0400588PyObject *
589PyErr_SetExcWithArgsKwargs(PyObject *exc, PyObject *args, PyObject *kwargs)
590{
591 PyObject *val;
592
593 /* args must at least be an empty tuple */
594 if (args == NULL)
595 args = PyTuple_New(0);
596
597 val = PyObject_Call(exc, args, kwargs);
598 if (val != NULL) {
599 PyErr_SetObject((PyObject *) Py_TYPE(val), val);
600 Py_DECREF(val);
601 }
602
603 return NULL;
604}
605
606PyObject *
607PyErr_SetFromImportErrorWithNameAndPath(PyObject *msg,
608 PyObject *name, PyObject *path)
609{
610 PyObject *args = PyTuple_New(1);
611 PyObject *kwargs = PyDict_New();
612 PyObject *result;
613
614 if (path == NULL)
615 path = Py_None;
616
617 PyTuple_SetItem(args, 0, msg);
618 PyDict_SetItemString(kwargs, "name", name);
619 PyDict_SetItemString(kwargs, "path", path);
620
621 result = PyErr_SetExcWithArgsKwargs(PyExc_ImportError, args, kwargs);
622
623 Py_DECREF(args);
624 Py_DECREF(kwargs);
625
626 return result;
627}
628
629PyObject *
630PyErr_SetFromImportErrorWithName(PyObject *msg, PyObject *name)
631{
632 return PyErr_SetFromImportErrorWithNameAndPath(msg, name, NULL);
633}
634
Guido van Rossum683a0721990-10-21 22:09:12 +0000635void
Neal Norwitzb382b842007-08-24 20:00:37 +0000636_PyErr_BadInternalCall(const char *filename, int lineno)
Fred Drake6d63adf2000-08-24 22:38:39 +0000637{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000638 PyErr_Format(PyExc_SystemError,
639 "%s:%d: bad argument to internal function",
640 filename, lineno);
Fred Drake6d63adf2000-08-24 22:38:39 +0000641}
642
643/* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can
644 export the entry point for existing object code: */
645#undef PyErr_BadInternalCall
646void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000647PyErr_BadInternalCall(void)
Guido van Rossum683a0721990-10-21 22:09:12 +0000648{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000649 PyErr_Format(PyExc_SystemError,
650 "bad argument to internal function");
Guido van Rossum683a0721990-10-21 22:09:12 +0000651}
Fred Drake6d63adf2000-08-24 22:38:39 +0000652#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
653
Guido van Rossum1548bac1997-02-14 17:09:47 +0000654
655
Guido van Rossum1548bac1997-02-14 17:09:47 +0000656PyObject *
657PyErr_Format(PyObject *exception, const char *format, ...)
Guido van Rossum1548bac1997-02-14 17:09:47 +0000658{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000659 va_list vargs;
660 PyObject* string;
Guido van Rossum1548bac1997-02-14 17:09:47 +0000661
Jeremy Hyltonb69a27e2000-09-01 03:49:47 +0000662#ifdef HAVE_STDARG_PROTOTYPES
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000663 va_start(vargs, format);
Jeremy Hyltonb69a27e2000-09-01 03:49:47 +0000664#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000665 va_start(vargs);
Jeremy Hyltonb69a27e2000-09-01 03:49:47 +0000666#endif
Guido van Rossum1548bac1997-02-14 17:09:47 +0000667
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000668 string = PyUnicode_FromFormatV(format, vargs);
669 PyErr_SetObject(exception, string);
670 Py_XDECREF(string);
671 va_end(vargs);
672 return NULL;
Guido van Rossum1548bac1997-02-14 17:09:47 +0000673}
Guido van Rossum7617e051997-09-16 18:43:50 +0000674
675
Thomas Wouters477c8d52006-05-27 19:21:47 +0000676
Guido van Rossum7617e051997-09-16 18:43:50 +0000677PyObject *
Neal Norwitzb382b842007-08-24 20:00:37 +0000678PyErr_NewException(const char *name, PyObject *base, PyObject *dict)
Guido van Rossum7617e051997-09-16 18:43:50 +0000679{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000680 const char *dot;
681 PyObject *modulename = NULL;
682 PyObject *classname = NULL;
683 PyObject *mydict = NULL;
684 PyObject *bases = NULL;
685 PyObject *result = NULL;
686 dot = strrchr(name, '.');
687 if (dot == NULL) {
688 PyErr_SetString(PyExc_SystemError,
689 "PyErr_NewException: name must be module.class");
690 return NULL;
691 }
692 if (base == NULL)
693 base = PyExc_Exception;
694 if (dict == NULL) {
695 dict = mydict = PyDict_New();
696 if (dict == NULL)
697 goto failure;
698 }
699 if (PyDict_GetItemString(dict, "__module__") == NULL) {
700 modulename = PyUnicode_FromStringAndSize(name,
701 (Py_ssize_t)(dot-name));
702 if (modulename == NULL)
703 goto failure;
704 if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
705 goto failure;
706 }
707 if (PyTuple_Check(base)) {
708 bases = base;
709 /* INCREF as we create a new ref in the else branch */
710 Py_INCREF(bases);
711 } else {
712 bases = PyTuple_Pack(1, base);
713 if (bases == NULL)
714 goto failure;
715 }
Florent Xiclunaaa6c1d22011-12-12 18:54:29 +0100716 /* Create a real class. */
Victor Stinner7eeb5b52010-06-07 19:57:46 +0000717 result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000718 dot+1, bases, dict);
Guido van Rossum7617e051997-09-16 18:43:50 +0000719 failure:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000720 Py_XDECREF(bases);
721 Py_XDECREF(mydict);
722 Py_XDECREF(classname);
723 Py_XDECREF(modulename);
724 return result;
Guido van Rossum7617e051997-09-16 18:43:50 +0000725}
Jeremy Hyltonb709df32000-09-01 02:47:25 +0000726
Georg Brandl1e28a272009-12-28 08:41:01 +0000727
728/* Create an exception with docstring */
729PyObject *
730PyErr_NewExceptionWithDoc(const char *name, const char *doc,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000731 PyObject *base, PyObject *dict)
Georg Brandl1e28a272009-12-28 08:41:01 +0000732{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000733 int result;
734 PyObject *ret = NULL;
735 PyObject *mydict = NULL; /* points to the dict only if we create it */
736 PyObject *docobj;
Georg Brandl1e28a272009-12-28 08:41:01 +0000737
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000738 if (dict == NULL) {
739 dict = mydict = PyDict_New();
740 if (dict == NULL) {
741 return NULL;
742 }
743 }
Georg Brandl1e28a272009-12-28 08:41:01 +0000744
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000745 if (doc != NULL) {
746 docobj = PyUnicode_FromString(doc);
747 if (docobj == NULL)
748 goto failure;
749 result = PyDict_SetItemString(dict, "__doc__", docobj);
750 Py_DECREF(docobj);
751 if (result < 0)
752 goto failure;
753 }
Georg Brandl1e28a272009-12-28 08:41:01 +0000754
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000755 ret = PyErr_NewException(name, base, dict);
Georg Brandl1e28a272009-12-28 08:41:01 +0000756 failure:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000757 Py_XDECREF(mydict);
758 return ret;
Georg Brandl1e28a272009-12-28 08:41:01 +0000759}
760
761
Jeremy Hyltonb709df32000-09-01 02:47:25 +0000762/* Call when an exception has occurred but there is no way for Python
763 to handle it. Examples: exception in __del__ or during GC. */
764void
765PyErr_WriteUnraisable(PyObject *obj)
766{
Martin v. Löwisbd928fe2011-10-14 10:20:37 +0200767 _Py_IDENTIFIER(__module__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000768 PyObject *f, *t, *v, *tb;
769 PyErr_Fetch(&t, &v, &tb);
770 f = PySys_GetObject("stderr");
771 if (f != NULL && f != Py_None) {
772 PyFile_WriteString("Exception ", f);
773 if (t) {
774 PyObject* moduleName;
775 char* className;
776 assert(PyExceptionClass_Check(t));
777 className = PyExceptionClass_Name(t);
778 if (className != NULL) {
779 char *dot = strrchr(className, '.');
780 if (dot != NULL)
781 className = dot+1;
782 }
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000783
Martin v. Löwis1ee1b6f2011-10-10 18:11:30 +0200784 moduleName = _PyObject_GetAttrId(t, &PyId___module__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000785 if (moduleName == NULL)
786 PyFile_WriteString("<unknown>", f);
787 else {
788 char* modstr = _PyUnicode_AsString(moduleName);
789 if (modstr &&
790 strcmp(modstr, "builtins") != 0)
791 {
792 PyFile_WriteString(modstr, f);
793 PyFile_WriteString(".", f);
794 }
795 }
796 if (className == NULL)
797 PyFile_WriteString("<unknown>", f);
798 else
799 PyFile_WriteString(className, f);
800 if (v && v != Py_None) {
801 PyFile_WriteString(": ", f);
802 PyFile_WriteObject(v, f, 0);
803 }
804 Py_XDECREF(moduleName);
805 }
Georg Brandl08be72d2010-10-24 15:11:22 +0000806 if (obj) {
807 PyFile_WriteString(" in ", f);
808 PyFile_WriteObject(obj, f, 0);
809 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000810 PyFile_WriteString(" ignored\n", f);
811 PyErr_Clear(); /* Just in case */
812 }
813 Py_XDECREF(t);
814 Py_XDECREF(v);
815 Py_XDECREF(tb);
Jeremy Hyltonb709df32000-09-01 02:47:25 +0000816}
Guido van Rossumcfd42b52000-12-15 21:58:52 +0000817
Armin Rigo092381a2003-10-25 14:29:27 +0000818extern PyObject *PyModule_GetWarningsModule(void);
Guido van Rossumcfd42b52000-12-15 21:58:52 +0000819
Guido van Rossum2fd45652001-02-28 21:46:24 +0000820
Benjamin Peterson2c539712010-09-20 22:42:10 +0000821void
822PyErr_SyntaxLocation(const char *filename, int lineno) {
823 PyErr_SyntaxLocationEx(filename, lineno, -1);
824}
825
826
Martin v. Löwiscfeb3b62002-03-03 21:30:27 +0000827/* Set file and line information for the current exception.
828 If the exception is not a SyntaxError, also sets additional attributes
829 to make printing of exceptions believe it is a syntax error. */
Guido van Rossum2fd45652001-02-28 21:46:24 +0000830
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +0000831void
Benjamin Peterson2c539712010-09-20 22:42:10 +0000832PyErr_SyntaxLocationEx(const char *filename, int lineno, int col_offset)
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +0000833{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000834 PyObject *exc, *v, *tb, *tmp;
Martin v. Löwis1c67dd92011-10-14 15:16:45 +0200835 _Py_IDENTIFIER(filename);
836 _Py_IDENTIFIER(lineno);
837 _Py_IDENTIFIER(msg);
838 _Py_IDENTIFIER(offset);
839 _Py_IDENTIFIER(print_file_and_line);
840 _Py_IDENTIFIER(text);
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +0000841
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000842 /* add attributes for the line number and filename for the error */
843 PyErr_Fetch(&exc, &v, &tb);
844 PyErr_NormalizeException(&exc, &v, &tb);
845 /* XXX check that it is, indeed, a syntax error. It might not
846 * be, though. */
847 tmp = PyLong_FromLong(lineno);
848 if (tmp == NULL)
849 PyErr_Clear();
850 else {
Martin v. Löwis1c67dd92011-10-14 15:16:45 +0200851 if (_PyObject_SetAttrId(v, &PyId_lineno, tmp))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000852 PyErr_Clear();
853 Py_DECREF(tmp);
854 }
Benjamin Peterson2c539712010-09-20 22:42:10 +0000855 if (col_offset >= 0) {
856 tmp = PyLong_FromLong(col_offset);
857 if (tmp == NULL)
858 PyErr_Clear();
859 else {
Martin v. Löwis1c67dd92011-10-14 15:16:45 +0200860 if (_PyObject_SetAttrId(v, &PyId_offset, tmp))
Benjamin Peterson2c539712010-09-20 22:42:10 +0000861 PyErr_Clear();
862 Py_DECREF(tmp);
863 }
864 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000865 if (filename != NULL) {
Victor Stinner15a71cd2010-10-17 19:03:16 +0000866 tmp = PyUnicode_DecodeFSDefault(filename);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000867 if (tmp == NULL)
868 PyErr_Clear();
869 else {
Martin v. Löwis1c67dd92011-10-14 15:16:45 +0200870 if (_PyObject_SetAttrId(v, &PyId_filename, tmp))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000871 PyErr_Clear();
872 Py_DECREF(tmp);
873 }
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +0000874
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000875 tmp = PyErr_ProgramText(filename, lineno);
876 if (tmp) {
Martin v. Löwis1c67dd92011-10-14 15:16:45 +0200877 if (_PyObject_SetAttrId(v, &PyId_text, tmp))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000878 PyErr_Clear();
879 Py_DECREF(tmp);
880 }
881 }
Martin v. Löwis1c67dd92011-10-14 15:16:45 +0200882 if (_PyObject_SetAttrId(v, &PyId_offset, Py_None)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000883 PyErr_Clear();
884 }
885 if (exc != PyExc_SyntaxError) {
Martin v. Löwis1c67dd92011-10-14 15:16:45 +0200886 if (!_PyObject_HasAttrId(v, &PyId_msg)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000887 tmp = PyObject_Str(v);
888 if (tmp) {
Martin v. Löwis1c67dd92011-10-14 15:16:45 +0200889 if (_PyObject_SetAttrId(v, &PyId_msg, tmp))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000890 PyErr_Clear();
891 Py_DECREF(tmp);
892 } else {
893 PyErr_Clear();
894 }
895 }
Martin v. Löwis1c67dd92011-10-14 15:16:45 +0200896 if (!_PyObject_HasAttrId(v, &PyId_print_file_and_line)) {
897 if (_PyObject_SetAttrId(v, &PyId_print_file_and_line,
898 Py_None))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000899 PyErr_Clear();
900 }
901 }
902 PyErr_Restore(exc, v, tb);
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +0000903}
904
Guido van Rossumebe8f8a2007-10-10 18:53:36 +0000905/* Attempt to load the line of text that the exception refers to. If it
906 fails, it will return NULL but will not set an exception.
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +0000907
908 XXX The functionality of this function is quite similar to the
Guido van Rossumebe8f8a2007-10-10 18:53:36 +0000909 functionality in tb_displayline() in traceback.c. */
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +0000910
911PyObject *
Martin v. Löwis95292d62002-12-11 14:04:59 +0000912PyErr_ProgramText(const char *filename, int lineno)
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +0000913{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000914 FILE *fp;
915 int i;
916 char linebuf[1000];
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +0000917
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000918 if (filename == NULL || *filename == '\0' || lineno <= 0)
919 return NULL;
920 fp = fopen(filename, "r" PY_STDIOTEXTMODE);
921 if (fp == NULL)
922 return NULL;
923 for (i = 0; i < lineno; i++) {
924 char *pLastChar = &linebuf[sizeof(linebuf) - 2];
925 do {
926 *pLastChar = '\0';
927 if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf,
928 fp, NULL) == NULL)
929 break;
930 /* fgets read *something*; if it didn't get as
931 far as pLastChar, it must have found a newline
932 or hit the end of the file; if pLastChar is \n,
933 it obviously found a newline; else we haven't
934 yet seen a newline, so must continue */
935 } while (*pLastChar != '\0' && *pLastChar != '\n');
936 }
937 fclose(fp);
938 if (i == lineno) {
939 char *p = linebuf;
940 PyObject *res;
941 while (*p == ' ' || *p == '\t' || *p == '\014')
942 p++;
943 res = PyUnicode_FromString(p);
944 if (res == NULL)
945 PyErr_Clear();
946 return res;
947 }
948 return NULL;
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +0000949}
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000950
951#ifdef __cplusplus
952}
953#endif