Mercurial > cpython-lru_cache-weakref
annotate Python/errors.c @ 56007:b0d03fa073ec legacy-trunk
Fix issue #1590864, multiple threads and fork() can cause deadlocks, by
acquiring the import lock around fork() calls. This prevents other threads
from having that lock while the fork happens, and is the recommended way of
dealing with such issues. There are two other locks we care about, the GIL
and the Thread Local Storage lock. The GIL is obviously held when calling
Python functions like os.fork(), and the TLS lock is explicitly reallocated
instead, while also deleting now-orphaned TLS data.
This only fixes calls to os.fork(), not extension modules or embedding
programs calling C's fork() directly. Solving that requires a new set of API
functions, and possibly a rewrite of the Python/thread_*.c mess. Add a
warning explaining the problem to the documentation in the mean time.
This also changes behaviour a little on AIX. Before, AIX (but only AIX) was
getting the import lock reallocated, seemingly to avoid this very same
problem. This is not the right approach, because the import lock is a
re-entrant one, and reallocating would do the wrong thing when forking while
holding the import lock.
Will backport to 2.6, minus the tiny AIX behaviour change.
| author | Thomas Wouters <thomas@python.org> |
|---|---|
| date | Wed, 16 Sep 2009 19:55:54 +0000 |
| parents | 921e569d1215 |
| children | cf39c5e462f9 |
| 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)) { |
|
52711
7e86fa255fc2
In PyErr_GivenExceptionMatches, temporarily bump the recursion
Georg Brandl <georg@python.org>
parents:
48876
diff
changeset
|
109 int res = 0, reclimit; |
|
48107
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); |
|
52711
7e86fa255fc2
In PyErr_GivenExceptionMatches, temporarily bump the recursion
Georg Brandl <georg@python.org>
parents:
48876
diff
changeset
|
112 /* Temporarily bump the recursion limit, so that in the most |
|
7e86fa255fc2
In PyErr_GivenExceptionMatches, temporarily bump the recursion
Georg Brandl <georg@python.org>
parents:
48876
diff
changeset
|
113 common case PyObject_IsSubclass will not raise a recursion |
|
7e86fa255fc2
In PyErr_GivenExceptionMatches, temporarily bump the recursion
Georg Brandl <georg@python.org>
parents:
48876
diff
changeset
|
114 error we have to ignore anyway. */ |
|
7e86fa255fc2
In PyErr_GivenExceptionMatches, temporarily bump the recursion
Georg Brandl <georg@python.org>
parents:
48876
diff
changeset
|
115 reclimit = Py_GetRecursionLimit(); |
|
7e86fa255fc2
In PyErr_GivenExceptionMatches, temporarily bump the recursion
Georg Brandl <georg@python.org>
parents:
48876
diff
changeset
|
116 Py_SetRecursionLimit(reclimit + 5); |
|
48107
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
117 res = PyObject_IsSubclass(err, exc); |
|
52711
7e86fa255fc2
In PyErr_GivenExceptionMatches, temporarily bump the recursion
Georg Brandl <georg@python.org>
parents:
48876
diff
changeset
|
118 Py_SetRecursionLimit(reclimit); |
|
48107
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
119 /* 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
|
120 if (res == -1) { |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
121 PyErr_WriteUnraisable(err); |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
122 res = 0; |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
123 } |
|
0fbddc04aee1
#2542: now that issubclass() may call arbitrary code,
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
47527
diff
changeset
|
124 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
|
125 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
|
126 } |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
127 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
128 return err == exc; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
129 } |
|
10638
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
130 |
|
6146
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 int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
133 PyErr_ExceptionMatches(PyObject *exc) |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
134 { |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
135 return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc); |
|
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 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
138 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
139 /* 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
|
140 eval_code2(), do_raise(), and PyErr_Print() |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
141 */ |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
142 void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
143 PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb) |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
144 { |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
145 PyObject *type = *exc; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
146 PyObject *value = *val; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
147 PyObject *inclass = NULL; |
|
20116
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
148 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
|
149 PyThreadState *tstate = NULL; |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
150 |
|
13883
15ad4088a700
Avoid dumping core when PyErr_NormalizeException() is called without
Guido van Rossum <guido@python.org>
parents:
13658
diff
changeset
|
151 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
|
152 /* 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
|
153 return; |
|
13883
15ad4088a700
Avoid dumping core when PyErr_NormalizeException() is called without
Guido van Rossum <guido@python.org>
parents:
13658
diff
changeset
|
154 } |
|
15ad4088a700
Avoid dumping core when PyErr_NormalizeException() is called without
Guido van Rossum <guido@python.org>
parents:
13658
diff
changeset
|
155 |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
156 /* 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
|
157 set to NULL. |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
158 */ |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
159 if (!value) { |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
160 value = Py_None; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
161 Py_INCREF(value); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
162 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
163 |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
164 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
|
165 inclass = PyExceptionInstance_Class(value); |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
166 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
167 /* 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
|
168 value will be an instance. |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
169 */ |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
170 if (PyExceptionClass_Check(type)) { |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
171 /* 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
|
172 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
|
173 value as an argument to instantiation of the type |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
174 class. |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
175 */ |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
176 if (!inclass || !PyObject_IsSubclass(inclass, type)) { |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
177 PyObject *args, *res; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
178 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
179 if (value == Py_None) |
|
30683
3b59fa5d25b1
Simplify and speedup uses of Py_BuildValue():
Raymond Hettinger <python@rcn.com>
parents:
29877
diff
changeset
|
180 args = PyTuple_New(0); |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
181 else if (PyTuple_Check(value)) { |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
182 Py_INCREF(value); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
183 args = value; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
184 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
185 else |
|
30683
3b59fa5d25b1
Simplify and speedup uses of Py_BuildValue():
Raymond Hettinger <python@rcn.com>
parents:
29877
diff
changeset
|
186 args = PyTuple_Pack(1, value); |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
187 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
188 if (args == NULL) |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
189 goto finally; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
190 res = PyEval_CallObject(type, args); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
191 Py_DECREF(args); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
192 if (res == NULL) |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
193 goto finally; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
194 Py_DECREF(value); |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
195 value = res; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
196 } |
|
6358
9e82dd76288e
PyErr_NormalizeException(): If the exception's type is a class and the
Barry Warsaw <barry@python.org>
parents:
6319
diff
changeset
|
197 /* 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
|
198 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
|
199 */ |
|
9e82dd76288e
PyErr_NormalizeException(): If the exception's type is a class and the
Barry Warsaw <barry@python.org>
parents:
6319
diff
changeset
|
200 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
|
201 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
|
202 type = inclass; |
|
9e82dd76288e
PyErr_NormalizeException(): If the exception's type is a class and the
Barry Warsaw <barry@python.org>
parents:
6319
diff
changeset
|
203 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
|
204 } |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
205 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
206 *exc = type; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
207 *val = value; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
208 return; |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
209 finally: |
|
6789
bb440a2975ab
Fix subtle bug in cleanup code in PyErr_NormalizeException(), detected
Guido van Rossum <guido@python.org>
parents:
6377
diff
changeset
|
210 Py_DECREF(type); |
|
bb440a2975ab
Fix subtle bug in cleanup code in PyErr_NormalizeException(), detected
Guido van Rossum <guido@python.org>
parents:
6377
diff
changeset
|
211 Py_DECREF(value); |
|
20116
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
212 /* 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
|
213 exception had a traceback, use the old traceback for the |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
214 new exception. It's better than nothing. |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
215 */ |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
216 initial_tb = *tb; |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
217 PyErr_Fetch(exc, val, tb); |
|
20116
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
218 if (initial_tb != NULL) { |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
219 if (*tb == NULL) |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
220 *tb = initial_tb; |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
221 else |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
222 Py_DECREF(initial_tb); |
|
55874d8e0dfb
PyErr_NormalizeException()
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19477
diff
changeset
|
223 } |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
224 /* 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
|
225 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
|
226 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
|
227 --tstate->recursion_depth; |
|
52738
54b2cd21ab46
PyErr_NormalizeException may not set an error, so convert the PyErr_SetObject
Georg Brandl <georg@python.org>
parents:
52711
diff
changeset
|
228 /* throw away the old exception... */ |
|
54b2cd21ab46
PyErr_NormalizeException may not set an error, so convert the PyErr_SetObject
Georg Brandl <georg@python.org>
parents:
52711
diff
changeset
|
229 Py_DECREF(*exc); |
|
54b2cd21ab46
PyErr_NormalizeException may not set an error, so convert the PyErr_SetObject
Georg Brandl <georg@python.org>
parents:
52711
diff
changeset
|
230 Py_DECREF(*val); |
|
54b2cd21ab46
PyErr_NormalizeException may not set an error, so convert the PyErr_SetObject
Georg Brandl <georg@python.org>
parents:
52711
diff
changeset
|
231 /* ... and use the recursion error instead */ |
|
54b2cd21ab46
PyErr_NormalizeException may not set an error, so convert the PyErr_SetObject
Georg Brandl <georg@python.org>
parents:
52711
diff
changeset
|
232 *exc = PyExc_RuntimeError; |
|
54b2cd21ab46
PyErr_NormalizeException may not set an error, so convert the PyErr_SetObject
Georg Brandl <georg@python.org>
parents:
52711
diff
changeset
|
233 *val = PyExc_RecursionErrorInst; |
|
54b2cd21ab46
PyErr_NormalizeException may not set an error, so convert the PyErr_SetObject
Georg Brandl <georg@python.org>
parents:
52711
diff
changeset
|
234 Py_INCREF(*exc); |
|
54b2cd21ab46
PyErr_NormalizeException may not set an error, so convert the PyErr_SetObject
Georg Brandl <georg@python.org>
parents:
52711
diff
changeset
|
235 Py_INCREF(*val); |
|
54b2cd21ab46
PyErr_NormalizeException may not set an error, so convert the PyErr_SetObject
Georg Brandl <georg@python.org>
parents:
52711
diff
changeset
|
236 /* just keeping the old traceback */ |
|
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
|
237 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
|
238 } |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
239 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
|
240 --tstate->recursion_depth; |
|
6146
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
241 } |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
242 |
|
a2a1df0ca808
Three new C API functions:
Barry Warsaw <barry@python.org>
parents:
5979
diff
changeset
|
243 |
| 6 | 244 void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
245 PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback) |
| 6 | 246 { |
|
31797
846b3ee7e106
Changed random calls to PyThreadState_Get() to use the macro
Nicholas Bastin <nick.bastin@gmail.com>
parents:
30979
diff
changeset
|
247 PyThreadState *tstate = PyThreadState_GET(); |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
248 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
249 *p_type = tstate->curexc_type; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
250 *p_value = tstate->curexc_value; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
251 *p_traceback = tstate->curexc_traceback; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
252 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
253 tstate->curexc_type = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
254 tstate->curexc_value = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
255 tstate->curexc_traceback = NULL; |
| 6 | 256 } |
| 257 | |
| 258 void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
259 PyErr_Clear(void) |
| 6 | 260 { |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
261 PyErr_Restore(NULL, NULL, NULL); |
| 6 | 262 } |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
263 |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
264 /* 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
|
265 |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
266 int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
267 PyErr_BadArgument(void) |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
268 { |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
5370
diff
changeset
|
269 PyErr_SetString(PyExc_TypeError, |
| 15318 | 270 "bad argument type for built-in operation"); |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
271 return 0; |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
272 } |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
273 |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
274 PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
275 PyErr_NoMemory(void) |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
276 { |
|
14066
25eea88047e9
Do not set a MemoryError exception over another MemoryError exception,
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents:
13883
diff
changeset
|
277 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
|
278 /* already current */ |
|
25eea88047e9
Do not set a MemoryError exception over another MemoryError exception,
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents:
13883
diff
changeset
|
279 return NULL; |
|
25eea88047e9
Do not set a MemoryError exception over another MemoryError exception,
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents:
13883
diff
changeset
|
280 |
|
6190
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
281 /* 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
|
282 if (PyExc_MemoryErrorInst) |
|
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
283 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
|
284 else |
|
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
285 /* 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
|
286 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
|
287 */ |
|
b5757e87eb32
PyErr_NoMemory(): If the pre-instantiated memory exception is non-null
Barry Warsaw <barry@python.org>
parents:
6146
diff
changeset
|
288 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
|
289 |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
290 return NULL; |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
291 } |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
292 |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
293 PyObject * |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
294 PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject) |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
295 { |
|
5370
1ea1f019268d
Quickly renamed. Also removed the long comment explaining why this is
Guido van Rossum <guido@python.org>
parents:
5318
diff
changeset
|
296 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
|
297 char *s; |
|
1832
79e420805c67
err_clear: clear interpreter stack trace
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
298 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
|
299 #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
|
300 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
|
301 #endif |
|
24071
8142f8d668a0
Patch #569753: Remove support for WIN16.
Martin v. Löwis <martin@v.loewis.de>
parents:
23029
diff
changeset
|
302 #ifdef MS_WINDOWS |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
303 char *s_buf = NULL; |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
304 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
|
305 #endif |
|
2376
c31eaed7798b
rename macstrerror to PyMac_StrError; no EINTR test in CW
Guido van Rossum <guido@python.org>
parents:
2190
diff
changeset
|
306 #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
|
307 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
|
308 return NULL; |
|
2376
c31eaed7798b
rename macstrerror to PyMac_StrError; no EINTR test in CW
Guido van Rossum <guido@python.org>
parents:
2190
diff
changeset
|
309 #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
|
310 #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
|
311 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
|
312 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
|
313 #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
|
314 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
|
315 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
|
316 else |
|
24071
8142f8d668a0
Patch #569753: Remove support for WIN16.
Martin v. Löwis <martin@v.loewis.de>
parents:
23029
diff
changeset
|
317 #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
|
318 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
|
319 #else |
|
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
320 { |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
321 /* 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
|
322 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
|
323 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
|
324 a Win32 error code |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
325 */ |
|
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
|
326 if (i > 0 && i < _sys_nerr) { |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
327 s = _sys_errlist[i]; |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
328 } |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
329 else { |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
330 int len = FormatMessage( |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
331 FORMAT_MESSAGE_ALLOCATE_BUFFER | |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
332 FORMAT_MESSAGE_FROM_SYSTEM | |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
333 FORMAT_MESSAGE_IGNORE_INSERTS, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
334 NULL, /* no message source */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
335 i, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
336 MAKELANGID(LANG_NEUTRAL, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
337 SUBLANG_DEFAULT), |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
338 /* Default language */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
339 (LPTSTR) &s_buf, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
340 0, /* size not used */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
341 NULL); /* no args */ |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
342 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
|
343 /* 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
|
344 situations */ |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
345 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
|
346 s = s_small_buf; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
347 s_buf = NULL; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
348 } else { |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
349 s = s_buf; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
350 /* remove trailing cr/lf and dots */ |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
351 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
|
352 s[--len] = '\0'; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
353 } |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
354 } |
|
10638
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
355 } |
|
22205
f4487350c537
Patch #494045: patches errno and stat to cope on plan9.
Martin v. Löwis <martin@v.loewis.de>
parents:
22121
diff
changeset
|
356 #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
|
357 #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
|
358 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
|
359 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
|
360 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
|
361 v = Py_BuildValue("(is)", i, s); |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
362 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
|
363 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
|
364 Py_DECREF(v); |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
365 } |
|
24071
8142f8d668a0
Patch #569753: Remove support for WIN16.
Martin v. Löwis <martin@v.loewis.de>
parents:
23029
diff
changeset
|
366 #ifdef MS_WINDOWS |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
367 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
|
368 #endif |
|
9
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
369 return NULL; |
|
33701db4ea55
Adde dconvenience functions.
Guido van Rossum <guido@python.org>
parents:
6
diff
changeset
|
370 } |
|
10638
df8a1c281ad7
Patch by Christian Tismer for Win32, to use FormatMessage() instead of
Guido van Rossum <guido@python.org>
parents:
9671
diff
changeset
|
371 |
|
8706
ca1c669bb041
PyErr_SetFromErrnoWithFilename(): New function which supports setting
Barry Warsaw <barry@python.org>
parents:
6789
diff
changeset
|
372 |
|
ca1c669bb041
PyErr_SetFromErrnoWithFilename(): New function which supports setting
Barry Warsaw <barry@python.org>
parents:
6789
diff
changeset
|
373 PyObject * |
|
54721
921e569d1215
Add const qualifier to PyErr_SetFromErrnoWithFilename and to
Alexandre Vassalotti <alexandre@peadrop.com>
parents:
54126
diff
changeset
|
374 PyErr_SetFromErrnoWithFilename(PyObject *exc, const char *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 { |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
376 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
|
377 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
|
378 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
|
379 return result; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
380 } |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
381 |
|
54126
d64d47ee54a1
Issue #3527: Removed Py_WIN_WIDE_FILENAMES which is not used any more.
Hirokazu Yamamoto <ocean-city@m2.ccsnet.ne.jp>
parents:
52738
diff
changeset
|
382 #ifdef MS_WINDOWS |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
383 PyObject * |
|
54721
921e569d1215
Add const qualifier to PyErr_SetFromErrnoWithFilename and to
Alexandre Vassalotti <alexandre@peadrop.com>
parents:
54126
diff
changeset
|
384 PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, const Py_UNICODE *filename) |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
385 { |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
386 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
|
387 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
|
388 NULL; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
389 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
|
390 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
|
391 return result; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
392 } |
|
54126
d64d47ee54a1
Issue #3527: Removed Py_WIN_WIDE_FILENAMES which is not used any more.
Hirokazu Yamamoto <ocean-city@m2.ccsnet.ne.jp>
parents:
52738
diff
changeset
|
393 #endif /* MS_WINDOWS */ |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
394 |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
395 PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
396 PyErr_SetFromErrno(PyObject *exc) |
|
8706
ca1c669bb041
PyErr_SetFromErrnoWithFilename(): New function which supports setting
Barry Warsaw <barry@python.org>
parents:
6789
diff
changeset
|
397 { |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
398 return PyErr_SetFromErrnoWithFilenameObject(exc, NULL); |
|
8706
ca1c669bb041
PyErr_SetFromErrnoWithFilename(): New function which supports setting
Barry Warsaw <barry@python.org>
parents:
6789
diff
changeset
|
399 } |
| 22 | 400 |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
401 #ifdef MS_WINDOWS |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
402 /* 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
|
403 PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject( |
|
24423
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
404 PyObject *exc, |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
405 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
|
406 PyObject *filenameObject) |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
407 { |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
408 int len; |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
409 char *s; |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
410 char *s_buf = NULL; /* Free via LocalFree */ |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
411 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
|
412 PyObject *v; |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
413 DWORD err = (DWORD)ierr; |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
414 if (err==0) err = GetLastError(); |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
415 len = FormatMessage( |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
416 /* Error API error */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
417 FORMAT_MESSAGE_ALLOCATE_BUFFER | |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
418 FORMAT_MESSAGE_FROM_SYSTEM | |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
419 FORMAT_MESSAGE_IGNORE_INSERTS, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
420 NULL, /* no message source */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
421 err, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
422 MAKELANGID(LANG_NEUTRAL, |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
423 SUBLANG_DEFAULT), /* Default language */ |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
424 (LPTSTR) &s_buf, |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
425 0, /* size not used */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
426 NULL); /* no args */ |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
427 if (len==0) { |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
428 /* 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
|
429 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
|
430 s = s_small_buf; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
431 s_buf = NULL; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
432 } else { |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
433 s = s_buf; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
434 /* remove trailing cr/lf and dots */ |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
435 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
|
436 s[--len] = '\0'; |
|
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
437 } |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
438 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
|
439 v = Py_BuildValue("(isO)", err, s, filenameObject); |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
440 else |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
441 v = Py_BuildValue("(is)", err, s); |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
442 if (v != NULL) { |
|
24423
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
443 PyErr_SetObject(exc, v); |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
444 Py_DECREF(v); |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
445 } |
|
25544
2fa559fb6ec5
Fix [ 616716 ] Bug in PyErr_SetExcFromWindows
Mark Hammond <mhammond@skippinet.com.au>
parents:
25543
diff
changeset
|
446 LocalFree(s_buf); |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
447 return NULL; |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
448 } |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
449 |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
450 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
|
451 PyObject *exc, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
452 int ierr, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
453 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
|
454 { |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
455 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
|
456 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
|
457 ierr, |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
458 name); |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
459 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
|
460 return ret; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
461 } |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
462 |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
463 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
|
464 PyObject *exc, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
465 int ierr, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
466 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
|
467 { |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
468 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
|
469 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
|
470 NULL; |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
471 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
|
472 ierr, |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
473 name); |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
474 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
|
475 return ret; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
476 } |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
477 |
|
24423
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
478 PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr) |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
479 { |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
480 return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL); |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
481 } |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
482 |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
483 PyObject *PyErr_SetFromWindowsErr(int ierr) |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
484 { |
|
24423
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
485 return PyErr_SetExcFromWindowsErrWithFilename(PyExc_WindowsError, |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
486 ierr, NULL); |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
487 } |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
488 PyObject *PyErr_SetFromWindowsErrWithFilename( |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
489 int ierr, |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
490 const char *filename) |
|
3db261a93a5b
New functions for extension writers on Windows:
Thomas Heller <theller@ctypes.org>
parents:
24071
diff
changeset
|
491 { |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
492 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
|
493 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
|
494 PyExc_WindowsError, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
495 ierr, name); |
|
25543
dfeec3b34fae
Fix errors to pep277 checkin identified by Neal Norwitz.
Mark Hammond <mhammond@skippinet.com.au>
parents:
25535
diff
changeset
|
496 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
|
497 return result; |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
498 } |
|
25535
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
499 |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
500 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
|
501 int ierr, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
502 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
|
503 { |
|
36751
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
504 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
|
505 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
|
506 NULL; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
507 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
|
508 PyExc_WindowsError, |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
509 ierr, name); |
|
25543
dfeec3b34fae
Fix errors to pep277 checkin identified by Neal Norwitz.
Mark Hammond <mhammond@skippinet.com.au>
parents:
25535
diff
changeset
|
510 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
|
511 return result; |
|
861065256487
Patch 594001: PEP 277 - Unicode file name support for Windows NT.
Mark Hammond <mhammond@skippinet.com.au>
parents:
24423
diff
changeset
|
512 } |
|
11801
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
513 #endif /* MS_WINDOWS */ |
|
fe960ad3db65
Patch by Mark Hammond:
Guido van Rossum <guido@python.org>
parents:
10638
diff
changeset
|
514 |
| 22 | 515 void |
|
14170
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
516 _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
|
517 { |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
518 PyErr_Format(PyExc_SystemError, |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
519 "%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
|
520 filename, lineno); |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
521 } |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
522 |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
523 /* 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
|
524 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
|
525 #undef PyErr_BadInternalCall |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
526 void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
527 PyErr_BadInternalCall(void) |
| 22 | 528 { |
|
14170
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
529 PyErr_Format(PyExc_SystemError, |
|
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
530 "bad argument to internal function"); |
| 22 | 531 } |
|
14170
019265b3a856
Improve the exceptions raised by PyErr_BadInternalCall(); adding the
Fred Drake <fdrake@acm.org>
parents:
14066
diff
changeset
|
532 #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
|
533 |
|
5105
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
534 |
|
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
535 |
|
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
536 PyObject * |
|
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
537 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
|
538 { |
|
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
539 va_list vargs; |
|
14335
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
540 PyObject* string; |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
541 |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
542 #ifdef HAVE_STDARG_PROTOTYPES |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
543 va_start(vargs, format); |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
544 #else |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
545 va_start(vargs); |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
546 #endif |
|
5105
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
547 |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
548 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
|
549 PyErr_SetObject(exception, string); |
|
951eb3af3494
code part of patch #100895 by Fredrik Lundh
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14330
diff
changeset
|
550 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
|
551 va_end(vargs); |
|
5105
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
552 return NULL; |
|
00fd6857f76b
Added convenience function PyErr_Format(exception, formatstring, ...) -> NULL.
Guido van Rossum <guido@python.org>
parents:
4654
diff
changeset
|
553 } |
|
6319
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
554 |
|
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
555 |
|
38246
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
556 |
|
6319
b7f0b98f5325
New API PyErr_NewException(name, base, dict) to create simple new exceptions.
Guido van Rossum <guido@python.org>
parents:
6190
diff
changeset
|
557 PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13578
diff
changeset
|
558 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
|
559 { |
|
6377
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
560 char *dot; |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
561 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
|
562 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
|
563 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
|
564 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
|
565 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
|
566 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
|
567 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
|
568 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
|
569 "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
|
570 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
|
571 } |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
572 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
|
573 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
|
574 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
|
575 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
|
576 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
|
577 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
|
578 } |
|
6377
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
579 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
|
580 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
|
581 (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
|
582 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
|
583 goto failure; |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
584 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
|
585 goto failure; |
|
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
586 } |
|
38246
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
587 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
|
588 bases = base; |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
589 /* 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
|
590 Py_INCREF(bases); |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
591 } else { |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
592 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
|
593 if (bases == NULL) |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
594 goto failure; |
|
ee2139935a1d
PyErr_NewException now accepts a tuple of base classes as its
Georg Brandl <georg@python.org>
parents:
37779
diff
changeset
|
595 } |
|
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
|
596 /* 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
|
597 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
|
598 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
|
599 failure: |
|
6377
4cb223f29337
New version of PyErr_NewException() that is compatible with -X option.
Guido van Rossum <guido@python.org>
parents:
6358
diff
changeset
|
600 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
|
601 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
|
602 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
|
603 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
|
604 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
|
605 } |
|
14330
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
606 |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
607 /* 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
|
608 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
|
609 void |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
610 PyErr_WriteUnraisable(PyObject *obj) |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
611 { |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
612 PyObject *f, *t, *v, *tb; |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
613 PyErr_Fetch(&t, &v, &tb); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
614 f = PySys_GetObject("stderr"); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
615 if (f != NULL) { |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
616 PyFile_WriteString("Exception ", f); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
617 if (t) { |
|
38455
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
618 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
|
619 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
|
620 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
|
621 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
|
622 if (className != NULL) { |
|
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
623 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
|
624 if (dot != NULL) |
|
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
625 className = dot+1; |
|
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
626 } |
|
1a23706139ca
PyErr_Display(), PyErr_WriteUnraisable(): Coverity found a cut-and-paste
Tim Peters <tim.peters@gmail.com>
parents:
38431
diff
changeset
|
627 |
|
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
|
628 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
|
629 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
|
630 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
|
631 else { |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
632 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
|
633 if (modstr && |
|
f3f0c697aa5b
When printing an unraisable error, don't print exceptions. before the name.
Neal Norwitz <nnorwitz@gmail.com>
parents:
40547
diff
changeset
|
634 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
|
635 { |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
636 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
|
637 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
|
638 } |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
639 } |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
640 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
|
641 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
|
642 else |
|
8e04de2480e4
PEP 352 implementation. Creates a new base class, BaseException, which has an
Brett Cannon <bcannon@gmail.com>
parents:
36737
diff
changeset
|
643 PyFile_WriteString(className, f); |
|
14330
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
644 if (v && v != Py_None) { |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
645 PyFile_WriteString(": ", f); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
646 PyFile_WriteObject(v, f, 0); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
647 } |
| 37779 | 648 Py_XDECREF(moduleName); |
|
14330
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
649 } |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
650 PyFile_WriteString(" in ", f); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
651 PyFile_WriteObject(obj, f, 0); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
652 PyFile_WriteString(" ignored\n", f); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
653 PyErr_Clear(); /* Just in case */ |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
654 } |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
655 Py_XDECREF(t); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
656 Py_XDECREF(v); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
657 Py_XDECREF(tb); |
|
6dee1985c681
refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
14170
diff
changeset
|
658 } |
| 15591 | 659 |
|
30781
74747f62f286
Made function declaration a proper C prototype
Armin Rigo <arigo@tunes.org>
parents:
30683
diff
changeset
|
660 extern PyObject *PyModule_GetWarningsModule(void); |
| 15591 | 661 |
|
16850
2d4da6cfee61
Add PyErr_WarnExplicit(), which calls warnings.warn_explicit(), with
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
662 |
|
22121
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
663 /* 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
|
664 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
|
665 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
|
666 |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
667 void |
|
26601
cc05c2c8660e
Constify filenames and scripts. Fixes #651362.
Martin v. Löwis <martin@v.loewis.de>
parents:
25544
diff
changeset
|
668 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
|
669 { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
670 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
|
671 |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
672 /* 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
|
673 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
|
674 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
|
675 /* 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
|
676 * be, though. */ |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
677 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
|
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, "lineno", 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 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
|
686 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
|
687 if (tmp == NULL) |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
688 PyErr_Clear(); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
689 else { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
690 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
|
691 PyErr_Clear(); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
692 Py_DECREF(tmp); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
693 } |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
694 |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
695 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
|
696 if (tmp) { |
| 38479 | 697 if (PyObject_SetAttrString(v, "text", tmp)) |
| 698 PyErr_Clear(); | |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
699 Py_DECREF(tmp); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
700 } |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
701 } |
|
22121
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
702 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
|
703 PyErr_Clear(); |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
704 } |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
705 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
|
706 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
|
707 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
|
708 if (tmp) { |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
709 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
|
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 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
|
712 } else { |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
713 PyErr_Clear(); |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
714 } |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
715 } |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
716 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
|
717 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
|
718 Py_None)) |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
719 PyErr_Clear(); |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
720 } |
|
d4406fbfcb4e
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
20221
diff
changeset
|
721 } |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
722 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
|
723 } |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
724 |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
725 /* 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
|
726 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
|
727 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
|
728 |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
729 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
|
730 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
|
731 */ |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
732 |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
733 PyObject * |
|
26601
cc05c2c8660e
Constify filenames and scripts. Fixes #651362.
Martin v. Löwis <martin@v.loewis.de>
parents:
25544
diff
changeset
|
734 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
|
735 { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
736 FILE *fp; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
737 int i; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
738 char linebuf[1000]; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
739 |
|
36701
e3248f1fc54d
PyErr_ProgramText(): Grrrrrr.
Tim Peters <tim.peters@gmail.com>
parents:
36521
diff
changeset
|
740 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
|
741 return NULL; |
|
23029
8291473fde3e
Mass checkin of universal newline support.
Jack Jansen <jack.jansen@cwi.nl>
parents:
22205
diff
changeset
|
742 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
|
743 if (fp == NULL) |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
744 return NULL; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
745 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
|
746 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
|
747 do { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
748 *pLastChar = '\0'; |
|
23029
8291473fde3e
Mass checkin of universal newline support.
Jack Jansen <jack.jansen@cwi.nl>
parents:
22205
diff
changeset
|
749 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
|
750 break; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
751 /* 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
|
752 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
|
753 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
|
754 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
|
755 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
|
756 } 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
|
757 } |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
758 fclose(fp); |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
759 if (i == lineno) { |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
760 char *p = linebuf; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
761 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
|
762 p++; |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
763 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
|
764 } |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
765 return NULL; |
|
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
15591
diff
changeset
|
766 } |
|
37655
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
767 |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
768 #ifdef __cplusplus |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
769 } |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
770 #endif |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36751
diff
changeset
|
771 |
