Mercurial > cpython-lru_cache-weakref

comparison Python/errors.c @ 61467:f197407bdba2 3.1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Recorded merge of revisions 81032 via svnmerge from svn+ssh://pythondev@svn.python.org/python/branches/py3k ................ r81032 | antoine.pitrou | 2010-05-09 17:52:27 +0200 (dim., 09 mai 2010) | 9 lines Recorded merge of revisions 81029 via svnmerge from svn+ssh://pythondev@svn.python.org/python/trunk ........ r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines Untabify C files. Will watch buildbots. ........ ................
author Antoine Pitrou <solipsis@pitrou.net>
date Sun, 09 May 2010 16:14:21 +0000
parents 77cfef596d33
children c6d86439aa91
comparison
equal deleted inserted replaced
61459:f8c19c5f5dd2 61467:f197407bdba2
22 22
23 23
24 void 24 void
25 PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback) 25 PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
26 { 26 {
27 PyThreadState *tstate = PyThreadState_GET(); 27 PyThreadState *tstate = PyThreadState_GET();
28 PyObject *oldtype, *oldvalue, *oldtraceback; 28 PyObject *oldtype, *oldvalue, *oldtraceback;
29 29
30 if (traceback != NULL && !PyTraceBack_Check(traceback)) { 30 if (traceback != NULL && !PyTraceBack_Check(traceback)) {
31 /* XXX Should never happen -- fatal error instead? */ 31 /* XXX Should never happen -- fatal error instead? */
32 /* Well, it could be None. */ 32 /* Well, it could be None. */
33 Py_DECREF(traceback); 33 Py_DECREF(traceback);
34 traceback = NULL; 34 traceback = NULL;
35 } 35 }
36 36
37 /* Save these in locals to safeguard against recursive 37 /* Save these in locals to safeguard against recursive
38 invocation through Py_XDECREF */ 38 invocation through Py_XDECREF */
39 oldtype = tstate->curexc_type; 39 oldtype = tstate->curexc_type;
40 oldvalue = tstate->curexc_value; 40 oldvalue = tstate->curexc_value;
41 oldtraceback = tstate->curexc_traceback; 41 oldtraceback = tstate->curexc_traceback;
42 42
43 tstate->curexc_type = type; 43 tstate->curexc_type = type;
44 tstate->curexc_value = value; 44 tstate->curexc_value = value;
45 tstate->curexc_traceback = traceback; 45 tstate->curexc_traceback = traceback;
46 46
47 Py_XDECREF(oldtype); 47 Py_XDECREF(oldtype);
48 Py_XDECREF(oldvalue); 48 Py_XDECREF(oldvalue);
49 Py_XDECREF(oldtraceback); 49 Py_XDECREF(oldtraceback);
50 } 50 }
51 51
52 void 52 void
53 PyErr_SetObject(PyObject *exception, PyObject *value) 53 PyErr_SetObject(PyObject *exception, PyObject *value)
54 { 54 {
55 PyThreadState *tstate = PyThreadState_GET(); 55 PyThreadState *tstate = PyThreadState_GET();
56 PyObject *exc_value; 56 PyObject *exc_value;
57 PyObject *tb = NULL; 57 PyObject *tb = NULL;
58 58
59 if (exception != NULL && 59 if (exception != NULL &&
60 !PyExceptionClass_Check(exception)) { 60 !PyExceptionClass_Check(exception)) {
61 PyErr_Format(PyExc_SystemError, 61 PyErr_Format(PyExc_SystemError,
62 "exception %R not a BaseException subclass", 62 "exception %R not a BaseException subclass",
63 exception); 63 exception);
64 return; 64 return;
65 } 65 }
66 Py_XINCREF(value); 66 Py_XINCREF(value);
67 exc_value = tstate->exc_value; 67 exc_value = tstate->exc_value;
68 if (exc_value != NULL && exc_value != Py_None) { 68 if (exc_value != NULL && exc_value != Py_None) {
69 /* Implicit exception chaining */ 69 /* Implicit exception chaining */
70 Py_INCREF(exc_value); 70 Py_INCREF(exc_value);
71 if (value == NULL || !PyExceptionInstance_Check(value)) { 71 if (value == NULL || !PyExceptionInstance_Check(value)) {
72 /* We must normalize the value right now */ 72 /* We must normalize the value right now */
73 PyObject *args, *fixed_value; 73 PyObject *args, *fixed_value;
74 if (value == NULL || value == Py_None) 74 if (value == NULL || value == Py_None)
75 args = PyTuple_New(0); 75 args = PyTuple_New(0);
76 else if (PyTuple_Check(value)) { 76 else if (PyTuple_Check(value)) {
77 Py_INCREF(value); 77 Py_INCREF(value);
78 args = value; 78 args = value;
79 } 79 }
80 else 80 else
81 args = PyTuple_Pack(1, value); 81 args = PyTuple_Pack(1, value);
82 fixed_value = args ? 82 fixed_value = args ?
83 PyEval_CallObject(exception, args) : NULL; 83 PyEval_CallObject(exception, args) : NULL;
84 Py_XDECREF(args); 84 Py_XDECREF(args);
85 Py_XDECREF(value); 85 Py_XDECREF(value);
86 if (fixed_value == NULL) 86 if (fixed_value == NULL)
87 return; 87 return;
88 value = fixed_value; 88 value = fixed_value;
89 } 89 }
90 /* Avoid reference cycles through the context chain. 90 /* Avoid reference cycles through the context chain.
91 This is O(chain length) but context chains are 91 This is O(chain length) but context chains are
92 usually very short. Sensitive readers may try 92 usually very short. Sensitive readers may try
93 to inline the call to PyException_GetContext. */ 93 to inline the call to PyException_GetContext. */
94 if (exc_value != value) { 94 if (exc_value != value) {
95 PyObject *o = exc_value, *context; 95 PyObject *o = exc_value, *context;
96 while ((context = PyException_GetContext(o))) { 96 while ((context = PyException_GetContext(o))) {
97 Py_DECREF(context); 97 Py_DECREF(context);
98 if (context == value) { 98 if (context == value) {
99 PyException_SetContext(o, NULL); 99 PyException_SetContext(o, NULL);
100 break; 100 break;
101 } 101 }
102 o = context; 102 o = context;
103 } 103 }
104 PyException_SetContext(value, exc_value); 104 PyException_SetContext(value, exc_value);
105 } else { 105 } else {
106 Py_DECREF(exc_value); 106 Py_DECREF(exc_value);
107 } 107 }
108 } 108 }
109 if (value != NULL && PyExceptionInstance_Check(value)) 109 if (value != NULL && PyExceptionInstance_Check(value))
110 tb = PyException_GetTraceback(value); 110 tb = PyException_GetTraceback(value);
111 Py_XINCREF(exception); 111 Py_XINCREF(exception);
112 PyErr_Restore(exception, value, tb); 112 PyErr_Restore(exception, value, tb);
113 } 113 }
114 114
115 void 115 void
116 PyErr_SetNone(PyObject *exception) 116 PyErr_SetNone(PyObject *exception)
117 { 117 {
118 PyErr_SetObject(exception, (PyObject *)NULL); 118 PyErr_SetObject(exception, (PyObject *)NULL);
119 } 119 }
120 120
121 void 121 void
122 PyErr_SetString(PyObject *exception, const char *string) 122 PyErr_SetString(PyObject *exception, const char *string)
123 { 123 {
124 PyObject *value = PyUnicode_FromString(string); 124 PyObject *value = PyUnicode_FromString(string);
125 PyErr_SetObject(exception, value); 125 PyErr_SetObject(exception, value);
126 Py_XDECREF(value); 126 Py_XDECREF(value);
127 } 127 }
128 128
129 129
130 PyObject * 130 PyObject *
131 PyErr_Occurred(void) 131 PyErr_Occurred(void)
132 { 132 {
133 PyThreadState *tstate = PyThreadState_GET(); 133 PyThreadState *tstate = PyThreadState_GET();
134 134
135 return tstate->curexc_type; 135 return tstate->curexc_type;
136 } 136 }
137 137
138 138
139 int 139 int
140 PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc) 140 PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
141 { 141 {
142 if (err == NULL || exc == NULL) { 142 if (err == NULL || exc == NULL) {
143 /* maybe caused by "import exceptions" that failed early on */ 143 /* maybe caused by "import exceptions" that failed early on */
144 return 0; 144 return 0;
145 } 145 }
146 if (PyTuple_Check(exc)) { 146 if (PyTuple_Check(exc)) {
147 Py_ssize_t i, n; 147 Py_ssize_t i, n;
148 n = PyTuple_Size(exc); 148 n = PyTuple_Size(exc);
149 for (i = 0; i < n; i++) { 149 for (i = 0; i < n; i++) {
150 /* Test recursively */ 150 /* Test recursively */
151 if (PyErr_GivenExceptionMatches( 151 if (PyErr_GivenExceptionMatches(
152 err, PyTuple_GET_ITEM(exc, i))) 152 err, PyTuple_GET_ITEM(exc, i)))
153 { 153 {
154 return 1; 154 return 1;
155 } 155 }
156 } 156 }
157 return 0; 157 return 0;
158 } 158 }
159 /* err might be an instance, so check its class. */ 159 /* err might be an instance, so check its class. */
160 if (PyExceptionInstance_Check(err)) 160 if (PyExceptionInstance_Check(err))
161 err = PyExceptionInstance_Class(err); 161 err = PyExceptionInstance_Class(err);
162 162
163 if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) { 163 if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
164 int res = 0; 164 int res = 0;
165 PyObject *exception, *value, *tb; 165 PyObject *exception, *value, *tb;
166 PyErr_Fetch(&exception, &value, &tb); 166 PyErr_Fetch(&exception, &value, &tb);
167 /* PyObject_IsSubclass() can recurse and therefore is 167 /* PyObject_IsSubclass() can recurse and therefore is
168 not safe (see test_bad_getattr in test.pickletester). */ 168 not safe (see test_bad_getattr in test.pickletester). */
169 res = PyType_IsSubtype((PyTypeObject *)err, (PyTypeObject *)exc); 169 res = PyType_IsSubtype((PyTypeObject *)err, (PyTypeObject *)exc);
170 /* This function must not fail, so print the error here */ 170 /* This function must not fail, so print the error here */
171 if (res == -1) { 171 if (res == -1) {
172 PyErr_WriteUnraisable(err); 172 PyErr_WriteUnraisable(err);
173 res = 0; 173 res = 0;
174 } 174 }
175 PyErr_Restore(exception, value, tb); 175 PyErr_Restore(exception, value, tb);
176 return res; 176 return res;
177 } 177 }
178 178
179 return err == exc; 179 return err == exc;
180 } 180 }
181 181
182 182
183 int 183 int
184 PyErr_ExceptionMatches(PyObject *exc) 184 PyErr_ExceptionMatches(PyObject *exc)
185 { 185 {
186 return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc); 186 return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
187 } 187 }
188 188
189 189
190 /* Used in many places to normalize a raised exception, including in 190 /* Used in many places to normalize a raised exception, including in
191 eval_code2(), do_raise(), and PyErr_Print() 191 eval_code2(), do_raise(), and PyErr_Print()
192 192
193 XXX: should PyErr_NormalizeException() also call 193 XXX: should PyErr_NormalizeException() also call
194 PyException_SetTraceback() with the resulting value and tb? 194 PyException_SetTraceback() with the resulting value and tb?
195 */ 195 */
196 void 196 void
197 PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb) 197 PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb)
198 { 198 {
199 PyObject *type = *exc; 199 PyObject *type = *exc;
200 PyObject *value = *val; 200 PyObject *value = *val;
201 PyObject *inclass = NULL; 201 PyObject *inclass = NULL;
202 PyObject *initial_tb = NULL; 202 PyObject *initial_tb = NULL;
203 PyThreadState *tstate = NULL; 203 PyThreadState *tstate = NULL;
204 204
205 if (type == NULL) { 205 if (type == NULL) {
206 /* There was no exception, so nothing to do. */ 206 /* There was no exception, so nothing to do. */
207 return; 207 return;
208 } 208 }
209 209
210 /* If PyErr_SetNone() was used, the value will have been actually 210 /* If PyErr_SetNone() was used, the value will have been actually
211 set to NULL. 211 set to NULL.
212 */ 212 */
213 if (!value) { 213 if (!value) {
214 value = Py_None; 214 value = Py_None;
215 Py_INCREF(value); 215 Py_INCREF(value);
216 } 216 }
217 217
218 if (PyExceptionInstance_Check(value)) 218 if (PyExceptionInstance_Check(value))
219 inclass = PyExceptionInstance_Class(value); 219 inclass = PyExceptionInstance_Class(value);
220 220
221 /* Normalize the exception so that if the type is a class, the 221 /* Normalize the exception so that if the type is a class, the
222 value will be an instance. 222 value will be an instance.
223 */ 223 */
224 if (PyExceptionClass_Check(type)) { 224 if (PyExceptionClass_Check(type)) {
225 /* if the value was not an instance, or is not an instance 225 /* if the value was not an instance, or is not an instance
226 whose class is (or is derived from) type, then use the 226 whose class is (or is derived from) type, then use the
227 value as an argument to instantiation of the type 227 value as an argument to instantiation of the type
228 class. 228 class.
229 */ 229 */
230 if (!inclass || !PyObject_IsSubclass(inclass, type)) { 230 if (!inclass || !PyObject_IsSubclass(inclass, type)) {
231 PyObject *args, *res; 231 PyObject *args, *res;
232 232
233 if (value == Py_None) 233 if (value == Py_None)
234 args = PyTuple_New(0); 234 args = PyTuple_New(0);
235 else if (PyTuple_Check(value)) { 235 else if (PyTuple_Check(value)) {
236 Py_INCREF(value); 236 Py_INCREF(value);
237 args = value; 237 args = value;
238 } 238 }
239 else 239 else
240 args = PyTuple_Pack(1, value); 240 args = PyTuple_Pack(1, value);
241 241
242 if (args == NULL) 242 if (args == NULL)
243 goto finally; 243 goto finally;
244 res = PyEval_CallObject(type, args); 244 res = PyEval_CallObject(type, args);
245 Py_DECREF(args); 245 Py_DECREF(args);
246 if (res == NULL) 246 if (res == NULL)
247 goto finally; 247 goto finally;
248 Py_DECREF(value); 248 Py_DECREF(value);
249 value = res; 249 value = res;
250 } 250 }
251 /* if the class of the instance doesn't exactly match the 251 /* if the class of the instance doesn't exactly match the
252 class of the type, believe the instance 252 class of the type, believe the instance
253 */ 253 */
254 else if (inclass != type) { 254 else if (inclass != type) {
255 Py_DECREF(type); 255 Py_DECREF(type);
256 type = inclass; 256 type = inclass;
257 Py_INCREF(type); 257 Py_INCREF(type);
258 } 258 }
259 } 259 }
260 *exc = type; 260 *exc = type;
261 *val = value; 261 *val = value;
262 return; 262 return;
263 finally: 263 finally:
264 Py_DECREF(type); 264 Py_DECREF(type);
265 Py_DECREF(value); 265 Py_DECREF(value);
266 /* If the new exception doesn't set a traceback and the old 266 /* If the new exception doesn't set a traceback and the old
267 exception had a traceback, use the old traceback for the 267 exception had a traceback, use the old traceback for the
268 new exception. It's better than nothing. 268 new exception. It's better than nothing.
269 */ 269 */
270 initial_tb = *tb; 270 initial_tb = *tb;
271 PyErr_Fetch(exc, val, tb); 271 PyErr_Fetch(exc, val, tb);
272 if (initial_tb != NULL) { 272 if (initial_tb != NULL) {
273 if (*tb == NULL) 273 if (*tb == NULL)
274 *tb = initial_tb; 274 *tb = initial_tb;
275 else 275 else
276 Py_DECREF(initial_tb); 276 Py_DECREF(initial_tb);
277 } 277 }
278 /* normalize recursively */ 278 /* normalize recursively */
279 tstate = PyThreadState_GET(); 279 tstate = PyThreadState_GET();
280 if (++tstate->recursion_depth > Py_GetRecursionLimit()) { 280 if (++tstate->recursion_depth > Py_GetRecursionLimit()) {
281 --tstate->recursion_depth; 281 --tstate->recursion_depth;
282 /* throw away the old exception... */ 282 /* throw away the old exception... */
283 Py_DECREF(*exc); 283 Py_DECREF(*exc);
284 Py_DECREF(*val); 284 Py_DECREF(*val);
285 /* ... and use the recursion error instead */ 285 /* ... and use the recursion error instead */
286 *exc = PyExc_RuntimeError; 286 *exc = PyExc_RuntimeError;
287 *val = PyExc_RecursionErrorInst; 287 *val = PyExc_RecursionErrorInst;
288 Py_INCREF(*exc); 288 Py_INCREF(*exc);
289 Py_INCREF(*val); 289 Py_INCREF(*val);
290 /* just keeping the old traceback */ 290 /* just keeping the old traceback */
291 return; 291 return;
292 } 292 }
293 PyErr_NormalizeException(exc, val, tb); 293 PyErr_NormalizeException(exc, val, tb);
294 --tstate->recursion_depth; 294 --tstate->recursion_depth;
295 } 295 }
296 296
297 297
298 void 298 void
299 PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback) 299 PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
300 { 300 {
301 PyThreadState *tstate = PyThreadState_GET(); 301 PyThreadState *tstate = PyThreadState_GET();
302 302
303 *p_type = tstate->curexc_type; 303 *p_type = tstate->curexc_type;
304 *p_value = tstate->curexc_value; 304 *p_value = tstate->curexc_value;
305 *p_traceback = tstate->curexc_traceback; 305 *p_traceback = tstate->curexc_traceback;
306 306
307 tstate->curexc_type = NULL; 307 tstate->curexc_type = NULL;
308 tstate->curexc_value = NULL; 308 tstate->curexc_value = NULL;
309 tstate->curexc_traceback = NULL; 309 tstate->curexc_traceback = NULL;
310 } 310 }
311 311
312 void 312 void
313 PyErr_Clear(void) 313 PyErr_Clear(void)
314 { 314 {
315 PyErr_Restore(NULL, NULL, NULL); 315 PyErr_Restore(NULL, NULL, NULL);
316 } 316 }
317 317
318 /* Convenience functions to set a type error exception and return 0 */ 318 /* Convenience functions to set a type error exception and return 0 */
319 319
320 int 320 int
321 PyErr_BadArgument(void) 321 PyErr_BadArgument(void)
322 { 322 {
323 PyErr_SetString(PyExc_TypeError, 323 PyErr_SetString(PyExc_TypeError,
324 "bad argument type for built-in operation"); 324 "bad argument type for built-in operation");
325 return 0; 325 return 0;
326 } 326 }
327 327
328 PyObject * 328 PyObject *
329 PyErr_NoMemory(void) 329 PyErr_NoMemory(void)
330 { 330 {
331 if (PyErr_ExceptionMatches(PyExc_MemoryError)) 331 if (PyErr_ExceptionMatches(PyExc_MemoryError))
332 /* already current */ 332 /* already current */
333 return NULL; 333 return NULL;
334 334
335 /* raise the pre-allocated instance if it still exists */ 335 /* raise the pre-allocated instance if it still exists */
336 if (PyExc_MemoryErrorInst) 336 if (PyExc_MemoryErrorInst)
337 { 337 {
338 /* Clear the previous traceback, otherwise it will be appended 338 /* Clear the previous traceback, otherwise it will be appended
339 * to the current one. 339 * to the current one.
340 * 340 *
341 * The following statement is not likely to raise any error; 341 * The following statement is not likely to raise any error;
342 * if it does, we simply discard it. 342 * if it does, we simply discard it.
343 */ 343 */
344 PyException_SetTraceback(PyExc_MemoryErrorInst, Py_None); 344 PyException_SetTraceback(PyExc_MemoryErrorInst, Py_None);
345 345
346 PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst); 346 PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
347 } 347 }
348 else 348 else
349 /* this will probably fail since there's no memory and hee, 349 /* this will probably fail since there's no memory and hee,
350 hee, we have to instantiate this class 350 hee, we have to instantiate this class
351 */ 351 */
352 PyErr_SetNone(PyExc_MemoryError); 352 PyErr_SetNone(PyExc_MemoryError);
353 353
354 return NULL; 354 return NULL;
355 } 355 }
356 356
357 PyObject * 357 PyObject *
358 PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject) 358 PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject)
359 { 359 {
360 PyObject *message; 360 PyObject *message;
361 PyObject *v; 361 PyObject *v;
362 int i = errno; 362 int i = errno;
363 #ifdef PLAN9 363 #ifdef PLAN9
364 char errbuf[ERRMAX]; 364 char errbuf[ERRMAX];
365 #else 365 #else
366 #ifndef MS_WINDOWS 366 #ifndef MS_WINDOWS
367 char *s; 367 char *s;
368 #else 368 #else
369 WCHAR *s_buf = NULL; 369 WCHAR *s_buf = NULL;
370 #endif /* Unix/Windows */ 370 #endif /* Unix/Windows */
371 #endif /* PLAN 9*/ 371 #endif /* PLAN 9*/
372 372
373 #ifdef EINTR 373 #ifdef EINTR
374 if (i == EINTR && PyErr_CheckSignals()) 374 if (i == EINTR && PyErr_CheckSignals())
375 return NULL; 375 return NULL;
376 #endif 376 #endif
377 377
378 #ifdef PLAN9 378 #ifdef PLAN9
379 rerrstr(errbuf, sizeof errbuf); 379 rerrstr(errbuf, sizeof errbuf);
380 message = PyUnicode_DecodeUTF8(errbuf, strlen(errbuf), "ignore"); 380 message = PyUnicode_DecodeUTF8(errbuf, strlen(errbuf), "ignore");
381 #else 381 #else
382 #ifndef MS_WINDOWS 382 #ifndef MS_WINDOWS
383 if (i == 0) 383 if (i == 0)
384 s = "Error"; /* Sometimes errno didn't get set */ 384 s = "Error"; /* Sometimes errno didn't get set */
385 else 385 else
386 s = strerror(i); 386 s = strerror(i);
387 message = PyUnicode_DecodeUTF8(s, strlen(s), "ignore"); 387 message = PyUnicode_DecodeUTF8(s, strlen(s), "ignore");
388 #else 388 #else
389 if (i == 0) 389 if (i == 0)
390 message = PyUnicode_FromString("Error"); /* Sometimes errno didn't get set */ 390 message = PyUnicode_FromString("Error"); /* Sometimes errno didn't get set */
391 else 391 else
392 { 392 {
393 /* Note that the Win32 errors do not lineup with the 393 /* Note that the Win32 errors do not lineup with the
394 errno error. So if the error is in the MSVC error 394 errno error. So if the error is in the MSVC error
395 table, we use it, otherwise we assume it really _is_ 395 table, we use it, otherwise we assume it really _is_
396 a Win32 error code 396 a Win32 error code
397 */ 397 */
398 if (i > 0 && i < _sys_nerr) { 398 if (i > 0 && i < _sys_nerr) {
399 message = PyUnicode_FromString(_sys_errlist[i]); 399 message = PyUnicode_FromString(_sys_errlist[i]);
400 } 400 }
401 else { 401 else {
402 int len = FormatMessageW( 402 int len = FormatMessageW(
403 FORMAT_MESSAGE_ALLOCATE_BUFFER | 403 FORMAT_MESSAGE_ALLOCATE_BUFFER |
404 FORMAT_MESSAGE_FROM_SYSTEM | 404 FORMAT_MESSAGE_FROM_SYSTEM |
405 FORMAT_MESSAGE_IGNORE_INSERTS, 405 FORMAT_MESSAGE_IGNORE_INSERTS,
406 NULL, /* no message source */ 406 NULL, /* no message source */
407 i, 407 i,
408 MAKELANGID(LANG_NEUTRAL, 408 MAKELANGID(LANG_NEUTRAL,
409 SUBLANG_DEFAULT), 409 SUBLANG_DEFAULT),
410 /* Default language */ 410 /* Default language */
411 (LPWSTR) &s_buf, 411 (LPWSTR) &s_buf,
412 0, /* size not used */ 412 0, /* size not used */
413 NULL); /* no args */ 413 NULL); /* no args */
414 if (len==0) { 414 if (len==0) {
415 /* Only ever seen this in out-of-mem 415 /* Only ever seen this in out-of-mem
416 situations */ 416 situations */
417 s_buf = NULL; 417 s_buf = NULL;
418 message = PyUnicode_FromFormat("Windows Error 0x%X", i); 418 message = PyUnicode_FromFormat("Windows Error 0x%X", i);
419 } else { 419 } else {
420 /* remove trailing cr/lf and dots */ 420 /* remove trailing cr/lf and dots */
421 while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.')) 421 while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.'))
422 s_buf[--len] = L'\0'; 422 s_buf[--len] = L'\0';
423 message = PyUnicode_FromUnicode(s_buf, len); 423 message = PyUnicode_FromUnicode(s_buf, len);
424 } 424 }
425 } 425 }
426 } 426 }
427 #endif /* Unix/Windows */ 427 #endif /* Unix/Windows */
428 #endif /* PLAN 9*/ 428 #endif /* PLAN 9*/
429 429
430 if (message == NULL) 430 if (message == NULL)
431 { 431 {
432 #ifdef MS_WINDOWS 432 #ifdef MS_WINDOWS
433 LocalFree(s_buf); 433 LocalFree(s_buf);
434 #endif 434 #endif
435 return NULL; 435 return NULL;
436 } 436 }
437 437
438 if (filenameObject != NULL) 438 if (filenameObject != NULL)
439 v = Py_BuildValue("(iOO)", i, message, filenameObject); 439 v = Py_BuildValue("(iOO)", i, message, filenameObject);
440 else 440 else
441 v = Py_BuildValue("(iO)", i, message); 441 v = Py_BuildValue("(iO)", i, message);
442 Py_DECREF(message); 442 Py_DECREF(message);
443 443
444 if (v != NULL) { 444 if (v != NULL) {
445 PyErr_SetObject(exc, v); 445 PyErr_SetObject(exc, v);
446 Py_DECREF(v); 446 Py_DECREF(v);
447 } 447 }
448 #ifdef MS_WINDOWS 448 #ifdef MS_WINDOWS
449 LocalFree(s_buf); 449 LocalFree(s_buf);
450 #endif 450 #endif
451 return NULL; 451 return NULL;
452 } 452 }
453 453
454 454
455 PyObject * 455 PyObject *
456 PyErr_SetFromErrnoWithFilename(PyObject *exc, const char *filename) 456 PyErr_SetFromErrnoWithFilename(PyObject *exc, const char *filename)
457 { 457 {
458 PyObject *name = filename ? PyUnicode_FromString(filename) : NULL; 458 PyObject *name = filename ? PyUnicode_FromString(filename) : NULL;
459 PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name); 459 PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
460 Py_XDECREF(name); 460 Py_XDECREF(name);
461 return result; 461 return result;
462 } 462 }
463 463
464 #ifdef MS_WINDOWS 464 #ifdef MS_WINDOWS
465 PyObject * 465 PyObject *
466 PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, const Py_UNICODE *filename) 466 PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, const Py_UNICODE *filename)
467 { 467 {
468 PyObject *name = filename ? 468 PyObject *name = filename ?
469 PyUnicode_FromUnicode(filename, wcslen(filename)) : 469 PyUnicode_FromUnicode(filename, wcslen(filename)) :
470 NULL; 470 NULL;
471 PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name); 471 PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
472 Py_XDECREF(name); 472 Py_XDECREF(name);
473 return result; 473 return result;
474 } 474 }
475 #endif /* MS_WINDOWS */ 475 #endif /* MS_WINDOWS */
476 476
477 PyObject * 477 PyObject *
478 PyErr_SetFromErrno(PyObject *exc) 478 PyErr_SetFromErrno(PyObject *exc)
479 { 479 {
480 return PyErr_SetFromErrnoWithFilenameObject(exc, NULL); 480 return PyErr_SetFromErrnoWithFilenameObject(exc, NULL);
481 } 481 }
482 482
483 #ifdef MS_WINDOWS 483 #ifdef MS_WINDOWS
484 /* Windows specific error code handling */ 484 /* Windows specific error code handling */
485 PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject( 485 PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject(
486 PyObject *exc, 486 PyObject *exc,
487 int ierr, 487 int ierr,
488 PyObject *filenameObject) 488 PyObject *filenameObject)
489 { 489 {
490 int len; 490 int len;
491 WCHAR *s_buf = NULL; /* Free via LocalFree */ 491 WCHAR *s_buf = NULL; /* Free via LocalFree */
492 PyObject *message; 492 PyObject *message;
493 PyObject *v; 493 PyObject *v;
494 DWORD err = (DWORD)ierr; 494 DWORD err = (DWORD)ierr;
495 if (err==0) err = GetLastError(); 495 if (err==0) err = GetLastError();
496 len = FormatMessageW( 496 len = FormatMessageW(
497 /* Error API error */ 497 /* Error API error */
498 FORMAT_MESSAGE_ALLOCATE_BUFFER | 498 FORMAT_MESSAGE_ALLOCATE_BUFFER |
499 FORMAT_MESSAGE_FROM_SYSTEM | 499 FORMAT_MESSAGE_FROM_SYSTEM |
500 FORMAT_MESSAGE_IGNORE_INSERTS, 500 FORMAT_MESSAGE_IGNORE_INSERTS,
501 NULL, /* no message source */ 501 NULL, /* no message source */
502 err, 502 err,
503 MAKELANGID(LANG_NEUTRAL, 503 MAKELANGID(LANG_NEUTRAL,
504 SUBLANG_DEFAULT), /* Default language */ 504 SUBLANG_DEFAULT), /* Default language */
505 (LPWSTR) &s_buf, 505 (LPWSTR) &s_buf,
506 0, /* size not used */ 506 0, /* size not used */
507 NULL); /* no args */ 507 NULL); /* no args */
508 if (len==0) { 508 if (len==0) {
509 /* Only seen this in out of mem situations */ 509 /* Only seen this in out of mem situations */
510 message = PyUnicode_FromFormat("Windows Error 0x%X", err); 510 message = PyUnicode_FromFormat("Windows Error 0x%X", err);
511 s_buf = NULL; 511 s_buf = NULL;
512 } else { 512 } else {
513 /* remove trailing cr/lf and dots */ 513 /* remove trailing cr/lf and dots */
514 while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.')) 514 while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.'))
515 s_buf[--len] = L'\0'; 515 s_buf[--len] = L'\0';
516 message = PyUnicode_FromUnicode(s_buf, len); 516 message = PyUnicode_FromUnicode(s_buf, len);
517 } 517 }
518 518
519 if (message == NULL) 519 if (message == NULL)
520 { 520 {
521 LocalFree(s_buf); 521 LocalFree(s_buf);
522 return NULL; 522 return NULL;
523 } 523 }
524 524
525 if (filenameObject != NULL) 525 if (filenameObject != NULL)
526 v = Py_BuildValue("(iOO)", err, message, filenameObject); 526 v = Py_BuildValue("(iOO)", err, message, filenameObject);
527 else 527 else
528 v = Py_BuildValue("(iO)", err, message); 528 v = Py_BuildValue("(iO)", err, message);
529 Py_DECREF(message); 529 Py_DECREF(message);
530 530
531 if (v != NULL) { 531 if (v != NULL) {
532 PyErr_SetObject(exc, v); 532 PyErr_SetObject(exc, v);
533 Py_DECREF(v); 533 Py_DECREF(v);
534 } 534 }
535 LocalFree(s_buf); 535 LocalFree(s_buf);
536 return NULL; 536 return NULL;
537 } 537 }
538 538
539 PyObject *PyErr_SetExcFromWindowsErrWithFilename( 539 PyObject *PyErr_SetExcFromWindowsErrWithFilename(
540 PyObject *exc, 540 PyObject *exc,
541 int ierr, 541 int ierr,
542 const char *filename) 542 const char *filename)
543 { 543 {
544 PyObject *name = filename ? PyUnicode_FromString(filename) : NULL; 544 PyObject *name = filename ? PyUnicode_FromString(filename) : NULL;
545 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc, 545 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
546 ierr, 546 ierr,
547 name); 547 name);
548 Py_XDECREF(name); 548 Py_XDECREF(name);
549 return ret; 549 return ret;
550 } 550 }
551 551
552 PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename( 552 PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename(
553 PyObject *exc, 553 PyObject *exc,
554 int ierr, 554 int ierr,
555 const Py_UNICODE *filename) 555 const Py_UNICODE *filename)
556 { 556 {
557 PyObject *name = filename ? 557 PyObject *name = filename ?
558 PyUnicode_FromUnicode(filename, wcslen(filename)) : 558 PyUnicode_FromUnicode(filename, wcslen(filename)) :
559 NULL; 559 NULL;
560 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc, 560 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
561 ierr, 561 ierr,
562 name); 562 name);
563 Py_XDECREF(name); 563 Py_XDECREF(name);
564 return ret; 564 return ret;
565 } 565 }
566 566
567 PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr) 567 PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr)
568 { 568 {
569 return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL); 569 return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL);
570 } 570 }
571 571
572 PyObject *PyErr_SetFromWindowsErr(int ierr) 572 PyObject *PyErr_SetFromWindowsErr(int ierr)
573 { 573 {
574 return PyErr_SetExcFromWindowsErrWithFilename(PyExc_WindowsError, 574 return PyErr_SetExcFromWindowsErrWithFilename(PyExc_WindowsError,
575 ierr, NULL); 575 ierr, NULL);
576 } 576 }
577 PyObject *PyErr_SetFromWindowsErrWithFilename( 577 PyObject *PyErr_SetFromWindowsErrWithFilename(
578 int ierr, 578 int ierr,
579 const char *filename) 579 const char *filename)
580 { 580 {
581 PyObject *name = filename ? PyUnicode_FromString(filename) : NULL; 581 PyObject *name = filename ? PyUnicode_FromString(filename) : NULL;
582 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject( 582 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
583 PyExc_WindowsError, 583 PyExc_WindowsError,
584 ierr, name); 584 ierr, name);
585 Py_XDECREF(name); 585 Py_XDECREF(name);
586 return result; 586 return result;
587 } 587 }
588 588
589 PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename( 589 PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename(
590 int ierr, 590 int ierr,
591 const Py_UNICODE *filename) 591 const Py_UNICODE *filename)
592 { 592 {
593 PyObject *name = filename ? 593 PyObject *name = filename ?
594 PyUnicode_FromUnicode(filename, wcslen(filename)) : 594 PyUnicode_FromUnicode(filename, wcslen(filename)) :
595 NULL; 595 NULL;
596 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject( 596 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
597 PyExc_WindowsError, 597 PyExc_WindowsError,
598 ierr, name); 598 ierr, name);
599 Py_XDECREF(name); 599 Py_XDECREF(name);
600 return result; 600 return result;
601 } 601 }
602 #endif /* MS_WINDOWS */ 602 #endif /* MS_WINDOWS */
603 603
604 void 604 void
605 _PyErr_BadInternalCall(const char *filename, int lineno) 605 _PyErr_BadInternalCall(const char *filename, int lineno)
606 { 606 {
607 PyErr_Format(PyExc_SystemError, 607 PyErr_Format(PyExc_SystemError,
608 "%s:%d: bad argument to internal function", 608 "%s:%d: bad argument to internal function",
609 filename, lineno); 609 filename, lineno);
610 } 610 }
611 611
612 /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can 612 /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can
613 export the entry point for existing object code: */ 613 export the entry point for existing object code: */
614 #undef PyErr_BadInternalCall 614 #undef PyErr_BadInternalCall
615 void 615 void
616 PyErr_BadInternalCall(void) 616 PyErr_BadInternalCall(void)
617 { 617 {
618 PyErr_Format(PyExc_SystemError, 618 PyErr_Format(PyExc_SystemError,
619 "bad argument to internal function"); 619 "bad argument to internal function");
620 } 620 }
621 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__) 621 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
622 622
623 623
624 624
625 PyObject * 625 PyObject *
626 PyErr_Format(PyObject *exception, const char *format, ...) 626 PyErr_Format(PyObject *exception, const char *format, ...)
627 { 627 {
628 va_list vargs; 628 va_list vargs;
629 PyObject* string; 629 PyObject* string;
630 630
631 #ifdef HAVE_STDARG_PROTOTYPES 631 #ifdef HAVE_STDARG_PROTOTYPES
632 va_start(vargs, format); 632 va_start(vargs, format);
633 #else 633 #else
634 va_start(vargs); 634 va_start(vargs);
635 #endif 635 #endif
636 636
637 string = PyUnicode_FromFormatV(format, vargs); 637 string = PyUnicode_FromFormatV(format, vargs);
638 PyErr_SetObject(exception, string); 638 PyErr_SetObject(exception, string);
639 Py_XDECREF(string); 639 Py_XDECREF(string);
640 va_end(vargs); 640 va_end(vargs);
641 return NULL; 641 return NULL;
642 } 642 }
643 643
644 644
645 645
646 PyObject * 646 PyObject *
647 PyErr_NewException(const char *name, PyObject *base, PyObject *dict) 647 PyErr_NewException(const char *name, PyObject *base, PyObject *dict)
648 { 648 {
649 const char *dot; 649 const char *dot;
650 PyObject *modulename = NULL; 650 PyObject *modulename = NULL;
651 PyObject *classname = NULL; 651 PyObject *classname = NULL;
652 PyObject *mydict = NULL; 652 PyObject *mydict = NULL;
653 PyObject *bases = NULL; 653 PyObject *bases = NULL;
654 PyObject *result = NULL; 654 PyObject *result = NULL;
655 dot = strrchr(name, '.'); 655 dot = strrchr(name, '.');
656 if (dot == NULL) { 656 if (dot == NULL) {
657 PyErr_SetString(PyExc_SystemError, 657 PyErr_SetString(PyExc_SystemError,
658 "PyErr_NewException: name must be module.class"); 658 "PyErr_NewException: name must be module.class");
659 return NULL; 659 return NULL;
660 } 660 }
661 if (base == NULL) 661 if (base == NULL)
662 base = PyExc_Exception; 662 base = PyExc_Exception;
663 if (dict == NULL) { 663 if (dict == NULL) {
664 dict = mydict = PyDict_New(); 664 dict = mydict = PyDict_New();
665 if (dict == NULL) 665 if (dict == NULL)
666 goto failure; 666 goto failure;
667 } 667 }
668 if (PyDict_GetItemString(dict, "__module__") == NULL) { 668 if (PyDict_GetItemString(dict, "__module__") == NULL) {
669 modulename = PyUnicode_FromStringAndSize(name, 669 modulename = PyUnicode_FromStringAndSize(name,
670 (Py_ssize_t)(dot-name)); 670 (Py_ssize_t)(dot-name));
671 if (modulename == NULL) 671 if (modulename == NULL)
672 goto failure; 672 goto failure;
673 if (PyDict_SetItemString(dict, "__module__", modulename) != 0) 673 if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
674 goto failure; 674 goto failure;
675 } 675 }
676 if (PyTuple_Check(base)) { 676 if (PyTuple_Check(base)) {
677 bases = base; 677 bases = base;
678 /* INCREF as we create a new ref in the else branch */ 678 /* INCREF as we create a new ref in the else branch */
679 Py_INCREF(bases); 679 Py_INCREF(bases);
680 } else { 680 } else {
681 bases = PyTuple_Pack(1, base); 681 bases = PyTuple_Pack(1, base);
682 if (bases == NULL) 682 if (bases == NULL)
683 goto failure; 683 goto failure;
684 } 684 }
685 /* Create a real new-style class. */ 685 /* Create a real new-style class. */
686 result = PyObject_CallFunction((PyObject *)&PyType_Type, "UOO", 686 result = PyObject_CallFunction((PyObject *)&PyType_Type, "UOO",
687 dot+1, bases, dict); 687 dot+1, bases, dict);
688 failure: 688 failure:
689 Py_XDECREF(bases); 689 Py_XDECREF(bases);
690 Py_XDECREF(mydict); 690 Py_XDECREF(mydict);
691 Py_XDECREF(classname); 691 Py_XDECREF(classname);
692 Py_XDECREF(modulename); 692 Py_XDECREF(modulename);
693 return result; 693 return result;
694 } 694 }
695 695
696 /* Call when an exception has occurred but there is no way for Python 696 /* Call when an exception has occurred but there is no way for Python
697 to handle it. Examples: exception in __del__ or during GC. */ 697 to handle it. Examples: exception in __del__ or during GC. */
698 void 698 void
699 PyErr_WriteUnraisable(PyObject *obj) 699 PyErr_WriteUnraisable(PyObject *obj)
700 { 700 {
701 PyObject *f, *t, *v, *tb; 701 PyObject *f, *t, *v, *tb;
702 PyErr_Fetch(&t, &v, &tb); 702 PyErr_Fetch(&t, &v, &tb);
703 f = PySys_GetObject("stderr"); 703 f = PySys_GetObject("stderr");
704 if (f != NULL && f != Py_None) { 704 if (f != NULL && f != Py_None) {
705 PyFile_WriteString("Exception ", f); 705 PyFile_WriteString("Exception ", f);
706 if (t) { 706 if (t) {
707 PyObject* moduleName; 707 PyObject* moduleName;
708 char* className; 708 char* className;
709 assert(PyExceptionClass_Check(t)); 709 assert(PyExceptionClass_Check(t));
710 className = PyExceptionClass_Name(t); 710 className = PyExceptionClass_Name(t);
711 if (className != NULL) { 711 if (className != NULL) {
712 char *dot = strrchr(className, '.'); 712 char *dot = strrchr(className, '.');
713 if (dot != NULL) 713 if (dot != NULL)
714 className = dot+1; 714 className = dot+1;
715 } 715 }
716 716
717 moduleName = PyObject_GetAttrString(t, "__module__"); 717 moduleName = PyObject_GetAttrString(t, "__module__");
718 if (moduleName == NULL) 718 if (moduleName == NULL)
719 PyFile_WriteString("<unknown>", f); 719 PyFile_WriteString("<unknown>", f);
720 else { 720 else {
721 char* modstr = _PyUnicode_AsString(moduleName); 721 char* modstr = _PyUnicode_AsString(moduleName);
722 if (modstr && 722 if (modstr &&
723 strcmp(modstr, "builtins") != 0) 723 strcmp(modstr, "builtins") != 0)
724 { 724 {
725 PyFile_WriteString(modstr, f); 725 PyFile_WriteString(modstr, f);
726 PyFile_WriteString(".", f); 726 PyFile_WriteString(".", f);
727 } 727 }
728 } 728 }
729 if (className == NULL) 729 if (className == NULL)
730 PyFile_WriteString("<unknown>", f); 730 PyFile_WriteString("<unknown>", f);
731 else 731 else
732 PyFile_WriteString(className, f); 732 PyFile_WriteString(className, f);
733 if (v && v != Py_None) { 733 if (v && v != Py_None) {
734 PyFile_WriteString(": ", f); 734 PyFile_WriteString(": ", f);
735 PyFile_WriteObject(v, f, 0); 735 PyFile_WriteObject(v, f, 0);
736 } 736 }
737 Py_XDECREF(moduleName); 737 Py_XDECREF(moduleName);
738 } 738 }
739 PyFile_WriteString(" in ", f); 739 PyFile_WriteString(" in ", f);
740 PyFile_WriteObject(obj, f, 0); 740 PyFile_WriteObject(obj, f, 0);
741 PyFile_WriteString(" ignored\n", f); 741 PyFile_WriteString(" ignored\n", f);
742 PyErr_Clear(); /* Just in case */ 742 PyErr_Clear(); /* Just in case */
743 } 743 }
744 Py_XDECREF(t); 744 Py_XDECREF(t);
745 Py_XDECREF(v); 745 Py_XDECREF(v);
746 Py_XDECREF(tb); 746 Py_XDECREF(tb);
747 } 747 }
748 748
749 extern PyObject *PyModule_GetWarningsModule(void); 749 extern PyObject *PyModule_GetWarningsModule(void);
750 750
751 751
754 to make printing of exceptions believe it is a syntax error. */ 754 to make printing of exceptions believe it is a syntax error. */
755 755
756 void 756 void
757 PyErr_SyntaxLocation(const char *filename, int lineno) 757 PyErr_SyntaxLocation(const char *filename, int lineno)
758 { 758 {
759 PyObject *exc, *v, *tb, *tmp; 759 PyObject *exc, *v, *tb, *tmp;
760 760
761 /* add attributes for the line number and filename for the error */ 761 /* add attributes for the line number and filename for the error */
762 PyErr_Fetch(&exc, &v, &tb); 762 PyErr_Fetch(&exc, &v, &tb);
763 PyErr_NormalizeException(&exc, &v, &tb); 763 PyErr_NormalizeException(&exc, &v, &tb);
764 /* XXX check that it is, indeed, a syntax error. It might not 764 /* XXX check that it is, indeed, a syntax error. It might not
765 * be, though. */ 765 * be, though. */
766 tmp = PyLong_FromLong(lineno); 766 tmp = PyLong_FromLong(lineno);
767 if (tmp == NULL) 767 if (tmp == NULL)
768 PyErr_Clear(); 768 PyErr_Clear();
769 else { 769 else {
770 if (PyObject_SetAttrString(v, "lineno", tmp)) 770 if (PyObject_SetAttrString(v, "lineno", tmp))
771 PyErr_Clear(); 771 PyErr_Clear();
772 Py_DECREF(tmp); 772 Py_DECREF(tmp);
773 } 773 }
774 if (filename != NULL) { 774 if (filename != NULL) {
775 tmp = PyUnicode_FromString(filename); 775 tmp = PyUnicode_FromString(filename);
776 if (tmp == NULL) 776 if (tmp == NULL)
777 PyErr_Clear(); 777 PyErr_Clear();
778 else { 778 else {
779 if (PyObject_SetAttrString(v, "filename", tmp)) 779 if (PyObject_SetAttrString(v, "filename", tmp))
780 PyErr_Clear(); 780 PyErr_Clear();
781 Py_DECREF(tmp); 781 Py_DECREF(tmp);
782 } 782 }
783 783
784 tmp = PyErr_ProgramText(filename, lineno); 784 tmp = PyErr_ProgramText(filename, lineno);
785 if (tmp) { 785 if (tmp) {
786 if (PyObject_SetAttrString(v, "text", tmp)) 786 if (PyObject_SetAttrString(v, "text", tmp))
787 PyErr_Clear(); 787 PyErr_Clear();
788 Py_DECREF(tmp); 788 Py_DECREF(tmp);
789 } 789 }
790 } 790 }
791 if (PyObject_SetAttrString(v, "offset", Py_None)) { 791 if (PyObject_SetAttrString(v, "offset", Py_None)) {
792 PyErr_Clear(); 792 PyErr_Clear();
793 } 793 }
794 if (exc != PyExc_SyntaxError) { 794 if (exc != PyExc_SyntaxError) {
795 if (!PyObject_HasAttrString(v, "msg")) { 795 if (!PyObject_HasAttrString(v, "msg")) {
796 tmp = PyObject_Str(v); 796 tmp = PyObject_Str(v);
797 if (tmp) { 797 if (tmp) {
798 if (PyObject_SetAttrString(v, "msg", tmp)) 798 if (PyObject_SetAttrString(v, "msg", tmp))
799 PyErr_Clear(); 799 PyErr_Clear();
800 Py_DECREF(tmp); 800 Py_DECREF(tmp);
801 } else { 801 } else {
802 PyErr_Clear(); 802 PyErr_Clear();
803 } 803 }
804 } 804 }
805 if (!PyObject_HasAttrString(v, "print_file_and_line")) { 805 if (!PyObject_HasAttrString(v, "print_file_and_line")) {
806 if (PyObject_SetAttrString(v, "print_file_and_line", 806 if (PyObject_SetAttrString(v, "print_file_and_line",
807 Py_None)) 807 Py_None))
808 PyErr_Clear(); 808 PyErr_Clear();
809 } 809 }
810 } 810 }
811 PyErr_Restore(exc, v, tb); 811 PyErr_Restore(exc, v, tb);
812 } 812 }
813 813
814 /* Attempt to load the line of text that the exception refers to. If it 814 /* Attempt to load the line of text that the exception refers to. If it
815 fails, it will return NULL but will not set an exception. 815 fails, it will return NULL but will not set an exception.
816 816
818 functionality in tb_displayline() in traceback.c. */ 818 functionality in tb_displayline() in traceback.c. */
819 819
820 PyObject * 820 PyObject *
821 PyErr_ProgramText(const char *filename, int lineno) 821 PyErr_ProgramText(const char *filename, int lineno)
822 { 822 {
823 FILE *fp; 823 FILE *fp;
824 int i; 824 int i;
825 char linebuf[1000]; 825 char linebuf[1000];
826 826
827 if (filename == NULL || *filename == '\0' || lineno <= 0) 827 if (filename == NULL || *filename == '\0' || lineno <= 0)
828 return NULL; 828 return NULL;
829 fp = fopen(filename, "r" PY_STDIOTEXTMODE); 829 fp = fopen(filename, "r" PY_STDIOTEXTMODE);
830 if (fp == NULL) 830 if (fp == NULL)
831 return NULL; 831 return NULL;
832 for (i = 0; i < lineno; i++) { 832 for (i = 0; i < lineno; i++) {
833 char *pLastChar = &linebuf[sizeof(linebuf) - 2]; 833 char *pLastChar = &linebuf[sizeof(linebuf) - 2];
834 do { 834 do {
835 *pLastChar = '\0'; 835 *pLastChar = '\0';
836 if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, 836 if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf,
837 fp, NULL) == NULL) 837 fp, NULL) == NULL)
838 break; 838 break;
839 /* fgets read *something*; if it didn't get as 839 /* fgets read *something*; if it didn't get as
840 far as pLastChar, it must have found a newline 840 far as pLastChar, it must have found a newline
841 or hit the end of the file; if pLastChar is \n, 841 or hit the end of the file; if pLastChar is \n,
842 it obviously found a newline; else we haven't 842 it obviously found a newline; else we haven't
843 yet seen a newline, so must continue */ 843 yet seen a newline, so must continue */
844 } while (*pLastChar != '\0' && *pLastChar != '\n'); 844 } while (*pLastChar != '\0' && *pLastChar != '\n');
845 } 845 }
846 fclose(fp); 846 fclose(fp);
847 if (i == lineno) { 847 if (i == lineno) {
848 char *p = linebuf; 848 char *p = linebuf;
849 PyObject *res; 849 PyObject *res;
850 while (*p == ' ' || *p == '\t' || *p == '\014') 850 while (*p == ' ' || *p == '\t' || *p == '\014')
851 p++; 851 p++;
852 res = PyUnicode_FromString(p); 852 res = PyUnicode_FromString(p);
853 if (res == NULL) 853 if (res == NULL)
854 PyErr_Clear(); 854 PyErr_Clear();
855 return res; 855 return res;
856 } 856 }
857 return NULL; 857 return NULL;
858 } 858 }
859 859
860 #ifdef __cplusplus 860 #ifdef __cplusplus
861 } 861 }
862 #endif 862 #endif