Mercurial > cpython-lru_cache-weakref
annotate Python/errors.c @ 48167:a8a8232cb541 legacy-trunk
Adds a sanity check to avoid a *very rare* infinite loop due to a corrupt tls
key list data structure in the thread startup path.
This change is a companion to r60148 which already successfully dealt with a
similar issue on thread shutdown.
In particular this loop has been observed happening from this call path:
#0 in find_key ()
#1 in PyThread_set_key_value ()
#2 in _PyGILState_NoteThreadState ()
#3 in PyThreadState_New ()
#4 in t_bootstrap ()
#5 in pthread_start_thread ()
I don't know how this happens but it does, *very* rarely. On more than
one hardware platform. I have not been able to reproduce it manually.
(A flaky mutex implementation on the system in question is one hypothesis).
As with r60148, the spinning we managed to observe in the wild was due to a
single list element pointing back upon itself.
| author | Gregory P. Smith <greg@mad-scientist.com> |
|---|---|
| date | Mon, 04 Aug 2008 07:33:37 +0000 |
| parents | 0fbddc04aee1 |
| children | d01c1d768841 |
| rev | line source |
|---|---|
| 145 | 1 |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
2 /* Error handling */ |
| 6 | 3 |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
4 #include "Python.h" |
| 86 | 5 |
| 2502 | 6 #ifndef __STDC__ |
|
5318
2c4b802a3b5d
Keep Microsoft VC happy.
Guido van Rossum <guido@python.org>
parents:
5312
diff
changeset
|
7 #ifndef MS_WINDOWS |
|
13447
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13256
diff
changeset
|
8 extern char *strerror(int); |
| 2502 | 9 #endif |
|
5318
2c4b802a3b5d
Keep Microsoft VC happy.
Guido van Rossum <guido@python.org>
parents:
5312
diff
changeset
|
10 #endif |
|
59
433f52d1d958
Added prototype for strerror.
Guido van Rossum <guido@python.org>
parents:
37
diff
changeset
|
11 |
|
24071
8142f8d668a0
Patch #569753: Remove support for WIN16.
Martin v. Löwis <martin@v.loewis.de>
parents:
23029
diff
changeset
|
12 #ifdef MS_WINDOWS |
|
10638
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
13 #include "windows.h" |
|
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
14 #include "winbase.h" |
|
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
15 #endif |
|
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
16 |
|
14335
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
17 #include <ctype.h> |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
18 |
|
37655
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
19 #ifdef __cplusplus |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
20 extern "C" { |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
21 #endif |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
22 |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
23 |
| 6 | 24 void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
25 PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback) |
|
2052
d7e91437f0a2
Lots of changes, most minor (fatal() instead of abort(), use of
Guido van Rossum <guido@python.org>
parents:
2019
diff
changeset
|
26 { |
|
9671
1d40bc25703a
Use PyThreadState_GET() macro.
Guido van Rossum <guido@python.org>
parents:
9365
diff
changeset
|
27 PyThreadState *tstate = PyThreadState_GET(); |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
28 PyObject *oldtype, *oldvalue, *oldtraceback; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
29 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
30 if (traceback != NULL && !PyTraceBack_Check(traceback)) { |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
31 /* XXX Should never happen -- fatal error instead? */ |
|
36737
fa92fe15251a
Updates to the with-statement:
Guido van Rossum <guido@python.org>
parents:
36701
diff
changeset
|
32 /* Well, it could be None. */ |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
33 Py_DECREF(traceback); |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
34 traceback = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
35 } |
|
2052
d7e91437f0a2
Lots of changes, most minor (fatal() instead of abort(), use of
Guido van Rossum <guido@python.org>
parents:
2019
diff
changeset
|
36 |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
37 /* Save these in locals to safeguard against recursive |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
38 invocation through Py_XDECREF */ |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
39 oldtype = tstate->curexc_type; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
40 oldvalue = tstate->curexc_value; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
41 oldtraceback = tstate->curexc_traceback; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
42 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
43 tstate->curexc_type = type; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
44 tstate->curexc_value = value; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
45 tstate->curexc_traceback = traceback; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
46 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
47 Py_XDECREF(oldtype); |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
48 Py_XDECREF(oldvalue); |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
49 Py_XDECREF(oldtraceback); |
|
2052
d7e91437f0a2
Lots of changes, most minor (fatal() instead of abort(), use of
Guido van Rossum <guido@python.org>
parents:
2019
diff
changeset
|
50 } |
|
d7e91437f0a2
Lots of changes, most minor (fatal() instead of abort(), use of
Guido van Rossum <guido@python.org>
parents:
2019
diff
changeset
|
51 |
|
d7e91437f0a2
Lots of changes, most minor (fatal() instead of abort(), use of
Guido van Rossum <guido@python.org>
parents:
2019
diff
changeset
|
52 void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
53 PyErr_SetObject(PyObject *exception, PyObject *value) |
| 6 | 54 { |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
55 Py_XINCREF(exception); |
|
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
56 Py_XINCREF(value); |
|
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
57 PyErr_Restore(exception, value, (PyObject *)NULL); |
| 6 | 58 } |
| 59 | |
| 60 void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
61 PyErr_SetNone(PyObject *exception) |
| 6 | 62 { |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
63 PyErr_SetObject(exception, (PyObject *)NULL); |
| 6 | 64 } |
| 65 | |
| 66 void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
67 PyErr_SetString(PyObject *exception, const char *string) |
| 6 | 68 { |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
69 PyObject *value = PyString_FromString(string); |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
70 PyErr_SetObject(exception, value); |
|
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
71 Py_XDECREF(value); |
| 6 | 72 } |
| 73 | |
|
1832
79e420805c67
err_clear: clear interpreter stack trace
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
74 |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
75 PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
76 PyErr_Occurred(void) |
| 6 | 77 { |
|
18007
6a2e2548e6cf
PyErr_Occurred(): Use PyThreadState_GET(), which saves a tiny function call
Tim Peters <tim.peters@gmail.com>
parents:
16997
diff
changeset
|
78 PyThreadState *tstate = PyThreadState_GET(); |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
79 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
80 return tstate->curexc_type; |
| 6 | 81 } |
| 82 | |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
83 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
84 int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
85 PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc) |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
86 { |
|
12559
3b8d9e63e4e1
PyErr_GivenExceptionMatches(): Check for err==NULL and exc==NULL and
Barry Warsaw <barry@python.org>
parents:
11899
diff
changeset
|
87 if (err == NULL || exc == NULL) { |
|
3b8d9e63e4e1
PyErr_GivenExceptionMatches(): Check for err==NULL and exc==NULL and
Barry Warsaw <barry@python.org>
parents:
11899
diff
changeset
|
88 /* maybe caused by "import exceptions" that failed early on */ |
|
3b8d9e63e4e1
PyErr_GivenExceptionMatches(): Check for err==NULL and exc==NULL and
Barry Warsaw <barry@python.org>
parents:
11899
diff
changeset
|
89 return 0; |
|
3b8d9e63e4e1
PyErr_GivenExceptionMatches(): Check for err==NULL and exc==NULL and
Barry Warsaw <barry@python.org>
parents:
11899
diff
changeset
|
90 } |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
91 if (PyTuple_Check(exc)) { |
|
36521
30aef3ce2b26
Use Py_ssize_t to count the
Martin v. Löwis <martin@v.loewis.de>
parents:
34440
diff
changeset
|
92 Py_ssize_t i, n; |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
93 n = PyTuple_Size(exc); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
94 for (i = 0; i < n; i++) { |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
95 /* Test recursively */ |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
96 if (PyErr_GivenExceptionMatches( |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
97 err, PyTuple_GET_ITEM(exc, i))) |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
98 { |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
99 return 1; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
100 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
101 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
102 return 0; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
103 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
104 /* err might be an instance, so check its class. */ |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
105 if (PyExceptionInstance_Check(err)) |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
106 err = PyExceptionInstance_Class(err); |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
107 |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
108 if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) { |
|
48107
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
109 int res = 0; |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
110 PyObject *exception, *value, *tb; |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
111 PyErr_Fetch(&exception, &value, &tb); |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
112 res = PyObject_IsSubclass(err, exc); |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
113 /* This function must not fail, so print the error here */ |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
114 if (res == -1) { |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
115 PyErr_WriteUnraisable(err); |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
116 /* issubclass did not succeed */ |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
117 res = 0; |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
118 } |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
119 PyErr_Restore(exception, value, tb); |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
120 return res; |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
121 } |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
122 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
123 return err == exc; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
124 } |
|
10638
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
125 |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
126 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
127 int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
128 PyErr_ExceptionMatches(PyObject *exc) |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
129 { |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
130 return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
131 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
132 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
133 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
134 /* Used in many places to normalize a raised exception, including in |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
135 eval_code2(), do_raise(), and PyErr_Print() |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
136 */ |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
137 void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
138 PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb) |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
139 { |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
140 PyObject *type = *exc; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
141 PyObject *value = *val; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
142 PyObject *inclass = NULL; |
|
20116
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
143 PyObject *initial_tb = NULL; |
|
43276
3bc3f12cae28
Fix a crasher where Python code managed to infinitely recurse in C code without
Brett Cannon <bcannon@gmail.com>
parents:
40956
diff
changeset
|
144 PyThreadState *tstate = NULL; |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
145 |
|
13883
15ad4088a700
Avoid dumping core when PyErr_NormalizeException() is called without
Guido van Rossum <guido@python.org>
parents:
13658
diff
changeset
|
146 if (type == NULL) { |
|
28571
5fbdcaef9dda
PyErr_NormalizeException(): in the type==NULL test, we should simply
Guido van Rossum <guido@python.org>
parents:
27958
diff
changeset
|
147 /* There was no exception, so nothing to do. */ |
|
5fbdcaef9dda
PyErr_NormalizeException(): in the type==NULL test, we should simply
Guido van Rossum <guido@python.org>
parents:
27958
diff
changeset
|
148 return; |
|
13883
15ad4088a700
Avoid dumping core when PyErr_NormalizeException() is called without
Guido van Rossum <guido@python.org>
parents:
13658
diff
changeset
|
149 } |
|
15ad4088a700
Avoid dumping core when PyErr_NormalizeException() is called without
Guido van Rossum <guido@python.org>
parents:
13658
diff
changeset
|
150 |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
151 /* If PyErr_SetNone() was used, the value will have been actually |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
152 set to NULL. |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
153 */ |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
154 if (!value) { |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
155 value = Py_None; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
156 Py_INCREF(value); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
157 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
158 |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
159 if (PyExceptionInstance_Check(value)) |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
160 inclass = PyExceptionInstance_Class(value); |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
161 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
162 /* Normalize the exception so that if the type is a class, the |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
163 value will be an instance. |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
164 */ |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
165 if (PyExceptionClass_Check(type)) { |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
166 /* if the value was not an instance, or is not an instance |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
167 whose class is (or is derived from) type, then use the |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
168 value as an argument to instantiation of the type |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
169 class. |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
170 */ |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
171 if (!inclass || !PyObject_IsSubclass(inclass, type)) { |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
172 PyObject *args, *res; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
173 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
174 if (value == Py_None) |
|
30683
3b59fa5d25b1
Simplify and speedup uses of Py_BuildValue():
Raymond Hettinger <python@rcn.com>
parents:
29877
diff
changeset
|
175 args = PyTuple_New(0); |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
176 else if (PyTuple_Check(value)) { |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
177 Py_INCREF(value); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
178 args = value; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
179 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
180 else |
|
30683
3b59fa5d25b1
Simplify and speedup uses of Py_BuildValue():
Raymond Hettinger <python@rcn.com>
parents:
29877
diff
changeset
|
181 args = PyTuple_Pack(1, value); |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
182 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
183 if (args == NULL) |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
184 goto finally; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
185 res = PyEval_CallObject(type, args); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
186 Py_DECREF(args); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
187 if (res == NULL) |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
188 goto finally; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
189 Py_DECREF(value); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
190 value = res; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
191 } |
|
6358
9e82dd76288e
PyErr_NormalizeException(): If the exception's type is a class and the
Barry Warsaw <barry@python.org>
parents:
6319
diff
changeset
|
192 /* if the class of the instance doesn't exactly match the |
|
9e82dd76288e
PyErr_NormalizeException(): If the exception's type is a class and the
Barry Warsaw <barry@python.org>
parents:
6319
diff
changeset
|
193 class of the type, believe the instance |
|
9e82dd76288e
PyErr_NormalizeException(): If the exception's type is a class and the
Barry Warsaw <barry@python.org>
parents:
6319
diff
changeset
|
194 */ |
|
9e82dd76288e
PyErr_NormalizeException(): If the exception's type is a class and the
Barry Warsaw <barry@python.org>
parents:
6319
diff
changeset
|
195 else if (inclass != type) { |
|
9e82dd76288e
PyErr_NormalizeException(): If the exception's type is a class and the
Barry Warsaw <barry@python.org>
parents:
6319
diff
changeset
|
196 Py_DECREF(type); |
|
9e82dd76288e
PyErr_NormalizeException(): If the exception's type is a class and the
Barry Warsaw <barry@python.org>
parents:
6319
diff
changeset
|
197 type = inclass; |
|
9e82dd76288e
PyErr_NormalizeException(): If the exception's type is a class and the
Barry Warsaw <barry@python.org>
parents:
6319
diff
changeset
|
198 Py_INCREF(type); |
|
9e82dd76288e
PyErr_NormalizeException(): If the exception's type is a class and the
Barry Warsaw <barry@python.org>
parents:
6319
diff
changeset
|
199 } |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
200 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
201 *exc = type; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
202 *val = value; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
203 return; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
204 finally: |
|
6789
bb440a2975ab
Fix subtle bug in cleanup code in PyErr_NormalizeException(), detected
Guido van Rossum <guido@python.org>
parents:
6377
diff
changeset
|
205 Py_DECREF(type); |
|
bb440a2975ab
Fix subtle bug in cleanup code in PyErr_NormalizeException(), detected
Guido van Rossum <guido@python.org>
parents:
6377
diff
changeset
|
206 Py_DECREF(value); |
|
20116
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
207 /* If the new exception doesn't set a traceback and the old |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
208 exception had a traceback, use the old traceback for the |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
209 new exception. It's better than nothing. |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
210 */ |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
211 initial_tb = *tb; |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
212 PyErr_Fetch(exc, val, tb); |
|
20116
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
213 if (initial_tb != NULL) { |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
214 if (*tb == NULL) |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
215 *tb = initial_tb; |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
216 else |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
217 Py_DECREF(initial_tb); |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
218 } |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
219 /* normalize recursively */ |
|
43276
3bc3f12cae28
Fix a crasher where Python code managed to infinitely recurse in C code without
Brett Cannon <bcannon@gmail.com>
parents:
40956
diff
changeset
|
220 tstate = PyThreadState_GET(); |
|
3bc3f12cae28
Fix a crasher where Python code managed to infinitely recurse in C code without
Brett Cannon <bcannon@gmail.com>
parents:
40956
diff
changeset
|
221 if (++tstate->recursion_depth > Py_GetRecursionLimit()) { |
|
3bc3f12cae28
Fix a crasher where Python code managed to infinitely recurse in C code without
Brett Cannon <bcannon@gmail.com>
parents:
40956
diff
changeset
|
222 --tstate->recursion_depth; |
|
3bc3f12cae28
Fix a crasher where Python code managed to infinitely recurse in C code without
Brett Cannon <bcannon@gmail.com>
parents:
40956
diff
changeset
|
223 PyErr_SetObject(PyExc_RuntimeError, PyExc_RecursionErrorInst); |
|
3bc3f12cae28
Fix a crasher where Python code managed to infinitely recurse in C code without
Brett Cannon <bcannon@gmail.com>
parents:
40956
diff
changeset
|
224 return; |
|
3bc3f12cae28
Fix a crasher where Python code managed to infinitely recurse in C code without
Brett Cannon <bcannon@gmail.com>
parents:
40956
diff
changeset
|
225 } |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
226 PyErr_NormalizeException(exc, val, tb); |
|
43276
3bc3f12cae28
Fix a crasher where Python code managed to infinitely recurse in C code without
Brett Cannon <bcannon@gmail.com>
parents:
40956
diff
changeset
|
227 --tstate->recursion_depth; |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
228 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
229 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
230 |
| 6 | 231 void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
232 PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback) |
| 6 | 233 { |
|
31797
846b3ee7e106
Changed random calls to PyThreadState_Get() to use the macro
Nicholas Bastin <nick.bastin@gmail.com>
parents:
30979
diff
changeset
|
234 PyThreadState *tstate = PyThreadState_GET(); |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
235 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
236 *p_type = tstate->curexc_type; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
237 *p_value = tstate->curexc_value; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
238 *p_traceback = tstate->curexc_traceback; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
239 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
240 tstate->curexc_type = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
241 tstate->curexc_value = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
242 tstate->curexc_traceback = NULL; |
| 6 | 243 } |
| 244 | |
| 245 void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
246 PyErr_Clear(void) |
| 6 | 247 { |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
248 PyErr_Restore(NULL, NULL, NULL); |
| 6 | 249 } |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
250 |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
251 /* Convenience functions to set a type error exception and return 0 */ |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
252 |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
253 int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
254 PyErr_BadArgument(void) |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
255 { |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
256 PyErr_SetString(PyExc_TypeError, |
| 15318 | 257 "bad argument type for built-in operation"); |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
258 return 0; |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
259 } |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
260 |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
261 PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
262 PyErr_NoMemory(void) |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
263 { |
|
14066
25eea88047e9
Do not set a MemoryError exception over another MemoryError exception,
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents:
13883
diff
changeset
|
264 if (PyErr_ExceptionMatches(PyExc_MemoryError)) |
|
25eea88047e9
Do not set a MemoryError exception over another MemoryError exception,
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents:
13883
diff
changeset
|
265 /* already current */ |
|
25eea88047e9
Do not set a MemoryError exception over another MemoryError exception,
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents:
13883
diff
changeset
|
266 return NULL; |
|
25eea88047e9
Do not set a MemoryError exception over another MemoryError exception,
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents:
13883
diff
changeset
|
267 |
|
6190
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
268 /* raise the pre-allocated instance if it still exists */ |
|
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
269 if (PyExc_MemoryErrorInst) |
|
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
270 PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst); |
|
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
271 else |
|
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
272 /* this will probably fail since there's no memory and hee, |
|
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
273 hee, we have to instantiate this class |
|
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
274 */ |
|
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
275 PyErr_SetNone(PyExc_MemoryError); |
|
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
276 |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
277 return NULL; |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
278 } |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
279 |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
280 PyObject * |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
281 PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject) |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
282 { |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
283 PyObject *v; |
|
9365
c80321c328b5
When errno is zero, avoid calling strerror() and use "Error" for the
Guido van Rossum <guido@python.org>
parents:
8706
diff
changeset
|
284 char *s; |
|
1832
79e420805c67
err_clear: clear interpreter stack trace
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
285 int i = errno; |
|
22205
f4487350c537
Patch #494045: patches errno and stat to cope on plan9.
Martin v. Löwis <martin@v.loewis.de>
parents:
22121
diff
changeset
|
286 #ifdef PLAN9 |
|
f4487350c537
Patch #494045: patches errno and stat to cope on plan9.
Martin v. Löwis <martin@v.loewis.de>
parents:
22121
diff
changeset
|
287 char errbuf[ERRMAX]; |
|
f4487350c537
Patch #494045: patches errno and stat to cope on plan9.
Martin v. Löwis <martin@v.loewis.de>
parents:
22121
diff
changeset
|
288 #endif |
|
24071
8142f8d668a0
Patch #569753: Remove support for WIN16.
Martin v. Löwis <martin@v.loewis.de>
parents:
23029
diff
changeset
|
289 #ifdef MS_WINDOWS |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
290 char *s_buf = NULL; |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
291 char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */ |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
292 #endif |
|
2376
c31eaed7798b
rename macstrerror to PyMac_StrError; no EINTR test in CW
Guido van Rossum <guido@python.org>
parents:
2190
diff
changeset
|
293 #ifdef EINTR |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
294 if (i == EINTR && PyErr_CheckSignals()) |
|
390
172aa2c3e734
Check for EINTR and turn it into KeyboardInterrupt
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
295 return NULL; |
|
2376
c31eaed7798b
rename macstrerror to PyMac_StrError; no EINTR test in CW
Guido van Rossum <guido@python.org>
parents:
2190
diff
changeset
|
296 #endif |
|
22205
f4487350c537
Patch #494045: patches errno and stat to cope on plan9.
Martin v. Löwis <martin@v.loewis.de>
parents:
22121
diff
changeset
|
297 #ifdef PLAN9 |
|
f4487350c537
Patch #494045: patches errno and stat to cope on plan9.
Martin v. Löwis <martin@v.loewis.de>
parents:
22121
diff
changeset
|
298 rerrstr(errbuf, sizeof errbuf); |
|
f4487350c537
Patch #494045: patches errno and stat to cope on plan9.
Martin v. Löwis <martin@v.loewis.de>
parents:
22121
diff
changeset
|
299 s = errbuf; |
|
f4487350c537
Patch #494045: patches errno and stat to cope on plan9.
Martin v. Löwis <martin@v.loewis.de>
parents:
22121
diff
changeset
|
300 #else |
|
9365
c80321c328b5
When errno is zero, avoid calling strerror() and use "Error" for the
Guido van Rossum <guido@python.org>
parents:
8706
diff
changeset
|
301 if (i == 0) |
|
c80321c328b5
When errno is zero, avoid calling strerror() and use "Error" for the
Guido van Rossum <guido@python.org>
parents:
8706
diff
changeset
|
302 s = "Error"; /* Sometimes errno didn't get set */ |
|
c80321c328b5
When errno is zero, avoid calling strerror() and use "Error" for the
Guido van Rossum <guido@python.org>
parents:
8706
diff
changeset
|
303 else |
|
24071
8142f8d668a0
Patch #569753: Remove support for WIN16.
Martin v. Löwis <martin@v.loewis.de>
parents:
23029
diff
changeset
|
304 #ifndef MS_WINDOWS |
|
9365
c80321c328b5
When errno is zero, avoid calling strerror() and use "Error" for the
Guido van Rossum <guido@python.org>
parents:
8706
diff
changeset
|
305 s = strerror(i); |
|
10638
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
306 #else |
|
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
307 { |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
308 /* Note that the Win32 errors do not lineup with the |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
309 errno error. So if the error is in the MSVC error |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
310 table, we use it, otherwise we assume it really _is_ |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
311 a Win32 error code |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
312 */ |
|
11825
4080c7a0f1ed
Mark pointed out a buglet in his patch: i < _sys_nerr isn't strong
Guido van Rossum <guido@python.org>
parents:
11801
diff
changeset
|
313 if (i > 0 && i < _sys_nerr) { |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
314 s = _sys_errlist[i]; |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
315 } |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
316 else { |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
317 int len = FormatMessage( |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
318 FORMAT_MESSAGE_ALLOCATE_BUFFER | |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
319 FORMAT_MESSAGE_FROM_SYSTEM | |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
320 FORMAT_MESSAGE_IGNORE_INSERTS, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
321 NULL, /* no message source */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
322 i, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
323 MAKELANGID(LANG_NEUTRAL, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
324 SUBLANG_DEFAULT), |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
325 /* Default language */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
326 (LPTSTR) &s_buf, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
327 0, /* size not used */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
328 NULL); /* no args */ |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
329 if (len==0) { |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
330 /* Only ever seen this in out-of-mem |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
331 situations */ |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
332 sprintf(s_small_buf, "Windows Error 0x%X", i); |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
333 s = s_small_buf; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
334 s_buf = NULL; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
335 } else { |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
336 s = s_buf; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
337 /* remove trailing cr/lf and dots */ |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
338 while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.')) |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
339 s[--len] = '\0'; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
340 } |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
341 } |
|
10638
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
342 } |
|
22205
f4487350c537
Patch #494045: patches errno and stat to cope on plan9.
Martin v. Löwis <martin@v.loewis.de>
parents:
22121
diff
changeset
|
343 #endif /* Unix/Windows */ |
|
f4487350c537
Patch #494045: patches errno and stat to cope on plan9.
Martin v. Löwis <martin@v.loewis.de>
parents:
22121
diff
changeset
|
344 #endif /* PLAN 9*/ |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
345 if (filenameObject != NULL) |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
346 v = Py_BuildValue("(isO)", i, s, filenameObject); |
|
8706
ca1c669bb041
PyErr_SetFromErrnoWithFilename(): New function which supports setting
Barry Warsaw <barry@python.org>
parents:
6789
diff
changeset
|
347 else |
|
9365
c80321c328b5
When errno is zero, avoid calling strerror() and use "Error" for the
Guido van Rossum <guido@python.org>
parents:
8706
diff
changeset
|
348 v = Py_BuildValue("(is)", i, s); |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
349 if (v != NULL) { |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
350 PyErr_SetObject(exc, v); |
|
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
351 Py_DECREF(v); |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
352 } |
|
24071
8142f8d668a0
Patch #569753: Remove support for WIN16.
Martin v. Löwis <martin@v.loewis.de>
parents:
23029
diff
changeset
|
353 #ifdef MS_WINDOWS |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
354 LocalFree(s_buf); |
|
10638
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
355 #endif |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
356 return NULL; |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
357 } |
|
10638
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
358 |
|
8706
ca1c669bb041
PyErr_SetFromErrnoWithFilename(): New function which supports setting
Barry Warsaw <barry@python.org>
parents:
6789
diff
changeset
|
359 |
|
ca1c669bb041
PyErr_SetFromErrnoWithFilename(): New function which supports setting
Barry Warsaw <barry@python.org>
parents:
6789
diff
changeset
|
360 PyObject * |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
361 PyErr_SetFromErrnoWithFilename(PyObject *exc, char *filename) |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
362 { |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
363 PyObject *name = filename ? PyString_FromString(filename) : NULL; |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
364 PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name); |
|
25543
dfeec3b34fae
Fix errors to pep277 checkin identified by Neal Norwitz.
Mark Hammond <mhammond@skippinet.com.au>
parents:
25535
diff
changeset
|
365 Py_XDECREF(name); |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
366 return result; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
367 } |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
368 |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
369 #ifdef Py_WIN_WIDE_FILENAMES |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
370 PyObject * |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
371 PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, Py_UNICODE *filename) |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
372 { |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
373 PyObject *name = filename ? |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
374 PyUnicode_FromUnicode(filename, wcslen(filename)) : |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
375 NULL; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
376 PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name); |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
377 Py_XDECREF(name); |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
378 return result; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
379 } |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
380 #endif /* Py_WIN_WIDE_FILENAMES */ |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
381 |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
382 PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
383 PyErr_SetFromErrno(PyObject *exc) |
|
8706
ca1c669bb041
PyErr_SetFromErrnoWithFilename(): New function which supports setting
Barry Warsaw <barry@python.org>
parents:
6789
diff
changeset
|
384 { |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
385 return PyErr_SetFromErrnoWithFilenameObject(exc, NULL); |
|
8706
ca1c669bb041
PyErr_SetFromErrnoWithFilename(): New function which supports setting
Barry Warsaw <barry@python.org>
parents:
6789
diff
changeset
|
386 } |
| 22 | 387 |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
388 #ifdef MS_WINDOWS |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
389 /* Windows specific error code handling */ |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
390 PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject( |
|
24423
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
391 PyObject *exc, |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
392 int ierr, |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
393 PyObject *filenameObject) |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
394 { |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
395 int len; |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
396 char *s; |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
397 char *s_buf = NULL; /* Free via LocalFree */ |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
398 char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */ |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
399 PyObject *v; |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
400 DWORD err = (DWORD)ierr; |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
401 if (err==0) err = GetLastError(); |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
402 len = FormatMessage( |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
403 /* Error API error */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
404 FORMAT_MESSAGE_ALLOCATE_BUFFER | |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
405 FORMAT_MESSAGE_FROM_SYSTEM | |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
406 FORMAT_MESSAGE_IGNORE_INSERTS, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
407 NULL, /* no message source */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
408 err, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
409 MAKELANGID(LANG_NEUTRAL, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
410 SUBLANG_DEFAULT), /* Default language */ |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
411 (LPTSTR) &s_buf, |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
412 0, /* size not used */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
413 NULL); /* no args */ |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
414 if (len==0) { |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
415 /* Only seen this in out of mem situations */ |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
416 sprintf(s_small_buf, "Windows Error 0x%X", err); |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
417 s = s_small_buf; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
418 s_buf = NULL; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
419 } else { |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
420 s = s_buf; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
421 /* remove trailing cr/lf and dots */ |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
422 while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.')) |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
423 s[--len] = '\0'; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
424 } |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
425 if (filenameObject != NULL) |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
426 v = Py_BuildValue("(isO)", err, s, filenameObject); |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
427 else |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
428 v = Py_BuildValue("(is)", err, s); |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
429 if (v != NULL) { |
|
24423
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
430 PyErr_SetObject(exc, v); |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
431 Py_DECREF(v); |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
432 } |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
433 LocalFree(s_buf); |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
434 return NULL; |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
435 } |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
436 |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
437 PyObject *PyErr_SetExcFromWindowsErrWithFilename( |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
438 PyObject *exc, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
439 int ierr, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
440 const char *filename) |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
441 { |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
442 PyObject *name = filename ? PyString_FromString(filename) : NULL; |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
443 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc, |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
444 ierr, |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
445 name); |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
446 Py_XDECREF(name); |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
447 return ret; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
448 } |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
449 |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
450 #ifdef Py_WIN_WIDE_FILENAMES |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
451 PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename( |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
452 PyObject *exc, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
453 int ierr, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
454 const Py_UNICODE *filename) |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
455 { |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
456 PyObject *name = filename ? |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
457 PyUnicode_FromUnicode(filename, wcslen(filename)) : |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
458 NULL; |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
459 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc, |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
460 ierr, |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
461 name); |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
462 Py_XDECREF(name); |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
463 return ret; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
464 } |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
465 #endif /* Py_WIN_WIDE_FILENAMES */ |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
466 |
|
24423
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
467 PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr) |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
468 { |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
469 return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL); |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
470 } |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
471 |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
472 PyObject *PyErr_SetFromWindowsErr(int ierr) |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
473 { |
|
24423
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
474 return PyErr_SetExcFromWindowsErrWithFilename(PyExc_WindowsError, |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
475 ierr, NULL); |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
476 } |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
477 PyObject *PyErr_SetFromWindowsErrWithFilename( |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
478 int ierr, |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
479 const char *filename) |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
480 { |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
481 PyObject *name = filename ? PyString_FromString(filename) : NULL; |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
482 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject( |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
483 PyExc_WindowsError, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
484 ierr, name); |
|
25543
dfeec3b34fae
Fix errors to pep277 checkin identified by Neal Norwitz.
Mark Hammond <mhammond@skippinet.com.au>
parents:
25535
diff
changeset
|
485 Py_XDECREF(name); |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
486 return result; |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
487 } |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
488 |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
489 #ifdef Py_WIN_WIDE_FILENAMES |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
490 PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename( |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
491 int ierr, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
492 const Py_UNICODE *filename) |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
493 { |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
494 PyObject *name = filename ? |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
495 PyUnicode_FromUnicode(filename, wcslen(filename)) : |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
496 NULL; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
497 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject( |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
498 PyExc_WindowsError, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
499 ierr, name); |
|
25543
dfeec3b34fae
Fix errors to pep277 checkin identified by Neal Norwitz.
Mark Hammond <mhammond@skippinet.com.au>
parents:
25535
diff
changeset
|
500 Py_XDECREF(name); |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
501 return result; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
502 } |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
503 #endif /* Py_WIN_WIDE_FILENAMES */ |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
504 #endif /* MS_WINDOWS */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
505 |
| 22 | 506 void |
|
14170
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
507 _PyErr_BadInternalCall(char *filename, int lineno) |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
508 { |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
509 PyErr_Format(PyExc_SystemError, |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
510 "%s:%d: bad argument to internal function", |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
511 filename, lineno); |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
512 } |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
513 |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
514 /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
515 export the entry point for existing object code: */ |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
516 #undef PyErr_BadInternalCall |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
517 void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
518 PyErr_BadInternalCall(void) |
| 22 | 519 { |
|
14170
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
520 PyErr_Format(PyExc_SystemError, |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
521 "bad argument to internal function"); |
| 22 | 522 } |
|
14170
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
523 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__) |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
524 |
|
5105
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
525 |
|
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
526 |
|
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
527 PyObject * |
|
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
528 PyErr_Format(PyObject *exception, const char *format, ...) |
|
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
529 { |
|
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
530 va_list vargs; |
|
14335
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
531 PyObject* string; |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
532 |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
533 #ifdef HAVE_STDARG_PROTOTYPES |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
534 va_start(vargs, format); |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
535 #else |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
536 va_start(vargs); |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
537 #endif |
|
5105
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
538 |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
539 string = PyString_FromFormatV(format, vargs); |
|
14335
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
540 PyErr_SetObject(exception, string); |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
541 Py_XDECREF(string); |
|
20221
abaf9ea2e560
SF bug [#467265] Compile errors on SuSe Linux on IBM/s390.
Tim Peters <tim.peters@gmail.com>
parents:
20116
diff
changeset
|
542 va_end(vargs); |
|
5105
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
543 return NULL; |
|
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
544 } |
|
6319
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
545 |
|
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
546 |
|
38246
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
547 |
|
6319
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
548 PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
549 PyErr_NewException(char *name, PyObject *base, PyObject *dict) |
|
6319
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
550 { |
|
6377
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
551 char *dot; |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
552 PyObject *modulename = NULL; |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
553 PyObject *classname = NULL; |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
554 PyObject *mydict = NULL; |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
555 PyObject *bases = NULL; |
|
6319
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
556 PyObject *result = NULL; |
|
6377
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
557 dot = strrchr(name, '.'); |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
558 if (dot == NULL) { |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
559 PyErr_SetString(PyExc_SystemError, |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
560 "PyErr_NewException: name must be module.class"); |
|
6319
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
561 return NULL; |
|
6377
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
562 } |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
563 if (base == NULL) |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
564 base = PyExc_Exception; |
|
6319
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
565 if (dict == NULL) { |
|
6377
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
566 dict = mydict = PyDict_New(); |
|
6319
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
567 if (dict == NULL) |
|
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
568 goto failure; |
|
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
569 } |
|
6377
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
570 if (PyDict_GetItemString(dict, "__module__") == NULL) { |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
571 modulename = PyString_FromStringAndSize(name, |
|
39995
6ba402b60041
Forward-port of r52136,52138: a review of overflow-detecting code.
Armin Rigo <arigo@tunes.org>
parents:
39373
diff
changeset
|
572 (Py_ssize_t)(dot-name)); |
|
6377
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
573 if (modulename == NULL) |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
574 goto failure; |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
575 if (PyDict_SetItemString(dict, "__module__", modulename) != 0) |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
576 goto failure; |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
577 } |
|
38246
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
578 if (PyTuple_Check(base)) { |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
579 bases = base; |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
580 /* INCREF as we create a new ref in the else branch */ |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
581 Py_INCREF(bases); |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
582 } else { |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
583 bases = PyTuple_Pack(1, base); |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
584 if (bases == NULL) |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
585 goto failure; |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
586 } |
|
38431
4c0823f0a0a1
Conversion of exceptions over from faked-up classes to new-style C types.
Richard Jones <richard@commonground.com.au>
parents:
38287
diff
changeset
|
587 /* Create a real new-style class. */ |
|
4c0823f0a0a1
Conversion of exceptions over from faked-up classes to new-style C types.
Richard Jones <richard@commonground.com.au>
parents:
38287
diff
changeset
|
588 result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO", |
|
4c0823f0a0a1
Conversion of exceptions over from faked-up classes to new-style C types.
Richard Jones <richard@commonground.com.au>
parents:
38287
diff
changeset
|
589 dot+1, bases, dict); |
|
6319
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
590 failure: |
|
6377
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
591 Py_XDECREF(bases); |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
592 Py_XDECREF(mydict); |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
593 Py_XDECREF(classname); |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
594 Py_XDECREF(modulename); |
|
6319
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
595 return result; |
|
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
596 } |
|
14330
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
597 |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
598 /* Call when an exception has occurred but there is no way for Python |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
599 to handle it. Examples: exception in __del__ or during GC. */ |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
600 void |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
601 PyErr_WriteUnraisable(PyObject *obj) |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
602 { |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
603 PyObject *f, *t, *v, *tb; |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
604 PyErr_Fetch(&t, &v, &tb); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
605 f = PySys_GetObject("stderr"); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
606 if (f != NULL) { |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
607 PyFile_WriteString("Exception ", f); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
608 if (t) { |
|
38455
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
609 PyObject* moduleName; |
|
40956
c83acfb1a632
SF #1669182, 2.5 was already fixed. Just assert in 2.6 since string exceptions
Neal Norwitz <nnorwitz@gmail.com>
parents:
40950
diff
changeset
|
610 char* className; |
|
c83acfb1a632
SF #1669182, 2.5 was already fixed. Just assert in 2.6 since string exceptions
Neal Norwitz <nnorwitz@gmail.com>
parents:
40950
diff
changeset
|
611 assert(PyExceptionClass_Check(t)); |
|
c83acfb1a632
SF #1669182, 2.5 was already fixed. Just assert in 2.6 since string exceptions
Neal Norwitz <nnorwitz@gmail.com>
parents:
40950
diff
changeset
|
612 className = PyExceptionClass_Name(t); |
|
38455
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
613 if (className != NULL) { |
|
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
614 char *dot = strrchr(className, '.'); |
|
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
615 if (dot != NULL) |
|
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
616 className = dot+1; |
|
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
617 } |
|
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
618 |
|
38431
4c0823f0a0a1
Conversion of exceptions over from faked-up classes to new-style C types.
Richard Jones <richard@commonground.com.au>
parents:
38287
diff
changeset
|
619 moduleName = PyObject_GetAttrString(t, "__module__"); |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
620 if (moduleName == NULL) |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
621 PyFile_WriteString("<unknown>", f); |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
622 else { |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
623 char* modstr = PyString_AsString(moduleName); |
|
40950
f3f0c697aa5b
When printing an unraisable error, don't print exceptions. before the name.
Neal Norwitz <nnorwitz@gmail.com>
parents:
40547
diff
changeset
|
624 if (modstr && |
|
f3f0c697aa5b
When printing an unraisable error, don't print exceptions. before the name.
Neal Norwitz <nnorwitz@gmail.com>
parents:
40547
diff
changeset
|
625 strcmp(modstr, "exceptions") != 0) |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
626 { |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
627 PyFile_WriteString(modstr, f); |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
628 PyFile_WriteString(".", f); |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
629 } |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
630 } |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
631 if (className == NULL) |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
632 PyFile_WriteString("<unknown>", f); |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
633 else |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
634 PyFile_WriteString(className, f); |
|
14330
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
635 if (v && v != Py_None) { |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
636 PyFile_WriteString(": ", f); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
637 PyFile_WriteObject(v, f, 0); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
638 } |
| 37779 | 639 Py_XDECREF(moduleName); |
|
14330
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
640 } |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
641 PyFile_WriteString(" in ", f); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
642 PyFile_WriteObject(obj, f, 0); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
643 PyFile_WriteString(" ignored\n", f); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
644 PyErr_Clear(); /* Just in case */ |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
645 } |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
646 Py_XDECREF(t); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
647 Py_XDECREF(v); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
648 Py_XDECREF(tb); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
649 } |
| 15591 | 650 |
|
30781
74747f62f286
Made function declaration a proper C prototype
Armin Rigo <arigo@tunes.org>
parents:
30683
diff
changeset
|
651 extern PyObject *PyModule_GetWarningsModule(void); |
| 15591 | 652 |
|
16850
2d4da6cfee61
Add PyErr_WarnExplicit(), which calls warnings.warn_explicit(), with
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
653 |
|
22121
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
654 /* Set file and line information for the current exception. |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
655 If the exception is not a SyntaxError, also sets additional attributes |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
656 to make printing of exceptions believe it is a syntax error. */ |
|
16850
2d4da6cfee61
Add PyErr_WarnExplicit(), which calls warnings.warn_explicit(), with
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
657 |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
658 void |
|
26601
cc05c2c8660e
Constify filenames and scripts. Fixes #651362.
Martin v. Löwis <martin@v.loewis.de>
parents:
25544
diff
changeset
|
659 PyErr_SyntaxLocation(const char *filename, int lineno) |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
660 { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
661 PyObject *exc, *v, *tb, *tmp; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
662 |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
663 /* add attributes for the line number and filename for the error */ |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
664 PyErr_Fetch(&exc, &v, &tb); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
665 PyErr_NormalizeException(&exc, &v, &tb); |
|
38431
4c0823f0a0a1
Conversion of exceptions over from faked-up classes to new-style C types.
Richard Jones <richard@commonground.com.au>
parents:
38287
diff
changeset
|
666 /* XXX check that it is, indeed, a syntax error. It might not |
|
4c0823f0a0a1
Conversion of exceptions over from faked-up classes to new-style C types.
Richard Jones <richard@commonground.com.au>
parents:
38287
diff
changeset
|
667 * be, though. */ |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
668 tmp = PyInt_FromLong(lineno); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
669 if (tmp == NULL) |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
670 PyErr_Clear(); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
671 else { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
672 if (PyObject_SetAttrString(v, "lineno", tmp)) |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
673 PyErr_Clear(); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
674 Py_DECREF(tmp); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
675 } |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
676 if (filename != NULL) { |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
677 tmp = PyString_FromString(filename); |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
678 if (tmp == NULL) |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
679 PyErr_Clear(); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
680 else { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
681 if (PyObject_SetAttrString(v, "filename", tmp)) |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
682 PyErr_Clear(); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
683 Py_DECREF(tmp); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
684 } |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
685 |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
686 tmp = PyErr_ProgramText(filename, lineno); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
687 if (tmp) { |
| 38479 | 688 if (PyObject_SetAttrString(v, "text", tmp)) |
| 689 PyErr_Clear(); | |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
690 Py_DECREF(tmp); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
691 } |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
692 } |
|
22121
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
693 if (PyObject_SetAttrString(v, "offset", Py_None)) { |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
694 PyErr_Clear(); |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
695 } |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
696 if (exc != PyExc_SyntaxError) { |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
697 if (!PyObject_HasAttrString(v, "msg")) { |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
698 tmp = PyObject_Str(v); |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
699 if (tmp) { |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
700 if (PyObject_SetAttrString(v, "msg", tmp)) |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
701 PyErr_Clear(); |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
702 Py_DECREF(tmp); |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
703 } else { |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
704 PyErr_Clear(); |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
705 } |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
706 } |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
707 if (!PyObject_HasAttrString(v, "print_file_and_line")) { |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
708 if (PyObject_SetAttrString(v, "print_file_and_line", |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
709 Py_None)) |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
710 PyErr_Clear(); |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
711 } |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
712 } |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
713 PyErr_Restore(exc, v, tb); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
714 } |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
715 |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
716 /* com_fetch_program_text will attempt to load the line of text that |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
717 the exception refers to. If it fails, it will return NULL but will |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
718 not set an exception. |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
719 |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
720 XXX The functionality of this function is quite similar to the |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
721 functionality in tb_displayline() in traceback.c. |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
722 */ |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
723 |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
724 PyObject * |
|
26601
cc05c2c8660e
Constify filenames and scripts. Fixes #651362.
Martin v. Löwis <martin@v.loewis.de>
parents:
25544
diff
changeset
|
725 PyErr_ProgramText(const char *filename, int lineno) |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
726 { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
727 FILE *fp; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
728 int i; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
729 char linebuf[1000]; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
730 |
|
36701
e3248f1fc54d
PyErr_ProgramText(): Grrrrrr.
Tim Peters <tim.peters@gmail.com>
parents:
36521
diff
changeset
|
731 if (filename == NULL || *filename == '\0' || lineno <= 0) |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
732 return NULL; |
|
23029
8291473fde3e
Mass checkin of universal newline support.
Jack Jansen <jack.jansen@cwi.nl>
parents:
22205
diff
changeset
|
733 fp = fopen(filename, "r" PY_STDIOTEXTMODE); |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
734 if (fp == NULL) |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
735 return NULL; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
736 for (i = 0; i < lineno; i++) { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
737 char *pLastChar = &linebuf[sizeof(linebuf) - 2]; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
738 do { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
739 *pLastChar = '\0'; |
|
23029
8291473fde3e
Mass checkin of universal newline support.
Jack Jansen <jack.jansen@cwi.nl>
parents:
22205
diff
changeset
|
740 if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, fp, NULL) == NULL) |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
741 break; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
742 /* fgets read *something*; if it didn't get as |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
743 far as pLastChar, it must have found a newline |
|
38287
698198cabbc5
Replace tab inside comment with space.
Walter Dörwald <walter@livinglogic.de>
parents:
38246
diff
changeset
|
744 or hit the end of the file; if pLastChar is \n, |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
745 it obviously found a newline; else we haven't |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
746 yet seen a newline, so must continue */ |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
747 } while (*pLastChar != '\0' && *pLastChar != '\n'); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
748 } |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
749 fclose(fp); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
750 if (i == lineno) { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
751 char *p = linebuf; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
752 while (*p == ' ' || *p == '\t' || *p == '\014') |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
753 p++; |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
754 return PyString_FromString(p); |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
755 } |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
756 return NULL; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
757 } |
|
37655
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
758 |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
759 #ifdef __cplusplus |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
760 } |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
761 #endif |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
762 |
