Mercurial > mm7

comparison lib/swig/swigwin-2.0.11/Lib/exception.i @ 1899:b3009adc0e2f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Adding swig, gitignore, hgignore
author Nomad
date Mon, 21 Oct 2013 10:42:27 +0200
parents
children
comparison
equal deleted inserted replaced
1867:eb580660bbbb 1899:b3009adc0e2f
1 /* -----------------------------------------------------------------------------
2 * exception.i
3 *
4 * SWIG library file providing language independent exception handling
5 * ----------------------------------------------------------------------------- */
6
7 #if defined(SWIGUTL)
8 #error "This version of exception.i should not be used"
9 #endif
10
11
12 %insert("runtime") "swigerrors.swg"
13
14
15 #ifdef SWIGPHP
16 %{
17 #include "zend_exceptions.h"
18 #define SWIG_exception(code, msg) { zend_throw_exception(NULL, (char*)msg, code TSRMLS_CC); }
19 %}
20 #endif
21
22 #ifdef SWIGGUILE
23 %{
24 SWIGINTERN void SWIG_exception_ (int code, const char *msg,
25 const char *subr) {
26 #define ERROR(scmerr) \
27 scm_error(scm_from_locale_string((char *) (scmerr)), \
28 (char *) subr, (char *) msg, \
29 SCM_EOL, SCM_BOOL_F)
30 #define MAP(swigerr, scmerr) \
31 case swigerr: \
32 ERROR(scmerr); \
33 break
34 switch (code) {
35 MAP(SWIG_MemoryError, "swig-memory-error");
36 MAP(SWIG_IOError, "swig-io-error");
37 MAP(SWIG_RuntimeError, "swig-runtime-error");
38 MAP(SWIG_IndexError, "swig-index-error");
39 MAP(SWIG_TypeError, "swig-type-error");
40 MAP(SWIG_DivisionByZero, "swig-division-by-zero");
41 MAP(SWIG_OverflowError, "swig-overflow-error");
42 MAP(SWIG_SyntaxError, "swig-syntax-error");
43 MAP(SWIG_ValueError, "swig-value-error");
44 MAP(SWIG_SystemError, "swig-system-error");
45 default:
46 ERROR("swig-error");
47 }
48 #undef ERROR
49 #undef MAP
50 }
51
52 #define SWIG_exception(a,b) SWIG_exception_(a, b, FUNC_NAME)
53 %}
54 #endif
55
56 #ifdef SWIGMZSCHEME
57
58 %{
59 SWIGINTERN void SWIG_exception_ (int code, const char *msg) {
60 #define ERROR(errname) \
61 scheme_signal_error(errname " (%s)", msg);
62 #define MAP(swigerr, errname) \
63 case swigerr: \
64 ERROR(errname); \
65 break
66 switch (code) {
67 MAP(SWIG_MemoryError, "swig-memory-error");
68 MAP(SWIG_IOError, "swig-io-error");
69 MAP(SWIG_RuntimeError, "swig-runtime-error");
70 MAP(SWIG_IndexError, "swig-index-error");
71 MAP(SWIG_TypeError, "swig-type-error");
72 MAP(SWIG_DivisionByZero, "swig-division-by-zero");
73 MAP(SWIG_OverflowError, "swig-overflow-error");
74 MAP(SWIG_SyntaxError, "swig-syntax-error");
75 MAP(SWIG_ValueError, "swig-value-error");
76 MAP(SWIG_SystemError, "swig-system-error");
77 default:
78 ERROR("swig-error");
79 }
80 #undef ERROR
81 #undef MAP
82 }
83
84 #define SWIG_exception(a,b) SWIG_exception_(a, b)
85 %}
86 #endif
87
88 #ifdef SWIGJAVA
89 %{
90 SWIGINTERN void SWIG_JavaException(JNIEnv *jenv, int code, const char *msg) {
91 SWIG_JavaExceptionCodes exception_code = SWIG_JavaUnknownError;
92 switch(code) {
93 case SWIG_MemoryError:
94 exception_code = SWIG_JavaOutOfMemoryError;
95 break;
96 case SWIG_IOError:
97 exception_code = SWIG_JavaIOException;
98 break;
99 case SWIG_SystemError:
100 case SWIG_RuntimeError:
101 exception_code = SWIG_JavaRuntimeException;
102 break;
103 case SWIG_OverflowError:
104 case SWIG_IndexError:
105 exception_code = SWIG_JavaIndexOutOfBoundsException;
106 break;
107 case SWIG_DivisionByZero:
108 exception_code = SWIG_JavaArithmeticException;
109 break;
110 case SWIG_SyntaxError:
111 case SWIG_ValueError:
112 case SWIG_TypeError:
113 exception_code = SWIG_JavaIllegalArgumentException;
114 break;
115 case SWIG_UnknownError:
116 default:
117 exception_code = SWIG_JavaUnknownError;
118 break;
119 }
120 SWIG_JavaThrowException(jenv, exception_code, msg);
121 }
122 %}
123
124 #define SWIG_exception(code, msg)\
125 { SWIG_JavaException(jenv, code, msg); return $null; }
126 #endif // SWIGJAVA
127
128 #ifdef SWIGOCAML
129 %{
130 #define OCAML_MSG_BUF_LEN 1024
131 SWIGINTERN void SWIG_exception_(int code, const char *msg) {
132 char msg_buf[OCAML_MSG_BUF_LEN];
133 sprintf( msg_buf, "Exception(%d): %s\n", code, msg );
134 failwith( msg_buf );
135 }
136 #define SWIG_exception(a,b) SWIG_exception_((a),(b))
137 %}
138 #endif
139
140
141 #ifdef SWIGCHICKEN
142 %{
143 SWIGINTERN void SWIG_exception_(int code, const char *msg) {
144 C_word *a;
145 C_word scmmsg;
146 C_word list;
147
148 a = C_alloc (C_SIZEOF_STRING (strlen (msg)) + C_SIZEOF_LIST(2));
149 scmmsg = C_string2 (&a, (char *) msg);
150 list = C_list(&a, 2, C_fix(code), scmmsg);
151 SWIG_ThrowException(list);
152 }
153 #define SWIG_exception(a,b) SWIG_exception_((a),(b))
154 %}
155 #endif
156
157 #ifdef SWIGCSHARP
158 %{
159 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
160 if (code == SWIG_ValueError) {
161 SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
162 SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
163 } else {
164 SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
165 switch(code) {
166 case SWIG_MemoryError:
167 exception_code = SWIG_CSharpOutOfMemoryException;
168 break;
169 case SWIG_IndexError:
170 exception_code = SWIG_CSharpIndexOutOfRangeException;
171 break;
172 case SWIG_DivisionByZero:
173 exception_code = SWIG_CSharpDivideByZeroException;
174 break;
175 case SWIG_IOError:
176 exception_code = SWIG_CSharpIOException;
177 break;
178 case SWIG_OverflowError:
179 exception_code = SWIG_CSharpOverflowException;
180 break;
181 case SWIG_RuntimeError:
182 case SWIG_TypeError:
183 case SWIG_SyntaxError:
184 case SWIG_SystemError:
185 case SWIG_UnknownError:
186 default:
187 exception_code = SWIG_CSharpApplicationException;
188 break;
189 }
190 SWIG_CSharpSetPendingException(exception_code, msg);
191 }
192 }
193 %}
194
195 #define SWIG_exception(code, msg)\
196 { SWIG_CSharpException(code, msg); return $null; }
197 #endif // SWIGCSHARP
198
199 #ifdef SWIGLUA
200
201 %{
202 #define SWIG_exception(a,b)\
203 { lua_pushfstring(L,"%s:%s",#a,b);SWIG_fail; }
204 %}
205
206 #endif // SWIGLUA
207
208 #ifdef SWIGD
209 %{
210 SWIGINTERN void SWIG_DThrowException(int code, const char *msg) {
211 SWIG_DExceptionCodes exception_code;
212 switch(code) {
213 case SWIG_IndexError:
214 exception_code = SWIG_DNoSuchElementException;
215 break;
216 case SWIG_IOError:
217 exception_code = SWIG_DIOException;
218 break;
219 case SWIG_ValueError:
220 exception_code = SWIG_DIllegalArgumentException;
221 break;
222 case SWIG_DivisionByZero:
223 case SWIG_MemoryError:
224 case SWIG_OverflowError:
225 case SWIG_RuntimeError:
226 case SWIG_TypeError:
227 case SWIG_SyntaxError:
228 case SWIG_SystemError:
229 case SWIG_UnknownError:
230 default:
231 exception_code = SWIG_DException;
232 break;
233 }
234 SWIG_DSetPendingException(exception_code, msg);
235 }
236 %}
237
238 #define SWIG_exception(code, msg)\
239 { SWIG_DThrowException(code, msg); return $null; }
240 #endif // SWIGD
241
242 #ifdef __cplusplus
243 /*
244 You can use the SWIG_CATCH_STDEXCEPT macro with the %exception
245 directive as follows:
246
247 %exception {
248 try {
249 $action
250 }
251 catch (my_except& e) {
252 ...
253 }
254 SWIG_CATCH_STDEXCEPT // catch std::exception
255 catch (...) {
256 SWIG_exception(SWIG_UnknownError, "Unknown exception");
257 }
258 }
259 */
260 %{
261 #include <stdexcept>
262 %}
263 %define SWIG_CATCH_STDEXCEPT
264 /* catching std::exception */
265 catch (std::invalid_argument& e) {
266 SWIG_exception(SWIG_ValueError, e.what() );
267 } catch (std::domain_error& e) {
268 SWIG_exception(SWIG_ValueError, e.what() );
269 } catch (std::overflow_error& e) {
270 SWIG_exception(SWIG_OverflowError, e.what() );
271 } catch (std::out_of_range& e) {
272 SWIG_exception(SWIG_IndexError, e.what() );
273 } catch (std::length_error& e) {
274 SWIG_exception(SWIG_IndexError, e.what() );
275 } catch (std::runtime_error& e) {
276 SWIG_exception(SWIG_RuntimeError, e.what() );
277 } catch (std::exception& e) {
278 SWIG_exception(SWIG_SystemError, e.what() );
279 }
280 %enddef
281 %define SWIG_CATCH_UNKNOWN
282 catch (std::exception& e) {
283 SWIG_exception(SWIG_SystemError, e.what() );
284 }
285 catch (...) {
286 SWIG_exception(SWIG_UnknownError, "unknown exception");
287 }
288 %enddef
289
290 /* rethrow the unknown exception */
291
292 #if defined(SWIGCSHARP) || defined(SWIGD)
293 %typemap(throws,noblock=1, canthrow=1) (...) {
294 SWIG_exception(SWIG_RuntimeError,"unknown exception");
295 }
296 #else
297 %typemap(throws,noblock=1) (...) {
298 SWIG_exception(SWIG_RuntimeError,"unknown exception");
299 }
300 #endif
301
302 #endif /* __cplusplus */
303
304 /* exception.i ends here */