1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
/***********************************************************
Copyright 1991, 1992 by Stichting Mathematisch Centrum, Amsterdam, The
Netherlands.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the names of Stichting Mathematisch
Centrum or CWI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior permission.
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
******************************************************************/
/* Error handling -- see also run.c */
/* New error handling interface.
The following problem exists (existed): methods of built-in modules
are called with 'self' and 'args' arguments, but without a context
argument, so they have no way to raise a specific exception.
The same is true for the object implementations: no context argument.
The old convention was to set 'errno' and to return NULL.
The caller (usually call_function() in eval.c) detects the NULL
return value and then calls puterrno(ctx) to turn the errno value
into a true exception. Problems with this approach are:
- it used standard errno values to indicate Python-specific errors,
but this means that when such an error code is reported by a system
call (e.g., in module posix), the user gets a confusing message
- errno is a global variable, which makes extensions to a multi-
threading environment difficult; e.g., in IRIX, multi-threaded
programs must use the function oserror() instead of looking in errno
- there is no portable way to add new error numbers for specic
situations -- the value space for errno is reserved to the OS, yet
the way to turn module-specific errors into a module-specific
exception requires module-specific values for errno
- there is no way to add a more situation-specific message to an
error.
The new interface solves all these problems. To return an error, a
built-in function calls err_set(exception), err_setval(exception,
value) or err_setstr(exception, string), and returns NULL. These
functions save the value for later use by puterrno(). To adapt this
scheme to a multi-threaded environment, only the implementation of
err_setval() has to be changed.
*/
#include "allobjects.h"
#include <errno.h>
#ifndef errno
extern int errno;
#endif
#include "errcode.h"
extern char *strerror PROTO((int));
/* Last exception stored by err_setval() */
static object *last_exception;
static object *last_exc_val;
void
err_setval(exception, value)
object *exception;
object *value;
{
XDECREF(last_exception);
XINCREF(exception);
last_exception = exception;
XDECREF(last_exc_val);
XINCREF(value);
last_exc_val = value;
}
void
err_set(exception)
object *exception;
{
err_setval(exception, (object *)NULL);
}
void
err_setstr(exception, string)
object *exception;
char *string;
{
object *value = newstringobject(string);
err_setval(exception, value);
XDECREF(value);
}
int
err_occurred()
{
return last_exception != NULL;
}
void
err_get(p_exc, p_val)
object **p_exc;
object **p_val;
{
*p_exc = last_exception;
last_exception = NULL;
*p_val = last_exc_val;
last_exc_val = NULL;
}
void
err_clear()
{
XDECREF(last_exception);
last_exception = NULL;
XDECREF(last_exc_val);
last_exc_val = NULL;
}
/* Convenience functions to set a type error exception and return 0 */
int
err_badarg()
{
err_setstr(TypeError, "illegal argument type for built-in operation");
return 0;
}
object *
err_nomem()
{
err_set(MemoryError);
return NULL;
}
object *
err_errno(exc)
object *exc;
{
object *v;
if (errno == EINTR && intrcheck()) {
err_set(KeyboardInterrupt);
return NULL;
}
v = newtupleobject(2);
if (v != NULL) {
settupleitem(v, 0, newintobject((long)errno));
settupleitem(v, 1, newstringobject(strerror(errno)));
}
err_setval(exc, v);
XDECREF(v);
return NULL;
}
void
err_badcall()
{
err_setstr(SystemError, "bad argument to internal function");
}
/* Set the error appropriate to the given input error code (see errcode.h) */
void
err_input(err)
int err;
{
switch (err) {
case E_DONE:
case E_OK:
break;
case E_SYNTAX:
err_setstr(SyntaxError, "invalid syntax");
break;
case E_TOKEN:
err_setstr(SyntaxError, "invalid token");
break;
case E_INTR:
err_set(KeyboardInterrupt);
break;
case E_NOMEM:
err_nomem();
break;
case E_EOF:
err_setstr(SyntaxError, "unexpected EOF while parsing");
break;
default:
err_setstr(SystemError, "unknown parsing error");
break;
}
}
|
