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