/xbmc/lib/libPython/Python/Python/exceptions.c
C | 1859 lines | 1392 code | 329 blank | 138 comment | 206 complexity | c550c6f89e17911ca5c7da96a37d7b3e MD5 | raw file
1/* This module provides the suite of standard class-based exceptions for
2 * Python's builtin module. This is a complete C implementation of what,
3 * in Python 1.5.2, was contained in the exceptions.py module. The problem
4 * there was that if exceptions.py could not be imported for some reason,
5 * the entire interpreter would abort.
6 *
7 * By moving the exceptions into C and statically linking, we can guarantee
8 * that the standard exceptions will always be available.
9 *
10 * history:
11 * 98-08-19 fl created (for pyexe)
12 * 00-02-08 fl updated for 1.5.2
13 * 26-May-2000 baw vetted for Python 1.6
14 *
15 * written by Fredrik Lundh
16 * modifications, additions, cleanups, and proofreading by Barry Warsaw
17 *
18 * Copyright (c) 1998-2000 by Secret Labs AB. All rights reserved.
19 */
20
21#include "Python.h"
22#include "osdefs.h"
23
24/* Caution: MS Visual C++ 6 errors if a single string literal exceeds
25 * 2Kb. So the module docstring has been broken roughly in half, using
26 * compile-time literal concatenation.
27 */
28
29/* NOTE: If the exception class hierarchy changes, don't forget to update
30 * Doc/lib/libexcs.tex!
31 */
32
33PyDoc_STRVAR(module__doc__,
34"Python's standard exception class hierarchy.\n\
35\n\
36Before Python 1.5, the standard exceptions were all simple string objects.\n\
37In Python 1.5, the standard exceptions were converted to classes organized\n\
38into a relatively flat hierarchy. String-based standard exceptions were\n\
39optional, or used as a fallback if some problem occurred while importing\n\
40the exception module. With Python 1.6, optional string-based standard\n\
41exceptions were removed (along with the -X command line flag).\n\
42\n\
43The class exceptions were implemented in such a way as to be almost\n\
44completely backward compatible. Some tricky uses of IOError could\n\
45potentially have broken, but by Python 1.6, all of these should have\n\
46been fixed. As of Python 1.6, the class-based standard exceptions are\n\
47now implemented in C, and are guaranteed to exist in the Python\n\
48interpreter.\n\
49\n\
50Here is a rundown of the class hierarchy. The classes found here are\n\
51inserted into both the exceptions module and the `built-in' module. It is\n\
52recommended that user defined class based exceptions be derived from the\n\
53`Exception' class, although this is currently not enforced.\n"
54 /* keep string pieces "small" */
55"\n\
56Exception\n\
57 |\n\
58 +-- SystemExit\n\
59 +-- StopIteration\n\
60 +-- StandardError\n\
61 | |\n\
62 | +-- KeyboardInterrupt\n\
63 | +-- ImportError\n\
64 | +-- EnvironmentError\n\
65 | | |\n\
66 | | +-- IOError\n\
67 | | +-- OSError\n\
68 | | |\n\
69 | | +-- WindowsError\n\
70 | | +-- VMSError\n\
71 | |\n\
72 | +-- EOFError\n\
73 | +-- RuntimeError\n\
74 | | |\n\
75 | | +-- NotImplementedError\n\
76 | |\n\
77 | +-- NameError\n\
78 | | |\n\
79 | | +-- UnboundLocalError\n\
80 | |\n\
81 | +-- AttributeError\n\
82 | +-- SyntaxError\n\
83 | | |\n\
84 | | +-- IndentationError\n\
85 | | |\n\
86 | | +-- TabError\n\
87 | |\n\
88 | +-- TypeError\n\
89 | +-- AssertionError\n\
90 | +-- LookupError\n\
91 | | |\n\
92 | | +-- IndexError\n\
93 | | +-- KeyError\n\
94 | |\n\
95 | +-- ArithmeticError\n\
96 | | |\n\
97 | | +-- OverflowError\n\
98 | | +-- ZeroDivisionError\n\
99 | | +-- FloatingPointError\n\
100 | |\n\
101 | +-- ValueError\n\
102 | | |\n\
103 | | +-- UnicodeError\n\
104 | | |\n\
105 | | +-- UnicodeEncodeError\n\
106 | | +-- UnicodeDecodeError\n\
107 | | +-- UnicodeTranslateError\n\
108 | |\n\
109 | +-- ReferenceError\n\
110 | +-- SystemError\n\
111 | +-- MemoryError\n\
112 |\n\
113 +---Warning\n\
114 |\n\
115 +-- UserWarning\n\
116 +-- DeprecationWarning\n\
117 +-- PendingDeprecationWarning\n\
118 +-- SyntaxWarning\n\
119 +-- OverflowWarning\n\
120 +-- RuntimeWarning\n\
121 +-- FutureWarning"
122);
123
124
125/* Helper function for populating a dictionary with method wrappers. */
126static int
127populate_methods(PyObject *klass, PyObject *dict, PyMethodDef *methods)
128{
129 PyObject *module;
130 int status = -1;
131
132 if (!methods)
133 return 0;
134
135 module = PyString_FromString("exceptions");
136 if (!module)
137 return 0;
138 while (methods->ml_name) {
139 /* get a wrapper for the built-in function */
140 PyObject *func = PyCFunction_NewEx(methods, NULL, module);
141 PyObject *meth;
142
143 if (!func)
144 goto status;
145
146 /* turn the function into an unbound method */
147 if (!(meth = PyMethod_New(func, NULL, klass))) {
148 Py_DECREF(func);
149 goto status;
150 }
151
152 /* add method to dictionary */
153 status = PyDict_SetItemString(dict, methods->ml_name, meth);
154 Py_DECREF(meth);
155 Py_DECREF(func);
156
157 /* stop now if an error occurred, otherwise do the next method */
158 if (status)
159 goto status;
160
161 methods++;
162 }
163 status = 0;
164 status:
165 Py_DECREF(module);
166 return status;
167}
168
169
170
171/* This function is used to create all subsequent exception classes. */
172static int
173make_class(PyObject **klass, PyObject *base,
174 char *name, PyMethodDef *methods,
175 char *docstr)
176{
177 PyObject *dict = PyDict_New();
178 PyObject *str = NULL;
179 int status = -1;
180
181 if (!dict)
182 return -1;
183
184 /* If an error occurs from here on, goto finally instead of explicitly
185 * returning NULL.
186 */
187
188 if (docstr) {
189 if (!(str = PyString_FromString(docstr)))
190 goto finally;
191 if (PyDict_SetItemString(dict, "__doc__", str))
192 goto finally;
193 }
194
195 if (!(*klass = PyErr_NewException(name, base, dict)))
196 goto finally;
197
198 if (populate_methods(*klass, dict, methods)) {
199 Py_DECREF(*klass);
200 *klass = NULL;
201 goto finally;
202 }
203
204 status = 0;
205
206 finally:
207 Py_XDECREF(dict);
208 Py_XDECREF(str);
209 return status;
210}
211
212
213/* Use this for *args signatures, otherwise just use PyArg_ParseTuple() */
214static PyObject *
215get_self(PyObject *args)
216{
217 PyObject *self = PyTuple_GetItem(args, 0);
218 if (!self) {
219 /* Watch out for being called to early in the bootstrapping process */
220 if (PyExc_TypeError) {
221 PyErr_SetString(PyExc_TypeError,
222 "unbound method must be called with instance as first argument");
223 }
224 return NULL;
225 }
226 return self;
227}
228
229
230
231/* Notes on bootstrapping the exception classes.
232 *
233 * First thing we create is the base class for all exceptions, called
234 * appropriately enough: Exception. Creation of this class makes no
235 * assumptions about the existence of any other exception class -- except
236 * for TypeError, which can conditionally exist.
237 *
238 * Next, StandardError is created (which is quite simple) followed by
239 * TypeError, because the instantiation of other exceptions can potentially
240 * throw a TypeError. Once these exceptions are created, all the others
241 * can be created in any order. See the static exctable below for the
242 * explicit bootstrap order.
243 *
244 * All classes after Exception can be created using PyErr_NewException().
245 */
246
247PyDoc_STRVAR(Exception__doc__, "Common base class for all exceptions.");
248
249
250static PyObject *
251Exception__init__(PyObject *self, PyObject *args)
252{
253 int status;
254
255 if (!(self = get_self(args)))
256 return NULL;
257
258 /* set args attribute */
259 /* XXX size is only a hint */
260 args = PySequence_GetSlice(args, 1, PySequence_Size(args));
261 if (!args)
262 return NULL;
263 status = PyObject_SetAttrString(self, "args", args);
264 Py_DECREF(args);
265 if (status < 0)
266 return NULL;
267
268 Py_INCREF(Py_None);
269 return Py_None;
270}
271
272
273static PyObject *
274Exception__str__(PyObject *self, PyObject *args)
275{
276 PyObject *out;
277
278 if (!PyArg_ParseTuple(args, "O:__str__", &self))
279 return NULL;
280
281 args = PyObject_GetAttrString(self, "args");
282 if (!args)
283 return NULL;
284
285 switch (PySequence_Size(args)) {
286 case 0:
287 out = PyString_FromString("");
288 break;
289 case 1:
290 {
291 PyObject *tmp = PySequence_GetItem(args, 0);
292 if (tmp) {
293 out = PyObject_Str(tmp);
294 Py_DECREF(tmp);
295 }
296 else
297 out = NULL;
298 break;
299 }
300 case -1:
301 PyErr_Clear();
302 /* Fall through */
303 default:
304 out = PyObject_Str(args);
305 break;
306 }
307
308 Py_DECREF(args);
309 return out;
310}
311
312
313static PyObject *
314Exception__getitem__(PyObject *self, PyObject *args)
315{
316 PyObject *out;
317 PyObject *index;
318
319 if (!PyArg_ParseTuple(args, "OO:__getitem__", &self, &index))
320 return NULL;
321
322 args = PyObject_GetAttrString(self, "args");
323 if (!args)
324 return NULL;
325
326 out = PyObject_GetItem(args, index);
327 Py_DECREF(args);
328 return out;
329}
330
331
332static PyMethodDef
333Exception_methods[] = {
334 /* methods for the Exception class */
335 { "__getitem__", Exception__getitem__, METH_VARARGS},
336 { "__str__", Exception__str__, METH_VARARGS},
337 { "__init__", Exception__init__, METH_VARARGS},
338 { NULL, NULL }
339};
340
341
342static int
343make_Exception(char *modulename)
344{
345 PyObject *dict = PyDict_New();
346 PyObject *str = NULL;
347 PyObject *name = NULL;
348 int status = -1;
349
350 if (!dict)
351 return -1;
352
353 /* If an error occurs from here on, goto finally instead of explicitly
354 * returning NULL.
355 */
356
357 if (!(str = PyString_FromString(modulename)))
358 goto finally;
359 if (PyDict_SetItemString(dict, "__module__", str))
360 goto finally;
361 Py_DECREF(str);
362 if (!(str = PyString_FromString(Exception__doc__)))
363 goto finally;
364 if (PyDict_SetItemString(dict, "__doc__", str))
365 goto finally;
366
367 if (!(name = PyString_FromString("Exception")))
368 goto finally;
369
370 if (!(PyExc_Exception = PyClass_New(NULL, dict, name)))
371 goto finally;
372
373 /* Now populate the dictionary with the method suite */
374 if (populate_methods(PyExc_Exception, dict, Exception_methods))
375 /* Don't need to reclaim PyExc_Exception here because that'll
376 * happen during interpreter shutdown.
377 */
378 goto finally;
379
380 status = 0;
381
382 finally:
383 Py_XDECREF(dict);
384 Py_XDECREF(str);
385 Py_XDECREF(name);
386 return status;
387}
388
389
390
391PyDoc_STRVAR(StandardError__doc__,
392"Base class for all standard Python exceptions.");
393
394PyDoc_STRVAR(TypeError__doc__, "Inappropriate argument type.");
395
396PyDoc_STRVAR(StopIteration__doc__, "Signal the end from iterator.next().");
397
398
399
400PyDoc_STRVAR(SystemExit__doc__, "Request to exit from the interpreter.");
401
402
403static PyObject *
404SystemExit__init__(PyObject *self, PyObject *args)
405{
406 PyObject *code;
407 int status;
408
409 if (!(self = get_self(args)))
410 return NULL;
411
412 /* Set args attribute. */
413 if (!(args = PySequence_GetSlice(args, 1, PySequence_Size(args))))
414 return NULL;
415
416 status = PyObject_SetAttrString(self, "args", args);
417 if (status < 0) {
418 Py_DECREF(args);
419 return NULL;
420 }
421
422 /* set code attribute */
423 switch (PySequence_Size(args)) {
424 case 0:
425 Py_INCREF(Py_None);
426 code = Py_None;
427 break;
428 case 1:
429 code = PySequence_GetItem(args, 0);
430 break;
431 case -1:
432 PyErr_Clear();
433 /* Fall through */
434 default:
435 Py_INCREF(args);
436 code = args;
437 break;
438 }
439
440 status = PyObject_SetAttrString(self, "code", code);
441 Py_DECREF(code);
442 Py_DECREF(args);
443 if (status < 0)
444 return NULL;
445
446 Py_INCREF(Py_None);
447 return Py_None;
448}
449
450
451static PyMethodDef SystemExit_methods[] = {
452 { "__init__", SystemExit__init__, METH_VARARGS},
453 {NULL, NULL}
454};
455
456
457
458PyDoc_STRVAR(KeyboardInterrupt__doc__, "Program interrupted by user.");
459
460PyDoc_STRVAR(ImportError__doc__,
461"Import can't find module, or can't find name in module.");
462
463
464
465PyDoc_STRVAR(EnvironmentError__doc__, "Base class for I/O related errors.");
466
467
468static PyObject *
469EnvironmentError__init__(PyObject *self, PyObject *args)
470{
471 PyObject *item0 = NULL;
472 PyObject *item1 = NULL;
473 PyObject *item2 = NULL;
474 PyObject *subslice = NULL;
475 PyObject *rtnval = NULL;
476
477 if (!(self = get_self(args)))
478 return NULL;
479
480 if (!(args = PySequence_GetSlice(args, 1, PySequence_Size(args))))
481 return NULL;
482
483 if (PyObject_SetAttrString(self, "args", args) ||
484 PyObject_SetAttrString(self, "errno", Py_None) ||
485 PyObject_SetAttrString(self, "strerror", Py_None) ||
486 PyObject_SetAttrString(self, "filename", Py_None))
487 {
488 goto finally;
489 }
490
491 switch (PySequence_Size(args)) {
492 case 3:
493 /* Where a function has a single filename, such as open() or some
494 * of the os module functions, PyErr_SetFromErrnoWithFilename() is
495 * called, giving a third argument which is the filename. But, so
496 * that old code using in-place unpacking doesn't break, e.g.:
497 *
498 * except IOError, (errno, strerror):
499 *
500 * we hack args so that it only contains two items. This also
501 * means we need our own __str__() which prints out the filename
502 * when it was supplied.
503 */
504 item0 = PySequence_GetItem(args, 0);
505 item1 = PySequence_GetItem(args, 1);
506 item2 = PySequence_GetItem(args, 2);
507 if (!item0 || !item1 || !item2)
508 goto finally;
509
510 if (PyObject_SetAttrString(self, "errno", item0) ||
511 PyObject_SetAttrString(self, "strerror", item1) ||
512 PyObject_SetAttrString(self, "filename", item2))
513 {
514 goto finally;
515 }
516
517 subslice = PySequence_GetSlice(args, 0, 2);
518 if (!subslice || PyObject_SetAttrString(self, "args", subslice))
519 goto finally;
520 break;
521
522 case 2:
523 /* Used when PyErr_SetFromErrno() is called and no filename
524 * argument is given.
525 */
526 item0 = PySequence_GetItem(args, 0);
527 item1 = PySequence_GetItem(args, 1);
528 if (!item0 || !item1)
529 goto finally;
530
531 if (PyObject_SetAttrString(self, "errno", item0) ||
532 PyObject_SetAttrString(self, "strerror", item1))
533 {
534 goto finally;
535 }
536 break;
537
538 case -1:
539 PyErr_Clear();
540 break;
541 }
542
543 Py_INCREF(Py_None);
544 rtnval = Py_None;
545
546 finally:
547 Py_DECREF(args);
548 Py_XDECREF(item0);
549 Py_XDECREF(item1);
550 Py_XDECREF(item2);
551 Py_XDECREF(subslice);
552 return rtnval;
553}
554
555
556static PyObject *
557EnvironmentError__str__(PyObject *self, PyObject *args)
558{
559 PyObject *originalself = self;
560 PyObject *filename;
561 PyObject *serrno;
562 PyObject *strerror;
563 PyObject *rtnval = NULL;
564
565 if (!PyArg_ParseTuple(args, "O:__str__", &self))
566 return NULL;
567
568 filename = PyObject_GetAttrString(self, "filename");
569 serrno = PyObject_GetAttrString(self, "errno");
570 strerror = PyObject_GetAttrString(self, "strerror");
571 if (!filename || !serrno || !strerror)
572 goto finally;
573
574 if (filename != Py_None) {
575 PyObject *fmt = PyString_FromString("[Errno %s] %s: %s");
576 PyObject *repr = PyObject_Repr(filename);
577 PyObject *tuple = PyTuple_New(3);
578
579 if (!fmt || !repr || !tuple) {
580 Py_XDECREF(fmt);
581 Py_XDECREF(repr);
582 Py_XDECREF(tuple);
583 goto finally;
584 }
585
586 PyTuple_SET_ITEM(tuple, 0, serrno);
587 PyTuple_SET_ITEM(tuple, 1, strerror);
588 PyTuple_SET_ITEM(tuple, 2, repr);
589
590 rtnval = PyString_Format(fmt, tuple);
591
592 Py_DECREF(fmt);
593 Py_DECREF(tuple);
594 /* already freed because tuple owned only reference */
595 serrno = NULL;
596 strerror = NULL;
597 }
598 else if (PyObject_IsTrue(serrno) && PyObject_IsTrue(strerror)) {
599 PyObject *fmt = PyString_FromString("[Errno %s] %s");
600 PyObject *tuple = PyTuple_New(2);
601
602 if (!fmt || !tuple) {
603 Py_XDECREF(fmt);
604 Py_XDECREF(tuple);
605 goto finally;
606 }
607
608 PyTuple_SET_ITEM(tuple, 0, serrno);
609 PyTuple_SET_ITEM(tuple, 1, strerror);
610
611 rtnval = PyString_Format(fmt, tuple);
612
613 Py_DECREF(fmt);
614 Py_DECREF(tuple);
615 /* already freed because tuple owned only reference */
616 serrno = NULL;
617 strerror = NULL;
618 }
619 else
620 /* The original Python code said:
621 *
622 * return StandardError.__str__(self)
623 *
624 * but there is no StandardError__str__() function; we happen to
625 * know that's just a pass through to Exception__str__().
626 */
627 rtnval = Exception__str__(originalself, args);
628
629 finally:
630 Py_XDECREF(filename);
631 Py_XDECREF(serrno);
632 Py_XDECREF(strerror);
633 return rtnval;
634}
635
636
637static
638PyMethodDef EnvironmentError_methods[] = {
639 {"__init__", EnvironmentError__init__, METH_VARARGS},
640 {"__str__", EnvironmentError__str__, METH_VARARGS},
641 {NULL, NULL}
642};
643
644
645
646
647PyDoc_STRVAR(IOError__doc__, "I/O operation failed.");
648
649PyDoc_STRVAR(OSError__doc__, "OS system call failed.");
650
651#ifdef MS_WINDOWS
652PyDoc_STRVAR(WindowsError__doc__, "MS-Windows OS system call failed.");
653#endif /* MS_WINDOWS */
654
655#ifdef __VMS
656static char
657VMSError__doc__[] = "OpenVMS OS system call failed.";
658#endif
659
660PyDoc_STRVAR(EOFError__doc__, "Read beyond end of file.");
661
662PyDoc_STRVAR(RuntimeError__doc__, "Unspecified run-time error.");
663
664PyDoc_STRVAR(NotImplementedError__doc__,
665"Method or function hasn't been implemented yet.");
666
667PyDoc_STRVAR(NameError__doc__, "Name not found globally.");
668
669PyDoc_STRVAR(UnboundLocalError__doc__,
670"Local name referenced but not bound to a value.");
671
672PyDoc_STRVAR(AttributeError__doc__, "Attribute not found.");
673
674
675
676PyDoc_STRVAR(SyntaxError__doc__, "Invalid syntax.");
677
678
679static int
680SyntaxError__classinit__(PyObject *klass)
681{
682 int retval = 0;
683 PyObject *emptystring = PyString_FromString("");
684
685 /* Additional class-creation time initializations */
686 if (!emptystring ||
687 PyObject_SetAttrString(klass, "msg", emptystring) ||
688 PyObject_SetAttrString(klass, "filename", Py_None) ||
689 PyObject_SetAttrString(klass, "lineno", Py_None) ||
690 PyObject_SetAttrString(klass, "offset", Py_None) ||
691 PyObject_SetAttrString(klass, "text", Py_None) ||
692 PyObject_SetAttrString(klass, "print_file_and_line", Py_None))
693 {
694 retval = -1;
695 }
696 Py_XDECREF(emptystring);
697 return retval;
698}
699
700
701static PyObject *
702SyntaxError__init__(PyObject *self, PyObject *args)
703{
704 PyObject *rtnval = NULL;
705 int lenargs;
706
707 if (!(self = get_self(args)))
708 return NULL;
709
710 if (!(args = PySequence_GetSlice(args, 1, PySequence_Size(args))))
711 return NULL;
712
713 if (PyObject_SetAttrString(self, "args", args))
714 goto finally;
715
716 lenargs = PySequence_Size(args);
717 if (lenargs >= 1) {
718 PyObject *item0 = PySequence_GetItem(args, 0);
719 int status;
720
721 if (!item0)
722 goto finally;
723 status = PyObject_SetAttrString(self, "msg", item0);
724 Py_DECREF(item0);
725 if (status)
726 goto finally;
727 }
728 if (lenargs == 2) {
729 PyObject *info = PySequence_GetItem(args, 1);
730 PyObject *filename = NULL, *lineno = NULL;
731 PyObject *offset = NULL, *text = NULL;
732 int status = 1;
733
734 if (!info)
735 goto finally;
736
737 filename = PySequence_GetItem(info, 0);
738 if (filename != NULL) {
739 lineno = PySequence_GetItem(info, 1);
740 if (lineno != NULL) {
741 offset = PySequence_GetItem(info, 2);
742 if (offset != NULL) {
743 text = PySequence_GetItem(info, 3);
744 if (text != NULL) {
745 status =
746 PyObject_SetAttrString(self, "filename", filename)
747 || PyObject_SetAttrString(self, "lineno", lineno)
748 || PyObject_SetAttrString(self, "offset", offset)
749 || PyObject_SetAttrString(self, "text", text);
750 Py_DECREF(text);
751 }
752 Py_DECREF(offset);
753 }
754 Py_DECREF(lineno);
755 }
756 Py_DECREF(filename);
757 }
758 Py_DECREF(info);
759
760 if (status)
761 goto finally;
762 }
763 Py_INCREF(Py_None);
764 rtnval = Py_None;
765
766 finally:
767 Py_DECREF(args);
768 return rtnval;
769}
770
771
772/* This is called "my_basename" instead of just "basename" to avoid name
773 conflicts with glibc; basename is already prototyped if _GNU_SOURCE is
774 defined, and Python does define that. */
775static char *
776my_basename(char *name)
777{
778 char *cp = name;
779 char *result = name;
780
781 if (name == NULL)
782 return "???";
783 while (*cp != '\0') {
784 if (*cp == SEP)
785 result = cp + 1;
786 ++cp;
787 }
788 return result;
789}
790
791
792static PyObject *
793SyntaxError__str__(PyObject *self, PyObject *args)
794{
795 PyObject *msg;
796 PyObject *str;
797 PyObject *filename, *lineno, *result;
798
799 if (!PyArg_ParseTuple(args, "O:__str__", &self))
800 return NULL;
801
802 if (!(msg = PyObject_GetAttrString(self, "msg")))
803 return NULL;
804
805 str = PyObject_Str(msg);
806 Py_DECREF(msg);
807 result = str;
808
809 /* XXX -- do all the additional formatting with filename and
810 lineno here */
811
812 if (str != NULL && PyString_Check(str)) {
813 int have_filename = 0;
814 int have_lineno = 0;
815 char *buffer = NULL;
816
817 if ((filename = PyObject_GetAttrString(self, "filename")) != NULL)
818 have_filename = PyString_Check(filename);
819 else
820 PyErr_Clear();
821
822 if ((lineno = PyObject_GetAttrString(self, "lineno")) != NULL)
823 have_lineno = PyInt_Check(lineno);
824 else
825 PyErr_Clear();
826
827 if (have_filename || have_lineno) {
828 int bufsize = PyString_GET_SIZE(str) + 64;
829 if (have_filename)
830 bufsize += PyString_GET_SIZE(filename);
831
832 buffer = PyMem_MALLOC(bufsize);
833 if (buffer != NULL) {
834 if (have_filename && have_lineno)
835 PyOS_snprintf(buffer, bufsize, "%s (%s, line %ld)",
836 PyString_AS_STRING(str),
837 my_basename(PyString_AS_STRING(filename)),
838 PyInt_AsLong(lineno));
839 else if (have_filename)
840 PyOS_snprintf(buffer, bufsize, "%s (%s)",
841 PyString_AS_STRING(str),
842 my_basename(PyString_AS_STRING(filename)));
843 else if (have_lineno)
844 PyOS_snprintf(buffer, bufsize, "%s (line %ld)",
845 PyString_AS_STRING(str),
846 PyInt_AsLong(lineno));
847
848 result = PyString_FromString(buffer);
849 PyMem_FREE(buffer);
850
851 if (result == NULL)
852 result = str;
853 else
854 Py_DECREF(str);
855 }
856 }
857 Py_XDECREF(filename);
858 Py_XDECREF(lineno);
859 }
860 return result;
861}
862
863
864static PyMethodDef SyntaxError_methods[] = {
865 {"__init__", SyntaxError__init__, METH_VARARGS},
866 {"__str__", SyntaxError__str__, METH_VARARGS},
867 {NULL, NULL}
868};
869
870
871static PyObject *
872KeyError__str__(PyObject *self, PyObject *args)
873{
874 PyObject *argsattr;
875 PyObject *result;
876
877 if (!PyArg_ParseTuple(args, "O:__str__", &self))
878 return NULL;
879
880 if (!(argsattr = PyObject_GetAttrString(self, "args")))
881 return NULL;
882
883 /* If args is a tuple of exactly one item, apply repr to args[0].
884 This is done so that e.g. the exception raised by {}[''] prints
885 KeyError: ''
886 rather than the confusing
887 KeyError
888 alone. The downside is that if KeyError is raised with an explanatory
889 string, that string will be displayed in quotes. Too bad.
890 If args is anything else, use the default Exception__str__().
891 */
892 if (PyTuple_Check(argsattr) && PyTuple_GET_SIZE(argsattr) == 1) {
893 PyObject *key = PyTuple_GET_ITEM(argsattr, 0);
894 result = PyObject_Repr(key);
895 }
896 else
897 result = Exception__str__(self, args);
898
899 Py_DECREF(argsattr);
900 return result;
901}
902
903static PyMethodDef KeyError_methods[] = {
904 {"__str__", KeyError__str__, METH_VARARGS},
905 {NULL, NULL}
906};
907
908
909#ifdef Py_USING_UNICODE
910static
911int get_int(PyObject *exc, const char *name, int *value)
912{
913 PyObject *attr = PyObject_GetAttrString(exc, (char *)name);
914
915 if (!attr)
916 return -1;
917 if (!PyInt_Check(attr)) {
918 PyErr_Format(PyExc_TypeError, "%.200s attribute must be int", name);
919 Py_DECREF(attr);
920 return -1;
921 }
922 *value = PyInt_AS_LONG(attr);
923 Py_DECREF(attr);
924 return 0;
925}
926
927
928static
929int set_int(PyObject *exc, const char *name, int value)
930{
931 PyObject *obj = PyInt_FromLong(value);
932 int result;
933
934 if (!obj)
935 return -1;
936 result = PyObject_SetAttrString(exc, (char *)name, obj);
937 Py_DECREF(obj);
938 return result;
939}
940
941
942static
943PyObject *get_string(PyObject *exc, const char *name)
944{
945 PyObject *attr = PyObject_GetAttrString(exc, (char *)name);
946
947 if (!attr)
948 return NULL;
949 if (!PyString_Check(attr)) {
950 PyErr_Format(PyExc_TypeError, "%.200s attribute must be str", name);
951 Py_DECREF(attr);
952 return NULL;
953 }
954 return attr;
955}
956
957
958static
959int set_string(PyObject *exc, const char *name, const char *value)
960{
961 PyObject *obj = PyString_FromString(value);
962 int result;
963
964 if (!obj)
965 return -1;
966 result = PyObject_SetAttrString(exc, (char *)name, obj);
967 Py_DECREF(obj);
968 return result;
969}
970
971
972static
973PyObject *get_unicode(PyObject *exc, const char *name)
974{
975 PyObject *attr = PyObject_GetAttrString(exc, (char *)name);
976
977 if (!attr)
978 return NULL;
979 if (!PyUnicode_Check(attr)) {
980 PyErr_Format(PyExc_TypeError, "%.200s attribute must be unicode", name);
981 Py_DECREF(attr);
982 return NULL;
983 }
984 return attr;
985}
986
987PyObject * PyUnicodeEncodeError_GetEncoding(PyObject *exc)
988{
989 return get_string(exc, "encoding");
990}
991
992PyObject * PyUnicodeDecodeError_GetEncoding(PyObject *exc)
993{
994 return get_string(exc, "encoding");
995}
996
997PyObject *PyUnicodeEncodeError_GetObject(PyObject *exc)
998{
999 return get_unicode(exc, "object");
1000}
1001
1002PyObject *PyUnicodeDecodeError_GetObject(PyObject *exc)
1003{
1004 return get_string(exc, "object");
1005}
1006
1007PyObject *PyUnicodeTranslateError_GetObject(PyObject *exc)
1008{
1009 return get_unicode(exc, "object");
1010}
1011
1012int PyUnicodeEncodeError_GetStart(PyObject *exc, int *start)
1013{
1014 if (!get_int(exc, "start", start)) {
1015 PyObject *object = PyUnicodeEncodeError_GetObject(exc);
1016 int size;
1017 if (!object)
1018 return -1;
1019 size = PyUnicode_GET_SIZE(object);
1020 if (*start<0)
1021 *start = 0;
1022 if (*start>=size)
1023 *start = size-1;
1024 Py_DECREF(object);
1025 return 0;
1026 }
1027 return -1;
1028}
1029
1030
1031int PyUnicodeDecodeError_GetStart(PyObject *exc, int *start)
1032{
1033 if (!get_int(exc, "start", start)) {
1034 PyObject *object = PyUnicodeDecodeError_GetObject(exc);
1035 int size;
1036 if (!object)
1037 return -1;
1038 size = PyString_GET_SIZE(object);
1039 if (*start<0)
1040 *start = 0;
1041 if (*start>=size)
1042 *start = size-1;
1043 Py_DECREF(object);
1044 return 0;
1045 }
1046 return -1;
1047}
1048
1049
1050int PyUnicodeTranslateError_GetStart(PyObject *exc, int *start)
1051{
1052 return PyUnicodeEncodeError_GetStart(exc, start);
1053}
1054
1055
1056int PyUnicodeEncodeError_SetStart(PyObject *exc, int start)
1057{
1058 return set_int(exc, "start", start);
1059}
1060
1061
1062int PyUnicodeDecodeError_SetStart(PyObject *exc, int start)
1063{
1064 return set_int(exc, "start", start);
1065}
1066
1067
1068int PyUnicodeTranslateError_SetStart(PyObject *exc, int start)
1069{
1070 return set_int(exc, "start", start);
1071}
1072
1073
1074int PyUnicodeEncodeError_GetEnd(PyObject *exc, int *end)
1075{
1076 if (!get_int(exc, "end", end)) {
1077 PyObject *object = PyUnicodeEncodeError_GetObject(exc);
1078 int size;
1079 if (!object)
1080 return -1;
1081 size = PyUnicode_GET_SIZE(object);
1082 if (*end<1)
1083 *end = 1;
1084 if (*end>size)
1085 *end = size;
1086 Py_DECREF(object);
1087 return 0;
1088 }
1089 return -1;
1090}
1091
1092
1093int PyUnicodeDecodeError_GetEnd(PyObject *exc, int *end)
1094{
1095 if (!get_int(exc, "end", end)) {
1096 PyObject *object = PyUnicodeDecodeError_GetObject(exc);
1097 int size;
1098 if (!object)
1099 return -1;
1100 size = PyString_GET_SIZE(object);
1101 if (*end<1)
1102 *end = 1;
1103 if (*end>size)
1104 *end = size;
1105 Py_DECREF(object);
1106 return 0;
1107 }
1108 return -1;
1109}
1110
1111
1112int PyUnicodeTranslateError_GetEnd(PyObject *exc, int *start)
1113{
1114 return PyUnicodeEncodeError_GetEnd(exc, start);
1115}
1116
1117
1118int PyUnicodeEncodeError_SetEnd(PyObject *exc, int end)
1119{
1120 return set_int(exc, "end", end);
1121}
1122
1123
1124int PyUnicodeDecodeError_SetEnd(PyObject *exc, int end)
1125{
1126 return set_int(exc, "end", end);
1127}
1128
1129
1130int PyUnicodeTranslateError_SetEnd(PyObject *exc, int end)
1131{
1132 return set_int(exc, "end", end);
1133}
1134
1135
1136PyObject *PyUnicodeEncodeError_GetReason(PyObject *exc)
1137{
1138 return get_string(exc, "reason");
1139}
1140
1141
1142PyObject *PyUnicodeDecodeError_GetReason(PyObject *exc)
1143{
1144 return get_string(exc, "reason");
1145}
1146
1147
1148PyObject *PyUnicodeTranslateError_GetReason(PyObject *exc)
1149{
1150 return get_string(exc, "reason");
1151}
1152
1153
1154int PyUnicodeEncodeError_SetReason(PyObject *exc, const char *reason)
1155{
1156 return set_string(exc, "reason", reason);
1157}
1158
1159
1160int PyUnicodeDecodeError_SetReason(PyObject *exc, const char *reason)
1161{
1162 return set_string(exc, "reason", reason);
1163}
1164
1165
1166int PyUnicodeTranslateError_SetReason(PyObject *exc, const char *reason)
1167{
1168 return set_string(exc, "reason", reason);
1169}
1170
1171
1172static PyObject *
1173UnicodeError__init__(PyObject *self, PyObject *args, PyTypeObject *objecttype)
1174{
1175 PyObject *rtnval = NULL;
1176 PyObject *encoding;
1177 PyObject *object;
1178 PyObject *start;
1179 PyObject *end;
1180 PyObject *reason;
1181
1182 if (!(self = get_self(args)))
1183 return NULL;
1184
1185 if (!(args = PySequence_GetSlice(args, 1, PySequence_Size(args))))
1186 return NULL;
1187
1188 if (!PyArg_ParseTuple(args, "O!O!O!O!O!",
1189 &PyString_Type, &encoding,
1190 objecttype, &object,
1191 &PyInt_Type, &start,
1192 &PyInt_Type, &end,
1193 &PyString_Type, &reason))
1194 goto finally;
1195
1196 if (PyObject_SetAttrString(self, "args", args))
1197 goto finally;
1198
1199 if (PyObject_SetAttrString(self, "encoding", encoding))
1200 goto finally;
1201 if (PyObject_SetAttrString(self, "object", object))
1202 goto finally;
1203 if (PyObject_SetAttrString(self, "start", start))
1204 goto finally;
1205 if (PyObject_SetAttrString(self, "end", end))
1206 goto finally;
1207 if (PyObject_SetAttrString(self, "reason", reason))
1208 goto finally;
1209
1210 Py_INCREF(Py_None);
1211 rtnval = Py_None;
1212
1213 finally:
1214 Py_DECREF(args);
1215 return rtnval;
1216}
1217
1218
1219static PyObject *
1220UnicodeEncodeError__init__(PyObject *self, PyObject *args)
1221{
1222 return UnicodeError__init__(self, args, &PyUnicode_Type);
1223}
1224
1225static PyObject *
1226UnicodeEncodeError__str__(PyObject *self, PyObject *arg)
1227{
1228 PyObject *encodingObj = NULL;
1229 PyObject *objectObj = NULL;
1230 int start;
1231 int end;
1232 PyObject *reasonObj = NULL;
1233 char buffer[1000];
1234 PyObject *result = NULL;
1235
1236 self = arg;
1237
1238 if (!(encodingObj = PyUnicodeEncodeError_GetEncoding(self)))
1239 goto error;
1240
1241 if (!(objectObj = PyUnicodeEncodeError_GetObject(self)))
1242 goto error;
1243
1244 if (PyUnicodeEncodeError_GetStart(self, &start))
1245 goto error;
1246
1247 if (PyUnicodeEncodeError_GetEnd(self, &end))
1248 goto error;
1249
1250 if (!(reasonObj = PyUnicodeEncodeError_GetReason(self)))
1251 goto error;
1252
1253 if (end==start+1) {
1254 int badchar = (int)PyUnicode_AS_UNICODE(objectObj)[start];
1255 char *format;
1256 if (badchar <= 0xff)
1257 format = "'%.400s' codec can't encode character u'\\x%02x' in position %d: %.400s";
1258 else if (badchar <= 0xffff)
1259 format = "'%.400s' codec can't encode character u'\\u%04x' in position %d: %.400s";
1260 else
1261 format = "'%.400s' codec can't encode character u'\\U%08x' in position %d: %.400s";
1262 PyOS_snprintf(buffer, sizeof(buffer),
1263 format,
1264 PyString_AS_STRING(encodingObj),
1265 badchar,
1266 start,
1267 PyString_AS_STRING(reasonObj)
1268 );
1269 }
1270 else {
1271 PyOS_snprintf(buffer, sizeof(buffer),
1272 "'%.400s' codec can't encode characters in position %d-%d: %.400s",
1273 PyString_AS_STRING(encodingObj),
1274 start,
1275 end-1,
1276 PyString_AS_STRING(reasonObj)
1277 );
1278 }
1279 result = PyString_FromString(buffer);
1280
1281error:
1282 Py_XDECREF(reasonObj);
1283 Py_XDECREF(objectObj);
1284 Py_XDECREF(encodingObj);
1285 return result;
1286}
1287
1288static PyMethodDef UnicodeEncodeError_methods[] = {
1289 {"__init__", UnicodeEncodeError__init__, METH_VARARGS},
1290 {"__str__", UnicodeEncodeError__str__, METH_O},
1291 {NULL, NULL}
1292};
1293
1294
1295PyObject * PyUnicodeEncodeError_Create(
1296 const char *encoding, const Py_UNICODE *object, int length,
1297 int start, int end, const char *reason)
1298{
1299 return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#iis",
1300 encoding, object, length, start, end, reason);
1301}
1302
1303
1304static PyObject *
1305UnicodeDecodeError__init__(PyObject *self, PyObject *args)
1306{
1307 return UnicodeError__init__(self, args, &PyString_Type);
1308}
1309
1310static PyObject *
1311UnicodeDecodeError__str__(PyObject *self, PyObject *arg)
1312{
1313 PyObject *encodingObj = NULL;
1314 PyObject *objectObj = NULL;
1315 int start;
1316 int end;
1317 PyObject *reasonObj = NULL;
1318 char buffer[1000];
1319 PyObject *result = NULL;
1320
1321 self = arg;
1322
1323 if (!(encodingObj = PyUnicodeDecodeError_GetEncoding(self)))
1324 goto error;
1325
1326 if (!(objectObj = PyUnicodeDecodeError_GetObject(self)))
1327 goto error;
1328
1329 if (PyUnicodeDecodeError_GetStart(self, &start))
1330 goto error;
1331
1332 if (PyUnicodeDecodeError_GetEnd(self, &end))
1333 goto error;
1334
1335 if (!(reasonObj = PyUnicodeDecodeError_GetReason(self)))
1336 goto error;
1337
1338 if (end==start+1) {
1339 PyOS_snprintf(buffer, sizeof(buffer),
1340 "'%.400s' codec can't decode byte 0x%02x in position %d: %.400s",
1341 PyString_AS_STRING(encodingObj),
1342 ((int)PyString_AS_STRING(objectObj)[start])&0xff,
1343 start,
1344 PyString_AS_STRING(reasonObj)
1345 );
1346 }
1347 else {
1348 PyOS_snprintf(buffer, sizeof(buffer),
1349 "'%.400s' codec can't decode bytes in position %d-%d: %.400s",
1350 PyString_AS_STRING(encodingObj),
1351 start,
1352 end-1,
1353 PyString_AS_STRING(reasonObj)
1354 );
1355 }
1356 result = PyString_FromString(buffer);
1357
1358error:
1359 Py_XDECREF(reasonObj);
1360 Py_XDECREF(objectObj);
1361 Py_XDECREF(encodingObj);
1362 return result;
1363}
1364
1365static PyMethodDef UnicodeDecodeError_methods[] = {
1366 {"__init__", UnicodeDecodeError__init__, METH_VARARGS},
1367 {"__str__", UnicodeDecodeError__str__, METH_O},
1368 {NULL, NULL}
1369};
1370
1371
1372PyObject * PyUnicodeDecodeError_Create(
1373 const char *encoding, const char *object, int length,
1374 int start, int end, const char *reason)
1375{
1376 return PyObject_CallFunction(PyExc_UnicodeDecodeError, "ss#iis",
1377 encoding, object, length, start, end, reason);
1378}
1379
1380
1381static PyObject *
1382UnicodeTranslateError__init__(PyObject *self, PyObject *args)
1383{
1384 PyObject *rtnval = NULL;
1385 PyObject *object;
1386 PyObject *start;
1387 PyObject *end;
1388 PyObject *reason;
1389
1390 if (!(self = get_self(args)))
1391 return NULL;
1392
1393 if (!(args = PySequence_GetSlice(args, 1, PySequence_Size(args))))
1394 return NULL;
1395
1396 if (!PyArg_ParseTuple(args, "O!O!O!O!",
1397 &PyUnicode_Type, &object,
1398 &PyInt_Type, &start,
1399 &PyInt_Type, &end,
1400 &PyString_Type, &reason))
1401 goto finally;
1402
1403 if (PyObject_SetAttrString(self, "args", args))
1404 goto finally;
1405
1406 if (PyObject_SetAttrString(self, "object", object))
1407 goto finally;
1408 if (PyObject_SetAttrString(self, "start", start))
1409 goto finally;
1410 if (PyObject_SetAttrString(self, "end", end))
1411 goto finally;
1412 if (PyObject_SetAttrString(self, "reason", reason))
1413 goto finally;
1414
1415 Py_INCREF(Py_None);
1416 rtnval = Py_None;
1417
1418 finally:
1419 Py_DECREF(args);
1420 return rtnval;
1421}
1422
1423
1424static PyObject *
1425UnicodeTranslateError__str__(PyObject *self, PyObject *arg)
1426{
1427 PyObject *objectObj = NULL;
1428 int start;
1429 int end;
1430 PyObject *reasonObj = NULL;
1431 char buffer[1000];
1432 PyObject *result = NULL;
1433
1434 self = arg;
1435
1436 if (!(objectObj = PyUnicodeTranslateError_GetObject(self)))
1437 goto error;
1438
1439 if (PyUnicodeTranslateError_GetStart(self, &start))
1440 goto error;
1441
1442 if (PyUnicodeTranslateError_GetEnd(self, &end))
1443 goto error;
1444
1445 if (!(reasonObj = PyUnicodeTranslateError_GetReason(self)))
1446 goto error;
1447
1448 if (end==start+1) {
1449 int badchar = (int)PyUnicode_AS_UNICODE(objectObj)[start];
1450 char *format;
1451 if (badchar <= 0xff)
1452 format = "can't translate character u'\\x%02x' in position %d: %.400s";
1453 else if (badchar <= 0xffff)
1454 format = "can't translate character u'\\u%04x' in position %d: %.400s";
1455 else
1456 format = "can't translate character u'\\U%08x' in position %d: %.400s";
1457 PyOS_snprintf(buffer, sizeof(buffer),
1458 format,
1459 badchar,
1460 start,
1461 PyString_AS_STRING(reasonObj)
1462 );
1463 }
1464 else {
1465 PyOS_snprintf(buffer, sizeof(buffer),
1466 "can't translate characters in position %d-%d: %.400s",
1467 start,
1468 end-1,
1469 PyString_AS_STRING(reasonObj)
1470 );
1471 }
1472 result = PyString_FromString(buffer);
1473
1474error:
1475 Py_XDECREF(reasonObj);
1476 Py_XDECREF(objectObj);
1477 return result;
1478}
1479
1480static PyMethodDef UnicodeTranslateError_methods[] = {
1481 {"__init__", UnicodeTranslateError__init__, METH_VARARGS},
1482 {"__str__", UnicodeTranslateError__str__, METH_O},
1483 {NULL, NULL}
1484};
1485
1486
1487PyObject * PyUnicodeTranslateError_Create(
1488 const Py_UNICODE *object, int length,
1489 int start, int end, const char *reason)
1490{
1491 return PyObject_CallFunction(PyExc_UnicodeTranslateError, "u#iis",
1492 object, length, start, end, reason);
1493}
1494#endif
1495
1496
1497
1498/* Exception doc strings */
1499
1500PyDoc_STRVAR(AssertionError__doc__, "Assertion failed.");
1501
1502PyDoc_STRVAR(LookupError__doc__, "Base class for lookup errors.");
1503
1504PyDoc_STRVAR(IndexError__doc__, "Sequence index out of range.");
1505
1506PyDoc_STRVAR(KeyError__doc__, "Mapping key not found.");
1507
1508PyDoc_STRVAR(ArithmeticError__doc__, "Base class for arithmetic errors.");
1509
1510PyDoc_STRVAR(OverflowError__doc__, "Result too large to be represented.");
1511
1512PyDoc_STRVAR(ZeroDivisionError__doc__,
1513"Second argument to a division or modulo operation was zero.");
1514
1515PyDoc_STRVAR(FloatingPointError__doc__, "Floating point operation failed.");
1516
1517PyDoc_STRVAR(ValueError__doc__,
1518"Inappropriate argument value (of correct type).");
1519
1520PyDoc_STRVAR(UnicodeError__doc__, "Unicode related error.");
1521
1522#ifdef Py_USING_UNICODE
1523PyDoc_STRVAR(UnicodeEncodeError__doc__, "Unicode encoding error.");
1524
1525PyDoc_STRVAR(UnicodeDecodeError__doc__, "Unicode decoding error.");
1526
1527PyDoc_STRVAR(UnicodeTranslateError__doc__, "Unicode translation error.");
1528#endif
1529
1530PyDoc_STRVAR(SystemError__doc__,
1531"Internal error in the Python interpreter.\n\
1532\n\
1533Please report this to the Python maintainer, along with the traceback,\n\
1534the Python version, and the hardware/OS platform and version.");
1535
1536PyDoc_STRVAR(ReferenceError__doc__,
1537"Weak ref proxy used after referent went away.");
1538
1539PyDoc_STRVAR(MemoryError__doc__, "Out of memory.");
1540
1541PyDoc_STRVAR(IndentationError__doc__, "Improper indentation.");
1542
1543PyDoc_STRVAR(TabError__doc__, "Improper mixture of spaces and tabs.");
1544
1545/* Warning category docstrings */
1546
1547PyDoc_STRVAR(Warning__doc__, "Base class for warning categories.");
1548
1549PyDoc_STRVAR(UserWarning__doc__,
1550"Base class for warnings generated by user code.");
1551
1552PyDoc_STRVAR(DeprecationWarning__doc__,
1553"Base class for warnings about deprecated features.");
1554
1555PyDoc_STRVAR(PendingDeprecationWarning__doc__,
1556"Base class for warnings about features which will be deprecated "
1557"in the future.");
1558
1559PyDoc_STRVAR(SyntaxWarning__doc__,
1560"Base class for warnings about dubious syntax.");
1561
1562PyDoc_STRVAR(OverflowWarning__doc__,
1563"Base class for warnings about numeric overflow. Won't exist in Python 2.5.");
1564
1565PyDoc_STRVAR(RuntimeWarning__doc__,
1566"Base class for warnings about dubious runtime behavior.");
1567
1568PyDoc_STRVAR(FutureWarning__doc__,
1569"Base class for warnings about constructs that will change semantically "
1570"in the future.");
1571
1572
1573
1574/* module global functions */
1575static PyMethodDef functions[] = {
1576 /* Sentinel */
1577 {NULL, NULL}
1578};
1579
1580
1581
1582/* Global C API defined exceptions */
1583
1584PyObject *PyExc_Exception;
1585PyObject *PyExc_StopIteration;
1586PyObject *PyExc_StandardError;
1587PyObject *PyExc_ArithmeticError;
1588PyObject *PyExc_LookupError;
1589
1590PyObject *PyExc_AssertionError;
1591PyObject *PyExc_AttributeError;
1592PyObject *PyExc_EOFError;
1593PyObject *PyExc_FloatingPointError;
1594PyObject *PyExc_EnvironmentError;
1595PyObject *PyExc_IOError;
1596PyObject *PyExc_OSError;
1597PyObject *PyExc_ImportError;
1598PyObject *PyExc_IndexError;
1599PyObject *PyExc_KeyError;
1600PyObject *PyExc_KeyboardInterrupt;
1601PyObject *PyExc_MemoryError;
1602PyObject *PyExc_NameError;
1603PyObject *PyExc_OverflowError;
1604PyObject *PyExc_RuntimeError;
1605PyObject *PyExc_NotImplementedError;
1606PyObject *PyExc_SyntaxError;
1607PyObject *PyExc_IndentationError;
1608PyObject *PyExc_TabError;
1609PyObject *PyExc_ReferenceError;
1610PyObject *PyExc_SystemError;
1611PyObject *PyExc_SystemExit;
1612PyObject *PyExc_UnboundLocalError;
1613PyObject *PyExc_UnicodeError;
1614PyObject *PyExc_UnicodeEncodeError;
1615PyObject *PyExc_UnicodeDecodeError;
1616PyObject *PyExc_UnicodeTranslateError;
1617PyObject *PyExc_TypeError;
1618PyObject *PyExc_ValueError;
1619PyObject *PyExc_ZeroDivisionError;
1620#ifdef MS_WINDOWS
1621PyObject *PyExc_WindowsError;
1622#endif
1623#ifdef __VMS
1624PyObject *PyExc_VMSError;
1625#endif
1626
1627/* Pre-computed MemoryError instance. Best to create this as early as
1628 * possibly and not wait until a MemoryError is actually raised!
1629 */
1630PyObject *PyExc_MemoryErrorInst;
1631
1632/* Predefined warning categories */
1633PyObject *PyExc_Warning;
1634PyObject *PyExc_UserWarning;
1635PyObject *PyExc_DeprecationWarning;
1636PyObject *PyExc_PendingDeprecationWarning;
1637PyObject *PyExc_SyntaxWarning;
1638/* PyExc_OverflowWarning should be removed for Python 2.5 */
1639PyObject *PyExc_OverflowWarning;
1640PyObject *PyExc_RuntimeWarning;
1641PyObject *PyExc_FutureWarning;
1642
1643
1644
1645/* mapping between exception names and their PyObject ** */
1646static struct {
1647 char *name;
1648 PyObject **exc;
1649 PyObject **base; /* NULL == PyExc_StandardError */
1650 char *docstr;
1651 PyMethodDef *methods;
1652 int (*classinit)(PyObject *);
1653} exctable[] = {
1654 /*
1655 * The first three classes MUST appear in exactly this order
1656 */
1657 {"Exception", &PyExc_Exception},
1658 {"StopIteration", &PyExc_StopIteration, &PyExc_Exception,
1659 StopIteration__doc__},
1660 {"StandardError", &PyExc_StandardError, &PyExc_Exception,
1661 StandardError__doc__},
1662 {"TypeError", &PyExc_TypeError, 0, TypeError__doc__},
1663 /*
1664 * The rest appear in depth-first order of the hierarchy
1665 */
1666 {"SystemExit", &PyExc_SystemExit, &PyExc_Exception, SystemExit__doc__,
1667 SystemExit_methods},
1668 {"KeyboardInterrupt", &PyExc_KeyboardInterrupt, 0, KeyboardInterrupt__doc__},
1669 {"ImportError", &PyExc_ImportError, 0, ImportError__doc__},
1670 {"EnvironmentError", &PyExc_EnvironmentError, 0, EnvironmentError__doc__,
1671 EnvironmentError_methods},
1672 {"IOError", &PyExc_IOError, &PyExc_EnvironmentError, IOError__doc__},
1673 {"OSError", &PyExc_OSError, &PyExc_EnvironmentError, OSError__doc__},
1674#ifdef MS_WINDOWS
1675 {"WindowsError", &PyExc_WindowsError, &PyExc_OSError,
1676 WindowsError__doc__},
1677#endif /* MS_WINDOWS */
1678#ifdef __VMS
1679 {"VMSError", &PyExc_VMSError, &PyExc_OSError,
1680 VMSError__doc__},
1681#endif
1682 {"EOFError", &PyExc_EOFError, 0, EOFError__doc__},
1683 {"RuntimeError", &PyExc_RuntimeError, 0, RuntimeError__doc__},
1684 {"NotImplementedError", &PyExc_NotImplementedError,
1685 &PyExc_RuntimeError, NotImplementedError__doc__},
1686 {"NameError", &PyExc_NameError, 0, NameError__doc__},
1687 {"UnboundLocalError", &PyExc_UnboundLocalError, &PyExc_NameError,
1688 UnboundLocalError__doc__},
1689 {"AttributeError", &PyExc_AttributeError, 0, AttributeError__doc__},
1690 {"SyntaxError", &PyExc_SyntaxError, 0, SyntaxError__doc__,
1691 SyntaxError_methods, SyntaxError__classinit__},
1692 {"IndentationError", &PyExc_IndentationError, &PyExc_SyntaxError,
1693 IndentationError__doc__},
1694 {"TabError", &PyExc_TabError, &PyExc_IndentationError,
1695 TabError__doc__},
1696 {"AssertionError", &PyExc_AssertionError, 0, AssertionError__doc__},
1697 {"LookupError", &PyExc_LookupError, 0, LookupError__doc__},
1698 {"IndexError", &PyExc_IndexError, &PyExc_LookupError,
1699 IndexError__doc__},
1700 {"KeyError", &PyExc_KeyError, &PyExc_LookupError,
1701 KeyError__doc__, KeyError_methods},
1702 {"ArithmeticError", &PyExc_ArithmeticError, 0, ArithmeticError__doc__},
1703 {"OverflowError", &PyExc_OverflowError, &PyExc_ArithmeticError,
1704 OverflowError__doc__},
1705 {"ZeroDivisionError", &PyExc_ZeroDivisionError, &PyExc_ArithmeticError,
1706 ZeroDivisionError__doc__},
1707 {"FloatingPointError", &PyExc_FloatingPointError, &PyExc_ArithmeticError,
1708 FloatingPointError__doc__},
1709 {"ValueError", &PyExc_ValueError, 0, ValueError__doc__},
1710 {"UnicodeError", &PyExc_UnicodeError, &PyExc_ValueError, UnicodeError__doc__},
1711#ifdef Py_USING_UNICODE
1712 {"UnicodeEncodeError", &PyExc_UnicodeEncodeError, &PyExc_UnicodeError,
1713 UnicodeEncodeError__doc__, UnicodeEncodeError_methods},
1714 {"UnicodeDecodeError", &PyExc_UnicodeDecodeError, &PyExc_UnicodeError,
1715 UnicodeDecodeError__doc__, UnicodeDecodeError_methods},
1716 {"UnicodeTranslateError", &PyExc_UnicodeTranslateError, &PyExc_UnicodeError,
1717 UnicodeTranslateError__doc__, UnicodeTranslateError_methods},
1718#endif
1719 {"ReferenceError", &PyExc_ReferenceError, 0, ReferenceError__doc__},
1720 {"SystemError", &PyExc_SystemError, 0, SystemError__doc__},
1721 {"MemoryError", &PyExc_MemoryError, 0, MemoryError__doc__},
1722 /* Warning categories */
1723 {"Warning", &PyExc_Warning, &PyExc_Exception, Warning__doc__},
1724 {"UserWarning", &PyExc_UserWarning, &PyExc_Warning, UserWarning__doc__},
1725 {"DeprecationWarning", &PyExc_DeprecationWarning, &PyExc_Warning,
1726 DeprecationWarning__doc__},
1727 {"PendingDeprecationWarning", &PyExc_PendingDeprecationWarning, &PyExc_Warning,
1728 PendingDeprecationWarning__doc__},
1729 {"SyntaxWarning", &PyExc_SyntaxWarning, &PyExc_Warning, SyntaxWarning__doc__},
1730 /* OverflowWarning should be removed for Python 2.5 */
1731 {"OverflowWarning", &PyExc_OverflowWarning, &PyExc_Warning,
1732 OverflowWarning__doc__},
1733 {"RuntimeWarning", &PyExc_RuntimeWarning, &PyExc_Warning,
1734 RuntimeWarning__doc__},
1735 {"FutureWarning", &PyExc_FutureWarning, &PyExc_Warning,
1736 FutureWarning__doc__},
1737 /* Sentinel */
1738 {NULL}
1739};
1740
1741
1742
1743void
1744_PyExc_Init(void)
1745{
1746 char *modulename = "exceptions";
1747 int modnamesz = strlen(modulename);
1748 int i;
1749 PyObject *me, *mydict, *bltinmod, *bdict, *doc, *args;
1750
1751 me = Py_InitModule(modulename, functions);
1752 if (me == NULL)
1753 goto err;
1754 mydict = PyModule_GetDict(me);
1755 if (mydict == NULL)
1756 goto err;
1757 bltinmod = PyImport_ImportModule("__builtin__");
1758 if (bltinmod == NULL)
1759 goto err;
1760 bdict = PyModule_GetDict(bltinmod);
1761 if (bdict == NULL)
1762 goto err;
1763 doc = PyString_FromString(module__doc__);
1764 if (doc == NULL)
1765 goto err;
1766
1767 i = PyDict_SetItemString(mydict, "__doc__", doc);
1768 Py_DECREF(doc);
1769 if (i < 0) {
1770 err:
1771 Py_FatalError("exceptions bootstrapping error.");
1772 return;
1773 }
1774
1775 /* This is the base class of all exceptions, so make it first. */
1776 if (make_Exception(modulename) ||
1777 PyDict_SetItemString(mydict, "Exception", PyExc_Exception) ||
1778 PyDict_SetItemString(bdict, "Exception", PyExc_Exception))
1779 {
1780 Py_FatalError("Base class `Exception' could not be created.");
1781 }
1782
1783 /* Now we can programmatically create all the remaining exceptions.
1784 * Remember to start the loop at 1 to skip Exceptions.
1785 */
1786 for (i=1; exctable[i].name; i++) {
1787 int status;
1788 char *cname = PyMem_NEW(char, modnamesz+strlen(exctable[i].name)+2);
1789 PyObject *base;
1790
1791 (void)strcpy(cname, modulename);
1792 (void)strcat(cname, ".");
1793 (void)strcat(cname, exctable[i].name);
1794
1795 if (exctable[i].base == 0)
1796 base = PyExc_StandardError;
1797 else
1798 base = *exctable[i].base;
1799
1800 status = make_class(exctable[i].exc, base, cname,
1801 exctable[i].methods,
1802 exctable[i].docstr);
1803
1804 PyMem_DEL(cname);
1805
1806 if (status)
1807 Py_FatalError("Standard exception classes could not be created.");
1808
1809 if (exctable[i].classinit) {
1810 status = (*exctable[i].classinit)(*exctable[i].exc);
1811 if (status)
1812 Py_FatalError("An exception class could not be initialized.");
1813 }
1814
1815 /* Now insert the class into both this module and the __builtin__
1816 * module.
1817 */
1818 if (PyDict_SetItemString(mydict, exctable[i].name, *exctable[i].exc) ||
1819 PyDict_SetItemString(bdict, exctable[i].name, *exctable[i].exc))
1820 {
1821 Py_FatalError("Module dictionary insertion problem.");
1822 }
1823 }
1824
1825 /* Now we need to pre-allocate a MemoryError instance */
1826 args = PyTuple_New(0);
1827 if (!args ||
1828 !(PyExc_MemoryErrorInst = PyEval_CallObject(PyExc_MemoryError, args)))
1829 {
1830 Py_FatalError("Cannot pre-allocate MemoryError instance\n");
1831 }
1832 Py_DECREF(args);
1833
1834 /* We're done with __builtin__ */
1835 Py_DECREF(bltinmod);
1836}
1837
1838
1839void
1840_PyExc_Fini(void)
1841{
1842 int i;
1843
1844 Py_XDECREF(PyExc_MemoryErrorInst);
1845 PyExc_MemoryErrorInst = NULL;
1846
1847 for (i=0; exctable[i].name; i++) {
1848 /* clear the class's dictionary, freeing up circular references
1849 * between the class and its methods.
1850 */
1851 PyObject* cdict = PyObject_GetAttrString(*exctable[i].exc, "__dict__");
1852 PyDict_Clear(cdict);
1853 Py_DECREF(cdict);
1854
1855 /* Now decref the exception class */
1856 Py_XDECREF(*exctable[i].exc);
1857 *exctable[i].exc = NULL;
1858 }
1859}