|
1 |
|
2 /* Error handling */ |
|
3 |
|
4 #include "Python.h" |
|
5 |
|
6 #ifndef __STDC__ |
|
7 #ifndef MS_WINDOWS |
|
8 extern char *strerror(int); |
|
9 #endif |
|
10 #endif |
|
11 |
|
12 #ifdef MS_WINDOWS |
|
13 #include "windows.h" |
|
14 #include "winbase.h" |
|
15 #endif |
|
16 |
|
17 #include <ctype.h> |
|
18 |
|
19 #ifdef __cplusplus |
|
20 extern "C" { |
|
21 #endif |
|
22 |
|
23 |
|
24 void |
|
25 PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback) |
|
26 { |
|
27 PyThreadState *tstate = PyThreadState_GET(); |
|
28 PyObject *oldtype, *oldvalue, *oldtraceback; |
|
29 |
|
30 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 } |
|
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 Py_ssize_t 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 (PyExceptionInstance_Check(err)) |
|
106 err = PyExceptionInstance_Class(err); |
|
107 |
|
108 if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) { |
|
109 int res = 0; |
|
110 PyObject *exception, *value, *tb; |
|
111 PyErr_Fetch(&exception, &value, &tb); |
|
112 res = PyObject_IsSubclass(err, exc); |
|
113 /* This function must not fail, so print the error here */ |
|
114 if (res == -1) { |
|
115 PyErr_WriteUnraisable(err); |
|
116 res = 0; |
|
117 } |
|
118 PyErr_Restore(exception, value, tb); |
|
119 return res; |
|
120 } |
|
121 |
|
122 return err == exc; |
|
123 } |
|
124 |
|
125 |
|
126 int |
|
127 PyErr_ExceptionMatches(PyObject *exc) |
|
128 { |
|
129 return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc); |
|
130 } |
|
131 |
|
132 |
|
133 /* Used in many places to normalize a raised exception, including in |
|
134 eval_code2(), do_raise(), and PyErr_Print() |
|
135 */ |
|
136 void |
|
137 PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb) |
|
138 { |
|
139 PyObject *type = *exc; |
|
140 PyObject *value = *val; |
|
141 PyObject *inclass = NULL; |
|
142 PyObject *initial_tb = NULL; |
|
143 PyThreadState *tstate = NULL; |
|
144 |
|
145 if (type == NULL) { |
|
146 /* There was no exception, so nothing to do. */ |
|
147 return; |
|
148 } |
|
149 |
|
150 /* If PyErr_SetNone() was used, the value will have been actually |
|
151 set to NULL. |
|
152 */ |
|
153 if (!value) { |
|
154 value = Py_None; |
|
155 Py_INCREF(value); |
|
156 } |
|
157 |
|
158 if (PyExceptionInstance_Check(value)) |
|
159 inclass = PyExceptionInstance_Class(value); |
|
160 |
|
161 /* Normalize the exception so that if the type is a class, the |
|
162 value will be an instance. |
|
163 */ |
|
164 if (PyExceptionClass_Check(type)) { |
|
165 /* if the value was not an instance, or is not an instance |
|
166 whose class is (or is derived from) type, then use the |
|
167 value as an argument to instantiation of the type |
|
168 class. |
|
169 */ |
|
170 if (!inclass || !PyObject_IsSubclass(inclass, type)) { |
|
171 PyObject *args, *res; |
|
172 |
|
173 if (value == Py_None) |
|
174 args = PyTuple_New(0); |
|
175 else if (PyTuple_Check(value)) { |
|
176 Py_INCREF(value); |
|
177 args = value; |
|
178 } |
|
179 else |
|
180 args = PyTuple_Pack(1, value); |
|
181 |
|
182 if (args == NULL) |
|
183 goto finally; |
|
184 res = PyEval_CallObject(type, args); |
|
185 Py_DECREF(args); |
|
186 if (res == NULL) |
|
187 goto finally; |
|
188 Py_DECREF(value); |
|
189 value = res; |
|
190 } |
|
191 /* if the class of the instance doesn't exactly match the |
|
192 class of the type, believe the instance |
|
193 */ |
|
194 else if (inclass != type) { |
|
195 Py_DECREF(type); |
|
196 type = inclass; |
|
197 Py_INCREF(type); |
|
198 } |
|
199 } |
|
200 *exc = type; |
|
201 *val = value; |
|
202 return; |
|
203 finally: |
|
204 Py_DECREF(type); |
|
205 Py_DECREF(value); |
|
206 /* If the new exception doesn't set a traceback and the old |
|
207 exception had a traceback, use the old traceback for the |
|
208 new exception. It's better than nothing. |
|
209 */ |
|
210 initial_tb = *tb; |
|
211 PyErr_Fetch(exc, val, tb); |
|
212 if (initial_tb != NULL) { |
|
213 if (*tb == NULL) |
|
214 *tb = initial_tb; |
|
215 else |
|
216 Py_DECREF(initial_tb); |
|
217 } |
|
218 /* normalize recursively */ |
|
219 tstate = PyThreadState_GET(); |
|
220 if (++tstate->recursion_depth > Py_GetRecursionLimit()) { |
|
221 --tstate->recursion_depth; |
|
222 PyErr_SetObject(PyExc_RuntimeError, PyExc_RecursionErrorInst); |
|
223 return; |
|
224 } |
|
225 PyErr_NormalizeException(exc, val, tb); |
|
226 --tstate->recursion_depth; |
|
227 } |
|
228 |
|
229 |
|
230 void |
|
231 PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback) |
|
232 { |
|
233 PyThreadState *tstate = PyThreadState_GET(); |
|
234 |
|
235 *p_type = tstate->curexc_type; |
|
236 *p_value = tstate->curexc_value; |
|
237 *p_traceback = tstate->curexc_traceback; |
|
238 |
|
239 tstate->curexc_type = NULL; |
|
240 tstate->curexc_value = NULL; |
|
241 tstate->curexc_traceback = NULL; |
|
242 } |
|
243 |
|
244 void |
|
245 PyErr_Clear(void) |
|
246 { |
|
247 PyErr_Restore(NULL, NULL, NULL); |
|
248 } |
|
249 |
|
250 /* Convenience functions to set a type error exception and return 0 */ |
|
251 |
|
252 int |
|
253 PyErr_BadArgument(void) |
|
254 { |
|
255 PyErr_SetString(PyExc_TypeError, |
|
256 "bad argument type for built-in operation"); |
|
257 return 0; |
|
258 } |
|
259 |
|
260 PyObject * |
|
261 PyErr_NoMemory(void) |
|
262 { |
|
263 if (PyErr_ExceptionMatches(PyExc_MemoryError)) |
|
264 /* already current */ |
|
265 return NULL; |
|
266 |
|
267 /* raise the pre-allocated instance if it still exists */ |
|
268 if (PyExc_MemoryErrorInst) |
|
269 PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst); |
|
270 else |
|
271 /* this will probably fail since there's no memory and hee, |
|
272 hee, we have to instantiate this class |
|
273 */ |
|
274 PyErr_SetNone(PyExc_MemoryError); |
|
275 |
|
276 return NULL; |
|
277 } |
|
278 |
|
279 PyObject * |
|
280 PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject) |
|
281 { |
|
282 PyObject *v; |
|
283 char *s; |
|
284 int i = errno; |
|
285 #ifdef PLAN9 |
|
286 char errbuf[ERRMAX]; |
|
287 #endif |
|
288 #ifdef MS_WINDOWS |
|
289 char *s_buf = NULL; |
|
290 char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */ |
|
291 #endif |
|
292 #ifdef EINTR |
|
293 if (i == EINTR && PyErr_CheckSignals()) |
|
294 return NULL; |
|
295 #endif |
|
296 #ifdef PLAN9 |
|
297 rerrstr(errbuf, sizeof errbuf); |
|
298 s = errbuf; |
|
299 #else |
|
300 if (i == 0) |
|
301 s = "Error"; /* Sometimes errno didn't get set */ |
|
302 else |
|
303 #ifndef MS_WINDOWS |
|
304 s = strerror(i); |
|
305 #else |
|
306 { |
|
307 /* Note that the Win32 errors do not lineup with the |
|
308 errno error. So if the error is in the MSVC error |
|
309 table, we use it, otherwise we assume it really _is_ |
|
310 a Win32 error code |
|
311 */ |
|
312 if (i > 0 && i < _sys_nerr) { |
|
313 s = _sys_errlist[i]; |
|
314 } |
|
315 else { |
|
316 int len = FormatMessage( |
|
317 FORMAT_MESSAGE_ALLOCATE_BUFFER | |
|
318 FORMAT_MESSAGE_FROM_SYSTEM | |
|
319 FORMAT_MESSAGE_IGNORE_INSERTS, |
|
320 NULL, /* no message source */ |
|
321 i, |
|
322 MAKELANGID(LANG_NEUTRAL, |
|
323 SUBLANG_DEFAULT), |
|
324 /* Default language */ |
|
325 (LPTSTR) &s_buf, |
|
326 0, /* size not used */ |
|
327 NULL); /* no args */ |
|
328 if (len==0) { |
|
329 /* Only ever seen this in out-of-mem |
|
330 situations */ |
|
331 sprintf(s_small_buf, "Windows Error 0x%X", i); |
|
332 s = s_small_buf; |
|
333 s_buf = NULL; |
|
334 } else { |
|
335 s = s_buf; |
|
336 /* remove trailing cr/lf and dots */ |
|
337 while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.')) |
|
338 s[--len] = '\0'; |
|
339 } |
|
340 } |
|
341 } |
|
342 #endif /* Unix/Windows */ |
|
343 #endif /* PLAN 9*/ |
|
344 if (filenameObject != NULL) |
|
345 v = Py_BuildValue("(isO)", i, s, filenameObject); |
|
346 else |
|
347 v = Py_BuildValue("(is)", i, s); |
|
348 if (v != NULL) { |
|
349 PyErr_SetObject(exc, v); |
|
350 Py_DECREF(v); |
|
351 } |
|
352 #ifdef MS_WINDOWS |
|
353 LocalFree(s_buf); |
|
354 #endif |
|
355 return NULL; |
|
356 } |
|
357 |
|
358 |
|
359 PyObject * |
|
360 PyErr_SetFromErrnoWithFilename(PyObject *exc, char *filename) |
|
361 { |
|
362 PyObject *name = filename ? PyString_FromString(filename) : NULL; |
|
363 PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name); |
|
364 Py_XDECREF(name); |
|
365 return result; |
|
366 } |
|
367 |
|
368 #ifdef Py_WIN_WIDE_FILENAMES |
|
369 PyObject * |
|
370 PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, Py_UNICODE *filename) |
|
371 { |
|
372 PyObject *name = filename ? |
|
373 PyUnicode_FromUnicode(filename, wcslen(filename)) : |
|
374 NULL; |
|
375 PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name); |
|
376 Py_XDECREF(name); |
|
377 return result; |
|
378 } |
|
379 #endif /* Py_WIN_WIDE_FILENAMES */ |
|
380 |
|
381 PyObject * |
|
382 PyErr_SetFromErrno(PyObject *exc) |
|
383 { |
|
384 return PyErr_SetFromErrnoWithFilenameObject(exc, NULL); |
|
385 } |
|
386 |
|
387 #ifdef MS_WINDOWS |
|
388 /* Windows specific error code handling */ |
|
389 PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject( |
|
390 PyObject *exc, |
|
391 int ierr, |
|
392 PyObject *filenameObject) |
|
393 { |
|
394 int len; |
|
395 char *s; |
|
396 char *s_buf = NULL; /* Free via LocalFree */ |
|
397 char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */ |
|
398 PyObject *v; |
|
399 DWORD err = (DWORD)ierr; |
|
400 if (err==0) err = GetLastError(); |
|
401 len = FormatMessage( |
|
402 /* Error API error */ |
|
403 FORMAT_MESSAGE_ALLOCATE_BUFFER | |
|
404 FORMAT_MESSAGE_FROM_SYSTEM | |
|
405 FORMAT_MESSAGE_IGNORE_INSERTS, |
|
406 NULL, /* no message source */ |
|
407 err, |
|
408 MAKELANGID(LANG_NEUTRAL, |
|
409 SUBLANG_DEFAULT), /* Default language */ |
|
410 (LPTSTR) &s_buf, |
|
411 0, /* size not used */ |
|
412 NULL); /* no args */ |
|
413 if (len==0) { |
|
414 /* Only seen this in out of mem situations */ |
|
415 sprintf(s_small_buf, "Windows Error 0x%X", err); |
|
416 s = s_small_buf; |
|
417 s_buf = NULL; |
|
418 } else { |
|
419 s = s_buf; |
|
420 /* remove trailing cr/lf and dots */ |
|
421 while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.')) |
|
422 s[--len] = '\0'; |
|
423 } |
|
424 if (filenameObject != NULL) |
|
425 v = Py_BuildValue("(isO)", err, s, filenameObject); |
|
426 else |
|
427 v = Py_BuildValue("(is)", err, s); |
|
428 if (v != NULL) { |
|
429 PyErr_SetObject(exc, v); |
|
430 Py_DECREF(v); |
|
431 } |
|
432 LocalFree(s_buf); |
|
433 return NULL; |
|
434 } |
|
435 |
|
436 PyObject *PyErr_SetExcFromWindowsErrWithFilename( |
|
437 PyObject *exc, |
|
438 int ierr, |
|
439 const char *filename) |
|
440 { |
|
441 PyObject *name = filename ? PyString_FromString(filename) : NULL; |
|
442 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc, |
|
443 ierr, |
|
444 name); |
|
445 Py_XDECREF(name); |
|
446 return ret; |
|
447 } |
|
448 |
|
449 #ifdef Py_WIN_WIDE_FILENAMES |
|
450 PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename( |
|
451 PyObject *exc, |
|
452 int ierr, |
|
453 const Py_UNICODE *filename) |
|
454 { |
|
455 PyObject *name = filename ? |
|
456 PyUnicode_FromUnicode(filename, wcslen(filename)) : |
|
457 NULL; |
|
458 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc, |
|
459 ierr, |
|
460 name); |
|
461 Py_XDECREF(name); |
|
462 return ret; |
|
463 } |
|
464 #endif /* Py_WIN_WIDE_FILENAMES */ |
|
465 |
|
466 PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr) |
|
467 { |
|
468 return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL); |
|
469 } |
|
470 |
|
471 PyObject *PyErr_SetFromWindowsErr(int ierr) |
|
472 { |
|
473 return PyErr_SetExcFromWindowsErrWithFilename(PyExc_WindowsError, |
|
474 ierr, NULL); |
|
475 } |
|
476 PyObject *PyErr_SetFromWindowsErrWithFilename( |
|
477 int ierr, |
|
478 const char *filename) |
|
479 { |
|
480 PyObject *name = filename ? PyString_FromString(filename) : NULL; |
|
481 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject( |
|
482 PyExc_WindowsError, |
|
483 ierr, name); |
|
484 Py_XDECREF(name); |
|
485 return result; |
|
486 } |
|
487 |
|
488 #ifdef Py_WIN_WIDE_FILENAMES |
|
489 PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename( |
|
490 int ierr, |
|
491 const Py_UNICODE *filename) |
|
492 { |
|
493 PyObject *name = filename ? |
|
494 PyUnicode_FromUnicode(filename, wcslen(filename)) : |
|
495 NULL; |
|
496 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject( |
|
497 PyExc_WindowsError, |
|
498 ierr, name); |
|
499 Py_XDECREF(name); |
|
500 return result; |
|
501 } |
|
502 #endif /* Py_WIN_WIDE_FILENAMES */ |
|
503 #endif /* MS_WINDOWS */ |
|
504 |
|
505 void |
|
506 _PyErr_BadInternalCall(char *filename, int lineno) |
|
507 { |
|
508 PyErr_Format(PyExc_SystemError, |
|
509 "%s:%d: bad argument to internal function", |
|
510 filename, lineno); |
|
511 } |
|
512 |
|
513 /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can |
|
514 export the entry point for existing object code: */ |
|
515 #undef PyErr_BadInternalCall |
|
516 void |
|
517 PyErr_BadInternalCall(void) |
|
518 { |
|
519 PyErr_Format(PyExc_SystemError, |
|
520 "bad argument to internal function"); |
|
521 } |
|
522 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__) |
|
523 |
|
524 |
|
525 |
|
526 PyObject * |
|
527 PyErr_Format(PyObject *exception, const char *format, ...) |
|
528 { |
|
529 va_list vargs; |
|
530 PyObject* string; |
|
531 |
|
532 #ifdef HAVE_STDARG_PROTOTYPES |
|
533 va_start(vargs, format); |
|
534 #else |
|
535 va_start(vargs); |
|
536 #endif |
|
537 |
|
538 string = PyString_FromFormatV(format, vargs); |
|
539 PyErr_SetObject(exception, string); |
|
540 Py_XDECREF(string); |
|
541 va_end(vargs); |
|
542 return NULL; |
|
543 } |
|
544 |
|
545 |
|
546 |
|
547 PyObject * |
|
548 PyErr_NewException(char *name, PyObject *base, PyObject *dict) |
|
549 { |
|
550 char *dot; |
|
551 PyObject *modulename = NULL; |
|
552 PyObject *classname = NULL; |
|
553 PyObject *mydict = NULL; |
|
554 PyObject *bases = NULL; |
|
555 PyObject *result = NULL; |
|
556 dot = strrchr(name, '.'); |
|
557 if (dot == NULL) { |
|
558 PyErr_SetString(PyExc_SystemError, |
|
559 "PyErr_NewException: name must be module.class"); |
|
560 return NULL; |
|
561 } |
|
562 if (base == NULL) |
|
563 base = PyExc_Exception; |
|
564 if (dict == NULL) { |
|
565 dict = mydict = PyDict_New(); |
|
566 if (dict == NULL) |
|
567 goto failure; |
|
568 } |
|
569 if (PyDict_GetItemString(dict, "__module__") == NULL) { |
|
570 modulename = PyString_FromStringAndSize(name, |
|
571 (Py_ssize_t)(dot-name)); |
|
572 if (modulename == NULL) |
|
573 goto failure; |
|
574 if (PyDict_SetItemString(dict, "__module__", modulename) != 0) |
|
575 goto failure; |
|
576 } |
|
577 if (PyTuple_Check(base)) { |
|
578 bases = base; |
|
579 /* INCREF as we create a new ref in the else branch */ |
|
580 Py_INCREF(bases); |
|
581 } else { |
|
582 bases = PyTuple_Pack(1, base); |
|
583 if (bases == NULL) |
|
584 goto failure; |
|
585 } |
|
586 /* Create a real new-style class. */ |
|
587 result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO", |
|
588 dot+1, bases, dict); |
|
589 failure: |
|
590 Py_XDECREF(bases); |
|
591 Py_XDECREF(mydict); |
|
592 Py_XDECREF(classname); |
|
593 Py_XDECREF(modulename); |
|
594 return result; |
|
595 } |
|
596 |
|
597 /* Call when an exception has occurred but there is no way for Python |
|
598 to handle it. Examples: exception in __del__ or during GC. */ |
|
599 void |
|
600 PyErr_WriteUnraisable(PyObject *obj) |
|
601 { |
|
602 PyObject *f, *t, *v, *tb; |
|
603 PyErr_Fetch(&t, &v, &tb); |
|
604 f = PySys_GetObject("stderr"); |
|
605 if (f != NULL) { |
|
606 PyFile_WriteString("Exception ", f); |
|
607 if (t) { |
|
608 PyObject* moduleName; |
|
609 char* className; |
|
610 assert(PyExceptionClass_Check(t)); |
|
611 className = PyExceptionClass_Name(t); |
|
612 if (className != NULL) { |
|
613 char *dot = strrchr(className, '.'); |
|
614 if (dot != NULL) |
|
615 className = dot+1; |
|
616 } |
|
617 |
|
618 moduleName = PyObject_GetAttrString(t, "__module__"); |
|
619 if (moduleName == NULL) |
|
620 PyFile_WriteString("<unknown>", f); |
|
621 else { |
|
622 char* modstr = PyString_AsString(moduleName); |
|
623 if (modstr && |
|
624 strcmp(modstr, "exceptions") != 0) |
|
625 { |
|
626 PyFile_WriteString(modstr, f); |
|
627 PyFile_WriteString(".", f); |
|
628 } |
|
629 } |
|
630 if (className == NULL) |
|
631 PyFile_WriteString("<unknown>", f); |
|
632 else |
|
633 PyFile_WriteString(className, f); |
|
634 if (v && v != Py_None) { |
|
635 PyFile_WriteString(": ", f); |
|
636 PyFile_WriteObject(v, f, 0); |
|
637 } |
|
638 Py_XDECREF(moduleName); |
|
639 } |
|
640 PyFile_WriteString(" in ", f); |
|
641 PyFile_WriteObject(obj, f, 0); |
|
642 PyFile_WriteString(" ignored\n", f); |
|
643 PyErr_Clear(); /* Just in case */ |
|
644 } |
|
645 Py_XDECREF(t); |
|
646 Py_XDECREF(v); |
|
647 Py_XDECREF(tb); |
|
648 } |
|
649 |
|
650 extern PyObject *PyModule_GetWarningsModule(void); |
|
651 |
|
652 |
|
653 /* Set file and line information for the current exception. |
|
654 If the exception is not a SyntaxError, also sets additional attributes |
|
655 to make printing of exceptions believe it is a syntax error. */ |
|
656 |
|
657 void |
|
658 PyErr_SyntaxLocation(const char *filename, int lineno) |
|
659 { |
|
660 PyObject *exc, *v, *tb, *tmp; |
|
661 |
|
662 /* add attributes for the line number and filename for the error */ |
|
663 PyErr_Fetch(&exc, &v, &tb); |
|
664 PyErr_NormalizeException(&exc, &v, &tb); |
|
665 /* XXX check that it is, indeed, a syntax error. It might not |
|
666 * be, though. */ |
|
667 tmp = PyInt_FromLong(lineno); |
|
668 if (tmp == NULL) |
|
669 PyErr_Clear(); |
|
670 else { |
|
671 if (PyObject_SetAttrString(v, "lineno", tmp)) |
|
672 PyErr_Clear(); |
|
673 Py_DECREF(tmp); |
|
674 } |
|
675 if (filename != NULL) { |
|
676 tmp = PyString_FromString(filename); |
|
677 if (tmp == NULL) |
|
678 PyErr_Clear(); |
|
679 else { |
|
680 if (PyObject_SetAttrString(v, "filename", tmp)) |
|
681 PyErr_Clear(); |
|
682 Py_DECREF(tmp); |
|
683 } |
|
684 |
|
685 tmp = PyErr_ProgramText(filename, lineno); |
|
686 if (tmp) { |
|
687 if (PyObject_SetAttrString(v, "text", tmp)) |
|
688 PyErr_Clear(); |
|
689 Py_DECREF(tmp); |
|
690 } |
|
691 } |
|
692 if (PyObject_SetAttrString(v, "offset", Py_None)) { |
|
693 PyErr_Clear(); |
|
694 } |
|
695 if (exc != PyExc_SyntaxError) { |
|
696 if (!PyObject_HasAttrString(v, "msg")) { |
|
697 tmp = PyObject_Str(v); |
|
698 if (tmp) { |
|
699 if (PyObject_SetAttrString(v, "msg", tmp)) |
|
700 PyErr_Clear(); |
|
701 Py_DECREF(tmp); |
|
702 } else { |
|
703 PyErr_Clear(); |
|
704 } |
|
705 } |
|
706 if (!PyObject_HasAttrString(v, "print_file_and_line")) { |
|
707 if (PyObject_SetAttrString(v, "print_file_and_line", |
|
708 Py_None)) |
|
709 PyErr_Clear(); |
|
710 } |
|
711 } |
|
712 PyErr_Restore(exc, v, tb); |
|
713 } |
|
714 |
|
715 /* com_fetch_program_text will attempt to load the line of text that |
|
716 the exception refers to. If it fails, it will return NULL but will |
|
717 not set an exception. |
|
718 |
|
719 XXX The functionality of this function is quite similar to the |
|
720 functionality in tb_displayline() in traceback.c. |
|
721 */ |
|
722 |
|
723 PyObject * |
|
724 PyErr_ProgramText(const char *filename, int lineno) |
|
725 { |
|
726 FILE *fp; |
|
727 int i; |
|
728 char linebuf[1000]; |
|
729 |
|
730 if (filename == NULL || *filename == '\0' || lineno <= 0) |
|
731 return NULL; |
|
732 fp = fopen(filename, "r" PY_STDIOTEXTMODE); |
|
733 if (fp == NULL) |
|
734 return NULL; |
|
735 for (i = 0; i < lineno; i++) { |
|
736 char *pLastChar = &linebuf[sizeof(linebuf) - 2]; |
|
737 do { |
|
738 *pLastChar = '\0'; |
|
739 if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, fp, NULL) == NULL) |
|
740 break; |
|
741 /* fgets read *something*; if it didn't get as |
|
742 far as pLastChar, it must have found a newline |
|
743 or hit the end of the file; if pLastChar is \n, |
|
744 it obviously found a newline; else we haven't |
|
745 yet seen a newline, so must continue */ |
|
746 } while (*pLastChar != '\0' && *pLastChar != '\n'); |
|
747 } |
|
748 fclose(fp); |
|
749 if (i == lineno) { |
|
750 char *p = linebuf; |
|
751 while (*p == ' ' || *p == '\t' || *p == '\014') |
|
752 p++; |
|
753 return PyString_FromString(p); |
|
754 } |
|
755 return NULL; |
|
756 } |
|
757 |
|
758 #ifdef __cplusplus |
|
759 } |
|
760 #endif |
|
761 |