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