?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winewayland.drv: Implement vkGetPhysicalDeviceSurfaceSupportKHR.
[wine.git] / dlls / msvcp90 / exception.c
blob01cb2bb5dab62773fa631c060225e5735c4339a0
1 /*
2 * Copyright 2010 Piotr Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <errno.h>
20 #include <stdarg.h>
21
22 #include "msvcp90.h"
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winternl.h"
26 #include "wine/debug.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(msvcp);
29
30 #define CXX_FRAME_MAGIC_VC6 0x19930520
31
32 CREATE_TYPE_INFO_VTABLE
33
34 #define CLASS_IS_SIMPLE_TYPE 1
35 #define CLASS_HAS_VIRTUAL_BASE_CLASS 4
36
37 int* __cdecl __processing_throw(void);
38
39 #if _MSVCP_VER >= 70 || defined(_MSVCIRT)
40 typedef const char **exception_name;
41 #define EXCEPTION_STR(name) (*name)
42 #define EXCEPTION_NAME(str) (&str)
43 #else
44 typedef const char *exception_name;
45 #define EXCEPTION_STR(name) (name)
46 #define EXCEPTION_NAME(str) (str)
47 #endif
48
49 void (CDECL *_Raise_handler)(const exception*) = NULL;
50
51 /* vtables */
52 extern const vtable_ptr exception_vtable;
53 /* ??_7bad_alloc@std@@6B@ */
54 extern const vtable_ptr bad_alloc_vtable;
55 /* ??_7logic_error@std@@6B@ */
56 extern const vtable_ptr logic_error_vtable;
57 /* ??_7length_error@std@@6B@ */
58 extern const vtable_ptr length_error_vtable;
59 /* ??_7out_of_range@std@@6B@ */
60 extern const vtable_ptr out_of_range_vtable;
61 extern const vtable_ptr invalid_argument_vtable;
62 /* ??_7runtime_error@std@@6B@ */
63 extern const vtable_ptr runtime_error_vtable;
64 extern const vtable_ptr _System_error_vtable;
65 extern const vtable_ptr system_error_vtable;
66 extern const vtable_ptr failure_vtable;
67 /* ??_7bad_cast@std@@6B@ */
68 extern const vtable_ptr bad_cast_vtable;
69 /* ??_7range_error@std@@6B@ */
70 extern const vtable_ptr range_error_vtable;
71 /* ??_7bad_function_call@std@@6B@ */
72 extern const vtable_ptr bad_function_call_vtable;
73
74 /* ??0exception@@QAE@ABQBD@Z */
75 /* ??0exception@@QEAA@AEBQEBD@Z */
76 DEFINE_THISCALL_WRAPPER(MSVCP_exception_ctor,8)
77 exception* __thiscall MSVCP_exception_ctor(exception *this, exception_name name)
78 {
79 TRACE("(%p %s)\n", this, EXCEPTION_STR(name));
80
81 this->vtable = &exception_vtable;
82 if(EXCEPTION_STR(name)) {
83 unsigned int name_len = strlen(EXCEPTION_STR(name)) + 1;
84 this->name = malloc(name_len);
85 memcpy(this->name, EXCEPTION_STR(name), name_len);
86 this->do_free = TRUE;
87 } else {
88 this->name = NULL;
89 this->do_free = FALSE;
90 }
91 return this;
92 }
93
94 DEFINE_THISCALL_WRAPPER(exception_copy_ctor,8)
95 exception* __thiscall exception_copy_ctor(exception *this, const exception *rhs)
96 {
97 TRACE("(%p,%p)\n", this, rhs);
98
99 if(!rhs->do_free) {
100 this->vtable = &exception_vtable;
101 this->name = rhs->name;
102 this->do_free = FALSE;
103 } else
104 MSVCP_exception_ctor(this, (exception_name)EXCEPTION_NAME(rhs->name));
105 TRACE("name = %s\n", this->name);
106 return this;
107 }
108
109 /* ??0exception@@QAE@XZ */
110 /* ??0exception@@QEAA@XZ */
111 DEFINE_THISCALL_WRAPPER(MSVCP_exception_default_ctor,4)
112 exception* __thiscall MSVCP_exception_default_ctor(exception *this)
113 {
114 TRACE("(%p)\n", this);
115 this->vtable = &exception_vtable;
116 this->name = NULL;
117 this->do_free = FALSE;
118 return this;
119 }
120
121 DEFINE_THISCALL_WRAPPER(MSVCP_exception_dtor,4)
122 void __thiscall MSVCP_exception_dtor(exception *this)
123 {
124 TRACE("(%p)\n", this);
125 this->vtable = &exception_vtable;
126 if(this->do_free)
127 free(this->name);
128 }
129
130 DEFINE_THISCALL_WRAPPER(MSVCP_exception_vector_dtor, 8)
131 void * __thiscall MSVCP_exception_vector_dtor(exception *this, unsigned int flags)
132 {
133 TRACE("%p %x\n", this, flags);
134 if(flags & 2) {
135 /* we have an array, with the number of elements stored before the first object */
136 INT_PTR i, *ptr = (INT_PTR *)this-1;
137
138 for(i=*ptr-1; i>=0; i--)
139 MSVCP_exception_dtor(this+i);
140 operator_delete(ptr);
141 } else {
142 MSVCP_exception_dtor(this);
143 if(flags & 1)
144 operator_delete(this);
145 }
146
147 return this;
148 }
149
150 /* ??_Gexception@@UAEPAXI@Z */
151 DEFINE_THISCALL_WRAPPER(MSVCP_exception_scalar_dtor, 8)
152 void * __thiscall MSVCP_exception_scalar_dtor(exception *this, unsigned int flags)
153 {
154 TRACE("(%p %x)\n", this, flags);
155 MSVCP_exception_dtor(this);
156 if (flags & 1) operator_delete(this);
157 return this;
158 }
159
160 /* ??4exception@@QAEAAV0@ABV0@@Z */
161 /* ??4exception@@QEAAAEAV0@AEBV0@@Z */
162 DEFINE_THISCALL_WRAPPER(MSVCP_exception_assign, 8)
163 exception* __thiscall MSVCP_exception_assign(exception *this, const exception *assign)
164 {
165 MSVCP_exception_dtor(this);
166 return exception_copy_ctor(this, assign);
167 }
168
169 /* ?_Doraise@bad_alloc@std@@MBEXXZ */
170 /* ?_Doraise@bad_alloc@std@@MEBAXXZ */
171 /* ?_Doraise@logic_error@std@@MBEXXZ */
172 /* ?_Doraise@logic_error@std@@MEBAXXZ */
173 /* ?_Doraise@length_error@std@@MBEXXZ */
174 /* ?_Doraise@length_error@std@@MEBAXXZ */
175 /* ?_Doraise@out_of_range@std@@MBEXXZ */
176 /* ?_Doraise@out_of_range@std@@MEBAXXZ */
177 /* ?_Doraise@runtime_error@std@@MBEXXZ */
178 /* ?_Doraise@runtime_error@std@@MEBAXXZ */
179 /* ?_Doraise@bad_cast@std@@MBEXXZ */
180 /* ?_Doraise@bad_cast@std@@MEBAXXZ */
181 /* ?_Doraise@range_error@std@@MBEXXZ */
182 /* ?_Doraise@range_error@std@@MEBAXXZ */
183 DEFINE_THISCALL_WRAPPER(MSVCP_exception__Doraise, 4)
184 void __thiscall MSVCP_exception__Doraise(exception *this)
185 {
186 FIXME("(%p) stub\n", this);
187 }
188
189 DEFINE_THISCALL_WRAPPER(MSVCP_exception_what,4)
190 const char* __thiscall MSVCP_exception_what(exception * this)
191 {
192 TRACE("(%p) returning %s\n", this, this->name);
193 return this->name ? this->name : "Unknown exception";
194 }
195
196 #if _MSVCP_VER >= 80
197 DEFINE_RTTI_DATA0(exception, 0, ".?AVexception@std@@")
198 #else
199 DEFINE_RTTI_DATA0(exception, 0, ".?AVexception@@")
200 #endif
201 DEFINE_CXX_DATA0(exception, MSVCP_exception_dtor)
202
203 /* bad_alloc class data */
204 typedef exception bad_alloc;
205
206 /* ??0bad_alloc@std@@QAE@PBD@Z */
207 /* ??0bad_alloc@std@@QEAA@PEBD@Z */
208 DEFINE_THISCALL_WRAPPER(MSVCP_bad_alloc_ctor, 8)
209 bad_alloc* __thiscall MSVCP_bad_alloc_ctor(bad_alloc *this, exception_name name)
210 {
211 TRACE("%p %s\n", this, EXCEPTION_STR(name));
212 MSVCP_exception_ctor(this, name);
213 this->vtable = &bad_alloc_vtable;
214 return this;
215 }
216
217 /* ??0bad_alloc@std@@QAE@XZ */
218 /* ??0bad_alloc@std@@QEAA@XZ */
219 DEFINE_THISCALL_WRAPPER(MSVCP_bad_alloc_default_ctor, 4)
220 bad_alloc* __thiscall MSVCP_bad_alloc_default_ctor(bad_alloc *this)
221 {
222 static const char *name = "bad allocation";
223 return MSVCP_bad_alloc_ctor(this, EXCEPTION_NAME(name));
224 }
225
226 /* ??0bad_alloc@std@@QAE@ABV01@@Z */
227 /* ??0bad_alloc@std@@QEAA@AEBV01@@Z */
228 DEFINE_THISCALL_WRAPPER(bad_alloc_copy_ctor, 8)
229 bad_alloc* __thiscall bad_alloc_copy_ctor(bad_alloc *this, const bad_alloc *rhs)
230 {
231 TRACE("%p %p\n", this, rhs);
232 exception_copy_ctor(this, rhs);
233 this->vtable = &bad_alloc_vtable;
234 return this;
235 }
236
237 /* ??1bad_alloc@std@@UAE@XZ */
238 /* ??1bad_alloc@std@@UEAA@XZ */
239 DEFINE_THISCALL_WRAPPER(MSVCP_bad_alloc_dtor, 4)
240 void __thiscall MSVCP_bad_alloc_dtor(bad_alloc *this)
241 {
242 TRACE("%p\n", this);
243 MSVCP_exception_dtor(this);
244 }
245
246 DEFINE_THISCALL_WRAPPER(MSVCP_bad_alloc_vector_dtor, 8)
247 void * __thiscall MSVCP_bad_alloc_vector_dtor(bad_alloc *this, unsigned int flags)
248 {
249 TRACE("%p %x\n", this, flags);
250 if(flags & 2) {
251 /* we have an array, with the number of elements stored before the first object */
252 INT_PTR i, *ptr = (INT_PTR *)this-1;
253
254 for(i=*ptr-1; i>=0; i--)
255 MSVCP_bad_alloc_dtor(this+i);
256 operator_delete(ptr);
257 } else {
258 MSVCP_bad_alloc_dtor(this);
259 if(flags & 1)
260 operator_delete(this);
261 }
262
263 return this;
264 }
265
266 /* ??4bad_alloc@std@@QAEAAV01@ABV01@@Z */
267 /* ??4bad_alloc@std@@QEAAAEAV01@AEBV01@@Z */
268 DEFINE_THISCALL_WRAPPER(MSVCP_bad_alloc_assign, 8)
269 bad_alloc* __thiscall MSVCP_bad_alloc_assign(bad_alloc *this, const bad_alloc *assign)
270 {
271 MSVCP_bad_alloc_dtor(this);
272 return bad_alloc_copy_ctor(this, assign);
273 }
274
275 DEFINE_RTTI_DATA1(bad_alloc, 0, &exception_rtti_base_descriptor, ".?AVbad_alloc@std@@")
276 DEFINE_CXX_DATA1(bad_alloc, &exception_cxx_type_info, MSVCP_bad_alloc_dtor)
277
278 /* logic_error class data */
279 typedef struct {
280 exception e;
281 #if _MSVCP_VER <= 90 && !defined _MSVCIRT
282 basic_string_char str;
283 #endif
284 } logic_error;
285
286 /* ??0logic_error@@QAE@ABQBD@Z */
287 /* ??0logic_error@@QEAA@AEBQEBD@Z */
288 DEFINE_THISCALL_WRAPPER(MSVCP_logic_error_ctor, 8)
289 logic_error* __thiscall MSVCP_logic_error_ctor( logic_error *this, exception_name name )
290 {
291 TRACE("%p %s\n", this, EXCEPTION_STR(name));
292 #if _MSVCP_VER <= 90 && !defined _MSVCIRT
293 #if _MSVCP_VER == 60
294 MSVCP_exception_ctor(&this->e, "");
295 #else
296 MSVCP_exception_default_ctor(&this->e);
297 #endif
298 MSVCP_basic_string_char_ctor_cstr(&this->str, EXCEPTION_STR(name));
299 #else
300 MSVCP_exception_ctor(&this->e, name);
301 #endif
302 this->e.vtable = &logic_error_vtable;
303 return this;
304 }
305
306 /* ??0logic_error@std@@QAE@ABV01@@Z */
307 /* ??0logic_error@std@@QEAA@AEBV01@@Z */
308 DEFINE_THISCALL_WRAPPER(logic_error_copy_ctor, 8)
309 logic_error* __thiscall logic_error_copy_ctor(
310 logic_error *this, const logic_error *rhs)
311 {
312 TRACE("%p %p\n", this, rhs);
313 exception_copy_ctor(&this->e, &rhs->e);
314 #if _MSVCP_VER <= 90 && !defined _MSVCIRT
315 MSVCP_basic_string_char_copy_ctor(&this->str, &rhs->str);
316 #endif
317 this->e.vtable = &logic_error_vtable;
318 return this;
319 }
320
321 /* ??0logic_error@std@@QAE@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@1@@Z */
322 /* ??0logic_error@std@@QEAA@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@1@@Z */
323 #ifndef _MSVCIRT
324 DEFINE_THISCALL_WRAPPER(MSVCP_logic_error_ctor_bstr, 8)
325 logic_error* __thiscall MSVCP_logic_error_ctor_bstr(logic_error *this, const basic_string_char *str)
326 {
327 const char *name = MSVCP_basic_string_char_c_str(str);
328 TRACE("(%p %p %s)\n", this, str, name);
329 return MSVCP_logic_error_ctor(this, EXCEPTION_NAME(name));
330 }
331 #endif
332
333 /* ??1logic_error@std@@UAE@XZ */
334 /* ??1logic_error@std@@UEAA@XZ */
335 /* ??1length_error@std@@UAE@XZ */
336 /* ??1length_error@std@@UEAA@XZ */
337 /* ??1out_of_range@std@@UAE@XZ */
338 /* ??1out_of_range@std@@UEAA@XZ */
339 DEFINE_THISCALL_WRAPPER(MSVCP_logic_error_dtor, 4)
340 void __thiscall MSVCP_logic_error_dtor(logic_error *this)
341 {
342 TRACE("%p\n", this);
343 MSVCP_exception_dtor(&this->e);
344 #if _MSVCP_VER <= 90 && !defined _MSVCIRT
345 MSVCP_basic_string_char_dtor(&this->str);
346 #endif
347 }
348
349 DEFINE_THISCALL_WRAPPER(MSVCP_logic_error_vector_dtor, 8)
350 void* __thiscall MSVCP_logic_error_vector_dtor(
351 logic_error *this, unsigned int flags)
352 {
353 TRACE("%p %x\n", this, flags);
354 if(flags & 2) {
355 /* we have an array, with the number of elements stored before the first object */
356 INT_PTR i, *ptr = (INT_PTR *)this-1;
357
358 for(i=*ptr-1; i>=0; i--)
359 MSVCP_logic_error_dtor(this+i);
360 operator_delete(ptr);
361 } else {
362 MSVCP_logic_error_dtor(this);
363 if(flags & 1)
364 operator_delete(this);
365 }
366
367 return this;
368 }
369
370 /* ??_Glogic_error@@UAEPAXI@Z */
371 DEFINE_THISCALL_WRAPPER(MSVCP_logic_error_scalar_dtor, 8)
372 void * __thiscall MSVCP_logic_error_scalar_dtor(logic_error *this, unsigned int flags)
373 {
374 TRACE("(%p %x)\n", this, flags);
375 MSVCP_logic_error_dtor(this);
376 if (flags & 1) operator_delete(this);
377 return this;
378 }
379
380 /* ??4logic_error@std@@QAEAAV01@ABV01@@Z */
381 /* ??4logic_error@std@@QEAAAEAV01@AEBV01@@Z */
382 DEFINE_THISCALL_WRAPPER(MSVCP_logic_error_assign, 8)
383 logic_error* __thiscall MSVCP_logic_error_assign(logic_error *this, const logic_error *assign)
384 {
385 MSVCP_logic_error_dtor(this);
386 return logic_error_copy_ctor(this, assign);
387 }
388
389 /* ?what@logic_error@std@@UBEPBDXZ */
390 /* ?what@logic_error@std@@UEBAPEBDXZ */
391 DEFINE_THISCALL_WRAPPER(MSVCP_logic_error_what, 4)
392 const char* __thiscall MSVCP_logic_error_what(logic_error *this)
393 {
394 TRACE("%p\n", this);
395 #if _MSVCP_VER > 90 || defined _MSVCIRT
396 return MSVCP_exception_what( &this->e );
397 #else
398 return MSVCP_basic_string_char_c_str(&this->str);
399 #endif
400 }
401
402 #if _MSVCP_VER >= 80
403 DEFINE_RTTI_DATA1(logic_error, 0, &exception_rtti_base_descriptor, ".?AVlogic_error@std@@")
404 #else
405 DEFINE_RTTI_DATA1(logic_error, 0, &exception_rtti_base_descriptor, ".?AVlogic_error@@")
406 #endif
407 DEFINE_CXX_TYPE_INFO(logic_error)
408
409 /* length_error class data */
410 typedef logic_error length_error;
411
412 static length_error* MSVCP_length_error_ctor( length_error *this, exception_name name )
413 {
414 TRACE("%p %s\n", this, EXCEPTION_STR(name));
415 MSVCP_logic_error_ctor(this, name);
416 this->e.vtable = &length_error_vtable;
417 return this;
418 }
419
420 /* ??0length_error@std@@QAE@ABV01@@Z */
421 /* ??0length_error@std@@QEAA@AEBV01@@Z */
422 DEFINE_THISCALL_WRAPPER(length_error_copy_ctor, 8)
423 length_error* __thiscall length_error_copy_ctor(
424 length_error *this, const length_error *rhs)
425 {
426 TRACE("%p %p\n", this, rhs);
427 logic_error_copy_ctor(this, rhs);
428 this->e.vtable = &length_error_vtable;
429 return this;
430 }
431
432 /* ??0length_error@std@@QAE@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@1@@Z */
433 /* ??0length_error@std@@QEAA@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@1@@Z */
434 #ifndef _MSVCIRT
435 DEFINE_THISCALL_WRAPPER(MSVCP_length_error_ctor_bstr, 8)
436 length_error* __thiscall MSVCP_length_error_ctor_bstr(length_error *this, const basic_string_char *str)
437 {
438 const char *name = MSVCP_basic_string_char_c_str(str);
439 TRACE("(%p %p %s)\n", this, str, name);
440 return MSVCP_length_error_ctor(this, EXCEPTION_NAME(name));
441 }
442 #endif
443
444 /* ??4length_error@std@@QAEAAV01@ABV01@@Z */
445 /* ??4length_error@std@@QEAAAEAV01@AEBV01@@Z */
446 DEFINE_THISCALL_WRAPPER(MSVCP_length_error_assign, 8)
447 length_error* __thiscall MSVCP_length_error_assign(length_error *this, const length_error *assign)
448 {
449 MSVCP_logic_error_dtor(this);
450 return length_error_copy_ctor(this, assign);
451 }
452
453 DEFINE_RTTI_DATA2(length_error, 0, &logic_error_rtti_base_descriptor, &exception_rtti_base_descriptor, ".?AVlength_error@std@@")
454 DEFINE_CXX_DATA2(length_error, &logic_error_cxx_type_info, &exception_cxx_type_info, MSVCP_logic_error_dtor)
455
456 /* out_of_range class data */
457 typedef logic_error out_of_range;
458
459 static out_of_range* MSVCP_out_of_range_ctor( out_of_range *this, exception_name name )
460 {
461 TRACE("%p %s\n", this, EXCEPTION_STR(name));
462 MSVCP_logic_error_ctor(this, name);
463 this->e.vtable = &out_of_range_vtable;
464 return this;
465 }
466
467 /* ??0out_of_range@std@@QAE@ABV01@@Z */
468 /* ??0out_of_range@std@@QEAA@AEBV01@@Z */
469 DEFINE_THISCALL_WRAPPER(out_of_range_copy_ctor, 8)
470 out_of_range* __thiscall out_of_range_copy_ctor(
471 out_of_range *this, const out_of_range *rhs)
472 {
473 TRACE("%p %p\n", this, rhs);
474 logic_error_copy_ctor(this, rhs);
475 this->e.vtable = &out_of_range_vtable;
476 return this;
477 }
478
479 /* ??0out_of_range@std@@QAE@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@1@@Z */
480 /* ??0out_of_range@std@@QEAA@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@1@@Z */
481 #ifndef _MSVCIRT
482 DEFINE_THISCALL_WRAPPER(MSVCP_out_of_range_ctor_bstr, 8)
483 out_of_range* __thiscall MSVCP_out_of_range_ctor_bstr(out_of_range *this, const basic_string_char *str)
484 {
485 const char *name = MSVCP_basic_string_char_c_str(str);
486 TRACE("(%p %p %s)\n", this, str, name);
487 return MSVCP_out_of_range_ctor(this, EXCEPTION_NAME(name));
488 }
489 #endif
490
491 /* ??4out_of_range@std@@QAEAAV01@ABV01@@Z */
492 /* ??4out_of_range@std@@QEAAAEAV01@AEBV01@@Z */
493 DEFINE_THISCALL_WRAPPER(MSVCP_out_of_range_assign, 8)
494 out_of_range* __thiscall MSVCP_out_of_range_assign(out_of_range *this, const out_of_range *assign)
495 {
496 MSVCP_logic_error_dtor(this);
497 return out_of_range_copy_ctor(this, assign);
498 }
499
500 DEFINE_RTTI_DATA2(out_of_range, 0, &logic_error_rtti_base_descriptor, &exception_rtti_base_descriptor, ".?AVout_of_range@std@@")
501 DEFINE_CXX_DATA2(out_of_range, &logic_error_cxx_type_info, &exception_cxx_type_info, MSVCP_logic_error_dtor)
502
503 /* invalid_argument class data */
504 typedef logic_error invalid_argument;
505
506 static invalid_argument* MSVCP_invalid_argument_ctor( invalid_argument *this, exception_name name )
507 {
508 TRACE("%p %s\n", this, EXCEPTION_STR(name));
509 MSVCP_logic_error_ctor(this, name);
510 this->e.vtable = &invalid_argument_vtable;
511 return this;
512 }
513
514 DEFINE_THISCALL_WRAPPER(invalid_argument_copy_ctor, 8)
515 invalid_argument* __thiscall invalid_argument_copy_ctor(
516 invalid_argument *this, invalid_argument *rhs)
517 {
518 TRACE("%p %p\n", this, rhs);
519 logic_error_copy_ctor(this, rhs);
520 this->e.vtable = &invalid_argument_vtable;
521 return this;
522 }
523
524 DEFINE_RTTI_DATA2(invalid_argument, 0, &logic_error_rtti_base_descriptor, &exception_rtti_base_descriptor, ".?AVinvalid_argument@std@@")
525 DEFINE_CXX_DATA2(invalid_argument, &logic_error_cxx_type_info, &exception_cxx_type_info, MSVCP_logic_error_dtor)
526
527 /* runtime_error class data */
528 typedef struct {
529 exception e;
530 #if _MSVCP_VER <= 90 && !defined _MSVCIRT
531 basic_string_char str;
532 #endif
533 } runtime_error;
534
535 static runtime_error* MSVCP_runtime_error_ctor( runtime_error *this, exception_name name )
536 {
537 TRACE("%p %s\n", this, EXCEPTION_STR(name));
538 #if _MSVCP_VER <= 90 && !defined _MSVCIRT
539 #if _MSVCP_VER == 60
540 MSVCP_exception_ctor(&this->e, "");
541 #else
542 MSVCP_exception_default_ctor(&this->e);
543 #endif
544 MSVCP_basic_string_char_ctor_cstr(&this->str, EXCEPTION_STR(name));
545 #else
546 MSVCP_exception_ctor(&this->e, name);
547 #endif
548 this->e.vtable = &runtime_error_vtable;
549 return this;
550 }
551
552 /* ??0runtime_error@std@@QAE@ABV01@@Z */
553 /* ??0runtime_error@std@@QEAA@AEBV01@@Z */
554 DEFINE_THISCALL_WRAPPER(runtime_error_copy_ctor, 8)
555 runtime_error* __thiscall runtime_error_copy_ctor(
556 runtime_error *this, const runtime_error *rhs)
557 {
558 TRACE("%p %p\n", this, rhs);
559 exception_copy_ctor(&this->e, &rhs->e);
560 #if _MSVCP_VER <= 90 && !defined _MSVCIRT
561 MSVCP_basic_string_char_copy_ctor(&this->str, &rhs->str);
562 #endif
563 this->e.vtable = &runtime_error_vtable;
564 return this;
565 }
566
567 /* ??0runtime_error@std@@QAE@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@1@@Z */
568 /* ??0runtime_error@std@@QEAA@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@1@@Z */
569 #ifndef _MSVCIRT
570 DEFINE_THISCALL_WRAPPER(MSVCP_runtime_error_ctor_bstr, 8)
571 runtime_error* __thiscall MSVCP_runtime_error_ctor_bstr(runtime_error *this, const basic_string_char *str)
572 {
573 const char *name = MSVCP_basic_string_char_c_str(str);
574 TRACE("(%p %p %s)\n", this, str, name);
575 return MSVCP_runtime_error_ctor(this, EXCEPTION_NAME(name));
576 }
577 #endif
578
579 /* ??1runtime_error@std@@UAE@XZ */
580 /* ??1runtime_error@std@@UEAA@XZ */
581 /* ??1range_error@std@@UAE@XZ */
582 /* ??1range_error@std@@UEAA@XZ */
583 DEFINE_THISCALL_WRAPPER(MSVCP_runtime_error_dtor, 4)
584 void __thiscall MSVCP_runtime_error_dtor(runtime_error *this)
585 {
586 TRACE("%p\n", this);
587 MSVCP_exception_dtor(&this->e);
588 #if _MSVCP_VER <= 90 && !defined _MSVCIRT
589 MSVCP_basic_string_char_dtor(&this->str);
590 #endif
591 }
592
593 DEFINE_THISCALL_WRAPPER(MSVCP_runtime_error_vector_dtor, 8)
594 void* __thiscall MSVCP_runtime_error_vector_dtor(
595 runtime_error *this, unsigned int flags)
596 {
597 TRACE("%p %x\n", this, flags);
598 if(flags & 2) {
599 /* we have an array, with the number of elements stored before the first object */
600 INT_PTR i, *ptr = (INT_PTR *)this-1;
601
602 for(i=*ptr-1; i>=0; i--)
603 MSVCP_runtime_error_dtor(this+i);
604 operator_delete(ptr);
605 } else {
606 MSVCP_runtime_error_dtor(this);
607 if(flags & 1)
608 operator_delete(this);
609 }
610
611 return this;
612 }
613
614 /* ??4runtime_error@std@@QAEAAV01@ABV01@@Z */
615 /* ??4runtime_error@std@@QEAAAEAV01@AEBV01@@Z */
616 DEFINE_THISCALL_WRAPPER(MSVCP_runtime_error_assign, 8)
617 runtime_error* __thiscall MSVCP_runtime_error_assign(runtime_error *this, const runtime_error *assign)
618 {
619 MSVCP_runtime_error_dtor(this);
620 return runtime_error_copy_ctor(this, assign);
621 }
622
623 /* ?what@runtime_error@std@@UBEPBDXZ */
624 /* ?what@runtime_error@std@@UEBAPEBDXZ */
625 DEFINE_THISCALL_WRAPPER(MSVCP_runtime_error_what, 4)
626 const char* __thiscall MSVCP_runtime_error_what(runtime_error *this)
627 {
628 TRACE("%p\n", this);
629 #if _MSVCP_VER > 90 || defined _MSVCIRT
630 return MSVCP_exception_what( &this->e );
631 #else
632 return MSVCP_basic_string_char_c_str(&this->str);
633 #endif
634 }
635
636 DEFINE_RTTI_DATA1(runtime_error, 0, &exception_rtti_base_descriptor, ".?AVruntime_error@std@@")
637 DEFINE_CXX_DATA1(runtime_error, &exception_cxx_type_info, MSVCP_runtime_error_dtor)
638
639 /* failure class data */
640 typedef struct {
641 runtime_error base;
642 #if _MSVCP_VER > 90
643 error_code code;
644 #endif
645 } system_error;
646 typedef system_error _System_error;
647 typedef system_error failure;
648
649 static failure* MSVCP_failure_ctor( failure *this, exception_name name )
650 {
651 TRACE("%p %s\n", this, EXCEPTION_STR(name));
652 MSVCP_runtime_error_ctor(&this->base, name);
653 #if _MSVCP_VER > 90
654 this->code.code = 1;
655 this->code.category = std_iostream_category();
656 #endif
657 this->base.e.vtable = &failure_vtable;
658 return this;
659 }
660
661 DEFINE_THISCALL_WRAPPER(failure_copy_ctor, 8)
662 failure* __thiscall failure_copy_ctor(
663 failure *this, failure *rhs)
664 {
665 TRACE("%p %p\n", this, rhs);
666 runtime_error_copy_ctor(&this->base, &rhs->base);
667 #if _MSVCP_VER > 90
668 this->code = rhs->code;
669 #endif
670 this->base.e.vtable = &failure_vtable;
671 return this;
672 }
673
674 DEFINE_THISCALL_WRAPPER(MSVCP_failure_dtor, 4)
675 void __thiscall MSVCP_failure_dtor(failure *this)
676 {
677 TRACE("%p\n", this);
678 MSVCP_runtime_error_dtor(&this->base);
679 }
680
681 DEFINE_THISCALL_WRAPPER(MSVCP_failure_vector_dtor, 8)
682 void* __thiscall MSVCP_failure_vector_dtor(
683 failure *this, unsigned int flags)
684 {
685 TRACE("%p %x\n", this, flags);
686 return MSVCP_runtime_error_vector_dtor(&this->base, flags);
687 }
688
689 DEFINE_THISCALL_WRAPPER(MSVCP_failure_what, 4)
690 const char* __thiscall MSVCP_failure_what(failure *this)
691 {
692 TRACE("%p\n", this);
693 return MSVCP_runtime_error_what(&this->base);
694 }
695
696 #if _MSVCP_VER > 90
697 DEFINE_THISCALL_WRAPPER(system_error_copy_ctor, 8)
698 system_error* __thiscall system_error_copy_ctor(
699 system_error *this, system_error *rhs)
700 {
701 failure_copy_ctor(this, rhs);
702 this->base.e.vtable = &system_error_vtable;
703 return this;
704 }
705 #endif
706
707 #if _MSVCP_VER > 110
708 DEFINE_THISCALL_WRAPPER(_System_error_copy_ctor, 8)
709 _System_error* __thiscall _System_error_copy_ctor(
710 _System_error *this, _System_error *rhs)
711 {
712 failure_copy_ctor(this, rhs);
713 this->base.e.vtable = &_System_error_vtable;
714 return this;
715 }
716 #endif
717
718 #if _MSVCP_VER > 110
719 DEFINE_RTTI_DATA2(_System_error, 0, &runtime_error_rtti_base_descriptor,
720 &exception_rtti_base_descriptor, ".?AV_System_error@std@@")
721 DEFINE_RTTI_DATA3(system_error, 0, &_System_error_rtti_base_descriptor,
722 &runtime_error_rtti_base_descriptor, &exception_rtti_base_descriptor,
723 ".?AVsystem_error@std@@")
724 DEFINE_RTTI_DATA4(failure, 0, &system_error_rtti_base_descriptor,
725 &_System_error_rtti_base_descriptor, &runtime_error_rtti_base_descriptor,
726 &exception_rtti_base_descriptor, ".?AVfailure@ios_base@std@@")
727 DEFINE_CXX_TYPE_INFO(_System_error)
728 DEFINE_CXX_DATA3(system_error, &_System_error_cxx_type_info,
729 &runtime_error_cxx_type_info, &exception_cxx_type_info,
730 MSVCP_runtime_error_dtor)
731 DEFINE_CXX_DATA4(failure, &system_error_cxx_type_info,
732 &_System_error_cxx_type_info, &runtime_error_cxx_type_info,
733 &exception_cxx_type_info, MSVCP_runtime_error_dtor)
734 #elif _MSVCP_VER > 90
735 DEFINE_RTTI_DATA2(system_error, 0, &runtime_error_rtti_base_descriptor,
736 &exception_rtti_base_descriptor, ".?AVsystem_error@std@@")
737 DEFINE_RTTI_DATA3(failure, 0, &system_error_rtti_base_descriptor,
738 &runtime_error_rtti_base_descriptor, &exception_rtti_base_descriptor,
739 ".?AVfailure@ios_base@std@@")
740 #if _MSVCP_VER == 100
741 DEFINE_CXX_TYPE_INFO(system_error);
742 #else
743 DEFINE_CXX_DATA2(system_error, &runtime_error_cxx_type_info,
744 &exception_cxx_type_info, MSVCP_runtime_error_dtor)
745 #endif
746 DEFINE_CXX_DATA3(failure, &system_error_cxx_type_info, &runtime_error_cxx_type_info,
747 &exception_cxx_type_info, MSVCP_runtime_error_dtor)
748 #else
749 DEFINE_RTTI_DATA2(failure, 0, &runtime_error_rtti_base_descriptor,
750 &exception_rtti_base_descriptor, ".?AVfailure@ios_base@std@@")
751 DEFINE_CXX_DATA2(failure, &runtime_error_cxx_type_info,
752 &exception_cxx_type_info, MSVCP_runtime_error_dtor)
753 #endif
754
755 /* bad_cast class data */
756 typedef exception bad_cast;
757
758 /* ??0bad_cast@std@@QAE@PBD@Z */
759 /* ??0bad_cast@std@@QEAA@PEBD@Z */
760 DEFINE_THISCALL_WRAPPER(MSVCP_bad_cast_ctor, 8)
761 bad_cast* __thiscall MSVCP_bad_cast_ctor(bad_cast *this, const char *name)
762 {
763 TRACE("%p %s\n", this, name);
764 MSVCP_exception_ctor(this, EXCEPTION_NAME(name));
765 this->vtable = &bad_cast_vtable;
766 return this;
767 }
768
769 /* ??_Fbad_cast@@QAEXXZ */
770 /* ??_Fbad_cast@std@@QEAAXXZ */
771 DEFINE_THISCALL_WRAPPER(MSVCP_bad_cast_default_ctor,4)
772 bad_cast* __thiscall MSVCP_bad_cast_default_ctor(bad_cast *this)
773 {
774 return MSVCP_bad_cast_ctor(this, "bad cast");
775 }
776
777 /* ??0bad_cast@std@@QAE@ABV01@@Z */
778 /* ??0bad_cast@std@@QEAA@AEBV01@@Z */
779 DEFINE_THISCALL_WRAPPER(bad_cast_copy_ctor, 8)
780 bad_cast* __thiscall bad_cast_copy_ctor(bad_cast *this, const bad_cast *rhs)
781 {
782 TRACE("%p %p\n", this, rhs);
783 exception_copy_ctor(this, rhs);
784 this->vtable = &bad_cast_vtable;
785 return this;
786 }
787
788 /* ??1bad_cast@@UAE@XZ */
789 /* ??1bad_cast@std@@UEAA@XZ */
790 DEFINE_THISCALL_WRAPPER(MSVCP_bad_cast_dtor, 4)
791 void __thiscall MSVCP_bad_cast_dtor(bad_cast *this)
792 {
793 TRACE("%p\n", this);
794 MSVCP_exception_dtor(this);
795 }
796
797 DEFINE_THISCALL_WRAPPER(MSVCP_bad_cast_vector_dtor, 8)
798 void * __thiscall MSVCP_bad_cast_vector_dtor(bad_cast *this, unsigned int flags)
799 {
800 TRACE("%p %x\n", this, flags);
801 if(flags & 2) {
802 /* we have an array, with the number of elements stored before the first object */
803 INT_PTR i, *ptr = (INT_PTR *)this-1;
804
805 for(i=*ptr-1; i>=0; i--)
806 MSVCP_bad_cast_dtor(this+i);
807 operator_delete(ptr);
808 } else {
809 MSVCP_bad_cast_dtor(this);
810 if(flags & 1)
811 operator_delete(this);
812 }
813
814 return this;
815 }
816
817 /* ??4bad_cast@std@@QAEAAV01@ABV01@@Z */
818 /* ??4bad_cast@std@@QEAAAEAV01@AEBV01@@Z */
819 DEFINE_THISCALL_WRAPPER(MSVCP_bad_cast_opequals, 8)
820 bad_cast* __thiscall MSVCP_bad_cast_opequals(bad_cast *this, const bad_cast *rhs)
821 {
822 TRACE("(%p %p)\n", this, rhs);
823
824 if(this != rhs) {
825 MSVCP_exception_dtor(this);
826 exception_copy_ctor(this, rhs);
827 }
828 return this;
829 }
830
831 DEFINE_RTTI_DATA1(bad_cast, 0, &exception_rtti_base_descriptor, ".?AVbad_cast@std@@")
832
833 /* range_error class data */
834 typedef runtime_error range_error;
835
836 static range_error* MSVCP_range_error_ctor( range_error *this, exception_name name )
837 {
838 TRACE("%p %s\n", this, EXCEPTION_STR(name));
839 MSVCP_runtime_error_ctor(this, name);
840 this->e.vtable = &range_error_vtable;
841 return this;
842 }
843
844 /* ??0range_error@std@@QAE@ABV01@@Z */
845 /* ??0range_error@std@@QEAA@AEBV01@@Z */
846 DEFINE_THISCALL_WRAPPER(range_error_copy_ctor, 8)
847 range_error* __thiscall range_error_copy_ctor(
848 range_error *this, const range_error *rhs)
849 {
850 TRACE("%p %p\n", this, rhs);
851 runtime_error_copy_ctor(this, rhs);
852 this->e.vtable = &range_error_vtable;
853 return this;
854 }
855
856 /* ??0range_error@std@@QAE@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@1@@Z */
857 /* ??0range_error@std@@QEAA@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@1@@Z */
858 #ifndef _MSVCIRT
859 DEFINE_THISCALL_WRAPPER(MSVCP_range_error_ctor_bstr, 8)
860 range_error* __thiscall MSVCP_range_error_ctor_bstr(range_error *this, const basic_string_char *str)
861 {
862 const char *name = MSVCP_basic_string_char_c_str(str);
863 TRACE("(%p %p %s)\n", this, str, name);
864 return MSVCP_range_error_ctor(this, EXCEPTION_NAME(name));
865 }
866 #endif
867
868 /* ??4range_error@std@@QAEAAV01@ABV01@@Z */
869 /* ??4range_error@std@@QEAAAEAV01@AEBV01@@Z */
870 DEFINE_THISCALL_WRAPPER(MSVCP_range_error_assign, 8)
871 range_error* __thiscall MSVCP_range_error_assign(range_error *this, const range_error *assign)
872 {
873 MSVCP_runtime_error_dtor(this);
874 return range_error_copy_ctor(this, assign);
875 }
876
877 DEFINE_RTTI_DATA2(range_error, 0, &runtime_error_rtti_base_descriptor, &exception_rtti_base_descriptor, ".?AVrange_error@std@@")
878 DEFINE_CXX_DATA2(range_error, &runtime_error_cxx_type_info, &exception_cxx_type_info, MSVCP_runtime_error_dtor)
879
880 #if _MSVCP_VER > 90
881 /* bad_function_call class data */
882 typedef exception bad_function_call;
883
884 static bad_function_call* MSVCP_bad_function_call_ctor(bad_function_call *this)
885 {
886 static const char *name = "bad function call";
887
888 TRACE("%p\n", this);
889 MSVCP_exception_ctor(this, EXCEPTION_NAME(name));
890 this->vtable = &bad_function_call_vtable;
891 return this;
892 }
893
894 DEFINE_THISCALL_WRAPPER(bad_function_call_copy_ctor, 8)
895 bad_function_call* __thiscall bad_function_call_copy_ctor(bad_function_call *this, const bad_function_call *rhs)
896 {
897 TRACE("%p %p\n", this, rhs);
898 exception_copy_ctor(this, rhs);
899 this->vtable = &bad_function_call_vtable;
900 return this;
901 }
902
903 DEFINE_RTTI_DATA1(bad_function_call, 0, &exception_rtti_base_descriptor, ".?AVbad_function_call@std@@")
904 DEFINE_CXX_DATA1(bad_function_call, &exception_cxx_type_info, MSVCP_exception_dtor)
905 #endif
906
907 /* ?_Nomemory@std@@YAXXZ */
908 void __cdecl DECLSPEC_NORETURN _Nomemory(void)
909 {
910 bad_alloc e;
911
912 TRACE("()\n");
913
914 MSVCP_bad_alloc_default_ctor(&e);
915 _CxxThrowException(&e, &bad_alloc_cxx_type);
916 }
917
918 /* ?_Xmem@tr1@std@@YAXXZ */
919 void __cdecl DECLSPEC_NORETURN _Xmem(void)
920 {
921 bad_alloc e;
922
923 TRACE("()\n");
924
925 MSVCP_bad_alloc_default_ctor(&e);
926 _CxxThrowException(&e, &bad_alloc_cxx_type);
927 }
928
929 /* ?_Xinvalid_argument@std@@YAXPBD@Z */
930 /* ?_Xinvalid_argument@std@@YAXPEBD@Z */
931 void __cdecl DECLSPEC_NORETURN _Xinvalid_argument(const char *str)
932 {
933 exception_name name = EXCEPTION_NAME(str);
934 invalid_argument e;
935
936 TRACE("(%s)\n", debugstr_a(str));
937
938 MSVCP_invalid_argument_ctor(&e, name);
939 _CxxThrowException(&e, &invalid_argument_cxx_type);
940 }
941
942 /* ?_Xlength_error@std@@YAXPBD@Z */
943 /* ?_Xlength_error@std@@YAXPEBD@Z */
944 void __cdecl DECLSPEC_NORETURN _Xlength_error(const char *str)
945 {
946 exception_name name = EXCEPTION_NAME(str);
947 length_error e;
948
949 TRACE("(%s)\n", debugstr_a(str));
950
951 MSVCP_length_error_ctor(&e, name);
952 _CxxThrowException(&e, &length_error_cxx_type);
953 }
954
955 /* ?_Xout_of_range@std@@YAXPBD@Z */
956 /* ?_Xout_of_range@std@@YAXPEBD@Z */
957 void __cdecl DECLSPEC_NORETURN _Xout_of_range(const char *str)
958 {
959 exception_name name = EXCEPTION_NAME(str);
960 out_of_range e;
961
962 TRACE("(%s)\n", debugstr_a(str));
963
964 MSVCP_out_of_range_ctor(&e, name);
965 _CxxThrowException(&e, &out_of_range_cxx_type);
966 }
967
968 /* ?_Xruntime_error@std@@YAXPBD@Z */
969 /* ?_Xruntime_error@std@@YAXPEBD@Z */
970 void __cdecl DECLSPEC_NORETURN _Xruntime_error(const char *str)
971 {
972 exception_name name = EXCEPTION_NAME(str);
973 runtime_error e;
974
975 TRACE("(%s)\n", debugstr_a(str));
976
977 MSVCP_runtime_error_ctor(&e, name);
978 _CxxThrowException(&e, &runtime_error_cxx_type);
979 }
980
981 #if _MSVCP_VER > 90
982 /* ?_Xbad_function_call@std@@YAXXZ() */
983 void __cdecl _Xbad_function_call(void)
984 {
985 exception e;
986
987 TRACE("()\n");
988
989 MSVCP_bad_function_call_ctor(&e);
990 _CxxThrowException(&e, &bad_function_call_cxx_type);
991 }
992 #endif
993
994 /* ?uncaught_exception@std@@YA_NXZ */
995 bool __cdecl MSVCP__uncaught_exception(void)
996 {
997 return __uncaught_exception();
998 }
999
1000 #if _MSVCP_VER >= 110
1001 typedef struct
1002 {
1003 logic_error base;
1004 error_code code;
1005 } future_error;
1006
1007 extern const vtable_ptr future_error_vtable;
1008
1009 DEFINE_THISCALL_WRAPPER(future_error_copy_ctor, 8)
1010 future_error* __thiscall future_error_copy_ctor(future_error *this, const future_error *rhs)
1011 {
1012 logic_error_copy_ctor(&this->base, &rhs->base);
1013 this->code = rhs->code;
1014 this->base.e.vtable = &future_error_vtable;
1015 return this;
1016 }
1017
1018 DEFINE_THISCALL_WRAPPER(MSVCP_future_error_what, 4)
1019 const char* __thiscall MSVCP_future_error_what(future_error *this)
1020 {
1021 const char *names[4] = {
1022 "broken promise",
1023 "future already retrieved",
1024 "promise already satisfied",
1025 "no state",
1026 };
1027 #if _MSVCP_VER == 110
1028 int code = this->code.code;
1029 #else
1030 int code = this->code.code-1;
1031 #endif
1032 TRACE("%p\n", this);
1033 return code >= 0 && code < ARRAY_SIZE(names) ? names[code] : NULL;
1034 }
1035
1036 DEFINE_RTTI_DATA3(future_error, 0, &future_error_rtti_base_descriptor,
1037 &logic_error_rtti_base_descriptor, &exception_rtti_base_descriptor,
1038 ".?AVfuture_error@std@@")
1039 DEFINE_CXX_DATA3(future_error, &logic_error_cxx_type_info, &logic_error_cxx_type_info,
1040 &exception_cxx_type_info, MSVCP_logic_error_dtor)
1041
1042 /* ?_Throw_future_error@std@@YAXABVerror_code@1@@Z */
1043 /* ?_Throw_future_error@std@@YAXAEBVerror_code@1@@Z */
1044 void __cdecl DECLSPEC_NORETURN _Throw_future_error( const error_code *error_code )
1045 {
1046 future_error e;
1047 const char *name = "";
1048
1049 TRACE("(%p)\n", error_code);
1050
1051 MSVCP_logic_error_ctor(&e.base, EXCEPTION_NAME(name));
1052 e.code = *error_code;
1053 e.base.e.vtable = &future_error_vtable;
1054 _CxxThrowException(&e, &future_error_cxx_type);
1055 }
1056
1057 typedef struct
1058 {
1059 EXCEPTION_RECORD *rec;
1060 LONG *ref; /* not binary compatible with native */
1061 } exception_ptr;
1062
1063 static void exception_ptr_rethrow(const exception_ptr *ep)
1064 {
1065 TRACE("(%p)\n", ep);
1066
1067 if (!ep->rec)
1068 {
1069 static const char *exception_msg = "bad exception";
1070 exception e;
1071
1072 MSVCP_exception_ctor(&e, &exception_msg);
1073 _CxxThrowException(&e, &exception_cxx_type);
1074 return;
1075 }
1076
1077 RaiseException(ep->rec->ExceptionCode, ep->rec->ExceptionFlags & (~EH_UNWINDING),
1078 ep->rec->NumberParameters, ep->rec->ExceptionInformation);
1079 }
1080
1081 /* ?_Rethrow_future_exception@std@@YAXVexception_ptr@1@@Z */
1082 void __cdecl _Rethrow_future_exception(const exception_ptr ep)
1083 {
1084 exception_ptr_rethrow(&ep);
1085 }
1086
1087 /* ?_Throw_C_error@std@@YAXH@Z */
1088 void __cdecl _Throw_C_error(int code)
1089 {
1090 system_error se;
1091 const char *msg;
1092 errno_t err;
1093
1094 TRACE("(%d)\n", code);
1095
1096 switch(code)
1097 {
1098 case 1:
1099 case 2:
1100 err = EAGAIN;
1101 break;
1102 case 3:
1103 err = EBUSY;
1104 break;
1105 case 4:
1106 err = EINVAL;
1107 break;
1108 default:
1109 #if _MSVCP_VER >= 140
1110 abort();
1111 #else
1112 return;
1113 #endif
1114 }
1115
1116 msg = strerror(err);
1117 MSVCP_runtime_error_ctor(&se.base, &msg);
1118 se.code.code = err;
1119 se.code.category = std_generic_category();
1120 se.base.e.vtable = &system_error_vtable;
1121
1122 _CxxThrowException(&se, &system_error_cxx_type);
1123 }
1124 #endif
1125
1126 #if _MSVCP_VER >= 140
1127 void** CDECL __current_exception(void);
1128
1129 /* compute the this pointer for a base class of a given type */
1130 static inline void *get_this_pointer( const this_ptr_offsets *off, void *object )
1131 {
1132 if (!object) return NULL;
1133
1134 if (off->vbase_descr >= 0)
1135 {
1136 int *offset_ptr;
1137
1138 /* move this ptr to vbase descriptor */
1139 object = (char *)object + off->vbase_descr;
1140 /* and fetch additional offset from vbase descriptor */
1141 offset_ptr = (int *)(*(char **)object + off->vbase_offset);
1142 object = (char *)object + *offset_ptr;
1143 }
1144
1145 object = (char *)object + off->this_offset;
1146 return object;
1147 }
1148
1149 #ifdef __i386__
1150 extern void call_copy_ctor( void *func, void *this, void *src, int has_vbase );
1151 __ASM_GLOBAL_FUNC( call_copy_ctor,
1152 "pushl %ebp\n\t"
1153 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
1154 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
1155 "movl %esp, %ebp\n\t"
1156 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
1157 "pushl $1\n\t"
1158 "movl 12(%ebp), %ecx\n\t"
1159 "pushl 16(%ebp)\n\t"
1160 "call *8(%ebp)\n\t"
1161 "leave\n"
1162 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
1163 __ASM_CFI(".cfi_same_value %ebp\n\t")
1164 "ret" );
1165 #else
1166 static inline void call_copy_ctor( void *func, void *this, void *src, int has_vbase )
1167 {
1168 TRACE( "calling copy ctor %p object %p src %p\n", func, this, src );
1169 if (has_vbase)
1170 ((void (__cdecl*)(void*, void*, BOOL))func)(this, src, 1);
1171 else
1172 ((void (__cdecl*)(void*, void*))func)(this, src);
1173 }
1174 #endif
1175
1176 int __cdecl __uncaught_exceptions(void)
1177 {
1178 return *__processing_throw();
1179 }
1180
1181 /*********************************************************************
1182 * ?__ExceptionPtrCreate@@YAXPAX@Z
1183 * ?__ExceptionPtrCreate@@YAXPEAX@Z
1184 */
1185 void __cdecl __ExceptionPtrCreate(exception_ptr *ep)
1186 {
1187 TRACE("(%p)\n", ep);
1188
1189 ep->rec = NULL;
1190 ep->ref = NULL;
1191 }
1192
1193 #ifdef __ASM_USE_THISCALL_WRAPPER
1194 extern void call_dtor(const cxx_exception_type *type, void *func, void *object);
1195
1196 __ASM_GLOBAL_FUNC( call_dtor,
1197 "movl 12(%esp),%ecx\n\t"
1198 "call *8(%esp)\n\t"
1199 "ret" );
1200 #elif __x86_64__
1201 static inline void call_dtor(const cxx_exception_type *type, unsigned int dtor, void *object)
1202 {
1203 char *base = RtlPcToFileHeader((void*)type, (void**)&base);
1204 void (__cdecl *func)(void*) = (void*)(base + dtor);
1205 func(object);
1206 }
1207 #else
1208 #define call_dtor(type, func, object) ((void (__thiscall*)(void*))(func))(object)
1209 #endif
1210
1211 /*********************************************************************
1212 * ?__ExceptionPtrDestroy@@YAXPAX@Z
1213 * ?__ExceptionPtrDestroy@@YAXPEAX@Z
1214 */
1215 void __cdecl __ExceptionPtrDestroy(exception_ptr *ep)
1216 {
1217 TRACE("(%p)\n", ep);
1218
1219 if (!ep->rec)
1220 return;
1221
1222 if (!InterlockedDecrement(ep->ref))
1223 {
1224 if (ep->rec->ExceptionCode == CXX_EXCEPTION)
1225 {
1226 const cxx_exception_type *type = (void*)ep->rec->ExceptionInformation[2];
1227 void *obj = (void*)ep->rec->ExceptionInformation[1];
1228
1229 if (type && type->destructor) call_dtor(type, type->destructor, obj);
1230 HeapFree(GetProcessHeap(), 0, obj);
1231 }
1232
1233 HeapFree(GetProcessHeap(), 0, ep->rec);
1234 HeapFree(GetProcessHeap(), 0, ep->ref);
1235 }
1236 }
1237
1238 /*********************************************************************
1239 * ?__ExceptionPtrCopy@@YAXPAXPBX@Z
1240 * ?__ExceptionPtrCopy@@YAXPEAXPEBX@Z
1241 */
1242 void __cdecl __ExceptionPtrCopy(exception_ptr *ep, const exception_ptr *copy)
1243 {
1244 TRACE("(%p %p)\n", ep, copy);
1245
1246 /* don't destroy object stored in ep */
1247 *ep = *copy;
1248 if (ep->ref)
1249 InterlockedIncrement(copy->ref);
1250 }
1251
1252 /*********************************************************************
1253 * ?__ExceptionPtrAssign@@YAXPAXPBX@Z
1254 * ?__ExceptionPtrAssign@@YAXPEAXPEBX@Z
1255 */
1256 void __cdecl __ExceptionPtrAssign(exception_ptr *ep, const exception_ptr *assign)
1257 {
1258 TRACE("(%p %p)\n", ep, assign);
1259
1260 /* don't destroy object stored in ep */
1261 if (ep->ref)
1262 InterlockedDecrement(ep->ref);
1263
1264 *ep = *assign;
1265 if (ep->ref)
1266 InterlockedIncrement(ep->ref);
1267 }
1268
1269 /*********************************************************************
1270 * ?__ExceptionPtrRethrow@@YAXPBX@Z
1271 * ?__ExceptionPtrRethrow@@YAXPEBX@Z
1272 */
1273 void __cdecl __ExceptionPtrRethrow(const exception_ptr *ep)
1274 {
1275 exception_ptr_rethrow(ep);
1276 }
1277
1278 /*********************************************************************
1279 * ?__ExceptionPtrCurrentException@@YAXPAX@Z
1280 * ?__ExceptionPtrCurrentException@@YAXPEAX@Z
1281 */
1282 #ifndef __x86_64__
1283 void __cdecl __ExceptionPtrCurrentException(exception_ptr *ep)
1284 {
1285 void **current_exception = __current_exception();
1286 EXCEPTION_RECORD *rec = current_exception ? *current_exception : NULL;
1287
1288 TRACE("(%p)\n", ep);
1289
1290 if (!rec)
1291 {
1292 ep->rec = NULL;
1293 ep->ref = NULL;
1294 return;
1295 }
1296
1297 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1298 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1299
1300 *ep->rec = *rec;
1301 *ep->ref = 1;
1302
1303 if (ep->rec->ExceptionCode == CXX_EXCEPTION)
1304 {
1305 const cxx_exception_type *et = (void*)ep->rec->ExceptionInformation[2];
1306 const cxx_type_info *ti;
1307 void **data, *obj;
1308
1309 ti = et->type_info_table->info[0];
1310 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
1311
1312 obj = (void*)ep->rec->ExceptionInformation[1];
1313 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
1314 {
1315 memcpy(data, obj, ti->size);
1316 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
1317 }
1318 else if (ti->copy_ctor)
1319 {
1320 call_copy_ctor(ti->copy_ctor, data, get_this_pointer(&ti->offsets, obj),
1321 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
1322 }
1323 else
1324 memcpy(data, get_this_pointer(&ti->offsets, obj), ti->size);
1325 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
1326 }
1327 return;
1328 }
1329 #else
1330 void __cdecl __ExceptionPtrCurrentException(exception_ptr *ep)
1331 {
1332 void **current_exception = __current_exception();
1333 EXCEPTION_RECORD *rec = current_exception ? *current_exception : NULL;
1334
1335 TRACE("(%p)\n", ep);
1336
1337 if (!rec)
1338 {
1339 ep->rec = NULL;
1340 ep->ref = NULL;
1341 return;
1342 }
1343
1344 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1345 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1346
1347 *ep->rec = *rec;
1348 *ep->ref = 1;
1349
1350 if (ep->rec->ExceptionCode == CXX_EXCEPTION)
1351 {
1352 const cxx_exception_type *et = (void*)ep->rec->ExceptionInformation[2];
1353 const cxx_type_info *ti;
1354 void **data, *obj;
1355 char *base = RtlPcToFileHeader((void*)et, (void**)&base);
1356
1357 ti = (const cxx_type_info*)(base + ((const cxx_type_info_table*)(base + et->type_info_table))->info[0]);
1358 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
1359
1360 obj = (void*)ep->rec->ExceptionInformation[1];
1361 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
1362 {
1363 memcpy(data, obj, ti->size);
1364 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
1365 }
1366 else if (ti->copy_ctor)
1367 {
1368 call_copy_ctor(base + ti->copy_ctor, data, get_this_pointer(&ti->offsets, obj),
1369 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
1370 }
1371 else
1372 memcpy(data, get_this_pointer(&ti->offsets, obj), ti->size);
1373 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
1374 }
1375 return;
1376 }
1377 #endif
1378
1379 /*********************************************************************
1380 * ?__ExceptionPtrToBool@@YA_NPBX@Z
1381 * ?__ExceptionPtrToBool@@YA_NPEBX@Z
1382 */
1383 bool __cdecl __ExceptionPtrToBool(exception_ptr *ep)
1384 {
1385 return !!ep->rec;
1386 }
1387
1388 /*********************************************************************
1389 * ?__ExceptionPtrCopyException@@YAXPAXPBX1@Z
1390 * ?__ExceptionPtrCopyException@@YAXPEAXPEBX1@Z
1391 */
1392 #ifndef __x86_64__
1393 void __cdecl __ExceptionPtrCopyException(exception_ptr *ep,
1394 exception *object, const cxx_exception_type *type)
1395 {
1396 const cxx_type_info *ti;
1397 void **data;
1398
1399 __ExceptionPtrDestroy(ep);
1400
1401 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1402 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1403 *ep->ref = 1;
1404
1405 memset(ep->rec, 0, sizeof(EXCEPTION_RECORD));
1406 ep->rec->ExceptionCode = CXX_EXCEPTION;
1407 ep->rec->ExceptionFlags = EH_NONCONTINUABLE;
1408 ep->rec->NumberParameters = 3;
1409 ep->rec->ExceptionInformation[0] = CXX_FRAME_MAGIC_VC6;
1410 ep->rec->ExceptionInformation[2] = (ULONG_PTR)type;
1411
1412 ti = type->type_info_table->info[0];
1413 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
1414 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
1415 {
1416 memcpy(data, object, ti->size);
1417 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
1418 }
1419 else if (ti->copy_ctor)
1420 {
1421 call_copy_ctor(ti->copy_ctor, data, get_this_pointer(&ti->offsets, object),
1422 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
1423 }
1424 else
1425 memcpy(data, get_this_pointer(&ti->offsets, object), ti->size);
1426 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
1427 }
1428 #else
1429 void __cdecl __ExceptionPtrCopyException(exception_ptr *ep,
1430 exception *object, const cxx_exception_type *type)
1431 {
1432 const cxx_type_info *ti;
1433 void **data;
1434 char *base;
1435
1436 RtlPcToFileHeader((void*)type, (void**)&base);
1437 __ExceptionPtrDestroy(ep);
1438
1439 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1440 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1441 *ep->ref = 1;
1442
1443 memset(ep->rec, 0, sizeof(EXCEPTION_RECORD));
1444 ep->rec->ExceptionCode = CXX_EXCEPTION;
1445 ep->rec->ExceptionFlags = EH_NONCONTINUABLE;
1446 ep->rec->NumberParameters = 4;
1447 ep->rec->ExceptionInformation[0] = CXX_FRAME_MAGIC_VC6;
1448 ep->rec->ExceptionInformation[2] = (ULONG_PTR)type;
1449 ep->rec->ExceptionInformation[3] = (ULONG_PTR)base;
1450
1451 ti = (const cxx_type_info*)(base + ((const cxx_type_info_table*)(base + type->type_info_table))->info[0]);
1452 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
1453 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
1454 {
1455 memcpy(data, object, ti->size);
1456 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
1457 }
1458 else if (ti->copy_ctor)
1459 {
1460 call_copy_ctor(base + ti->copy_ctor, data, get_this_pointer(&ti->offsets, object),
1461 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
1462 }
1463 else
1464 memcpy(data, get_this_pointer(&ti->offsets, object), ti->size);
1465 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
1466 }
1467 #endif
1468
1469 /*********************************************************************
1470 * ?__ExceptionPtrCompare@@YA_NPBX0@Z
1471 * ?__ExceptionPtrCompare@@YA_NPEBX0@Z
1472 */
1473 bool __cdecl __ExceptionPtrCompare(const exception_ptr *ep1, const exception_ptr *ep2)
1474 {
1475 return ep1->rec == ep2->rec;
1476 }
1477 #endif
1478
1479 #if _MSVCP_VER >= 70 || defined(_MSVCIRT)
1480 #define EXCEPTION_VTABLE(name,funcs) __ASM_VTABLE(name,funcs)
1481 #else
1482 #define EXCEPTION_VTABLE(name,funcs) __ASM_VTABLE(name,funcs VTABLE_ADD_FUNC(MSVCP_exception__Doraise))
1483 #endif
1484
1485 __ASM_BLOCK_BEGIN(exception_vtables)
1486 EXCEPTION_VTABLE(exception,
1487 VTABLE_ADD_FUNC(MSVCP_exception_vector_dtor)
1488 VTABLE_ADD_FUNC(MSVCP_exception_what));
1489 EXCEPTION_VTABLE(bad_alloc,
1490 VTABLE_ADD_FUNC(MSVCP_bad_alloc_vector_dtor)
1491 VTABLE_ADD_FUNC(MSVCP_exception_what));
1492 EXCEPTION_VTABLE(logic_error,
1493 VTABLE_ADD_FUNC(MSVCP_logic_error_vector_dtor)
1494 VTABLE_ADD_FUNC(MSVCP_logic_error_what));
1495 EXCEPTION_VTABLE(length_error,
1496 VTABLE_ADD_FUNC(MSVCP_logic_error_vector_dtor)
1497 VTABLE_ADD_FUNC(MSVCP_logic_error_what));
1498 EXCEPTION_VTABLE(out_of_range,
1499 VTABLE_ADD_FUNC(MSVCP_logic_error_vector_dtor)
1500 VTABLE_ADD_FUNC(MSVCP_logic_error_what));
1501 EXCEPTION_VTABLE(invalid_argument,
1502 VTABLE_ADD_FUNC(MSVCP_logic_error_vector_dtor)
1503 VTABLE_ADD_FUNC(MSVCP_logic_error_what));
1504 EXCEPTION_VTABLE(runtime_error,
1505 VTABLE_ADD_FUNC(MSVCP_runtime_error_vector_dtor)
1506 VTABLE_ADD_FUNC(MSVCP_runtime_error_what));
1507 #if _MSVCP_VER >= 110
1508 EXCEPTION_VTABLE(future_error,
1509 VTABLE_ADD_FUNC(MSVCP_logic_error_vector_dtor)
1510 VTABLE_ADD_FUNC(MSVCP_future_error_what));
1511 #endif
1512 #if _MSVCP_VER > 110
1513 EXCEPTION_VTABLE(_System_error,
1514 VTABLE_ADD_FUNC(MSVCP_failure_vector_dtor)
1515 VTABLE_ADD_FUNC(MSVCP_failure_what));
1516 #endif
1517 #if _MSVCP_VER > 90
1518 EXCEPTION_VTABLE(system_error,
1519 VTABLE_ADD_FUNC(MSVCP_failure_vector_dtor)
1520 VTABLE_ADD_FUNC(MSVCP_failure_what));
1521 EXCEPTION_VTABLE(bad_function_call,
1522 VTABLE_ADD_FUNC(MSVCP_exception_vector_dtor)
1523 VTABLE_ADD_FUNC(MSVCP_exception_what));
1524 #endif
1525 EXCEPTION_VTABLE(failure,
1526 VTABLE_ADD_FUNC(MSVCP_failure_vector_dtor)
1527 VTABLE_ADD_FUNC(MSVCP_failure_what));
1528 EXCEPTION_VTABLE(bad_cast,
1529 VTABLE_ADD_FUNC(MSVCP_bad_cast_vector_dtor)
1530 VTABLE_ADD_FUNC(MSVCP_exception_what));
1531 EXCEPTION_VTABLE(range_error,
1532 VTABLE_ADD_FUNC(MSVCP_runtime_error_vector_dtor)
1533 VTABLE_ADD_FUNC(MSVCP_runtime_error_what));
1534
1535 __ASM_BLOCK_END
1536
1537 /* Internal: throws exception */
1538 void DECLSPEC_NORETURN throw_exception(const char *str)
1539 {
1540 exception_name name = EXCEPTION_NAME(str);
1541 exception e;
1542
1543 MSVCP_exception_ctor(&e, name);
1544 _CxxThrowException(&e, &exception_cxx_type);
1545 }
1546
1547 /* Internal: throws range_error exception */
1548 void DECLSPEC_NORETURN throw_range_error(const char *str)
1549 {
1550 exception_name name = EXCEPTION_NAME(str);
1551 range_error e;
1552
1553 MSVCP_range_error_ctor(&e, name);
1554 _CxxThrowException(&e, &range_error_cxx_type);
1555 }
1556
1557 /* Internal: throws failure exception */
1558 void DECLSPEC_NORETURN throw_failure(const char *str)
1559 {
1560 exception_name name = EXCEPTION_NAME(str);
1561 failure e;
1562
1563 MSVCP_failure_ctor(&e, name);
1564 _CxxThrowException(&e, &failure_cxx_type);
1565 }
1566
1567 void init_exception(void *base)
1568 {
1569 #ifdef __x86_64__
1570 init_type_info_rtti(base);
1571 init_exception_rtti(base);
1572 init_bad_alloc_rtti(base);
1573 init_logic_error_rtti(base);
1574 init_length_error_rtti(base);
1575 init_out_of_range_rtti(base);
1576 init_invalid_argument_rtti(base);
1577 init_runtime_error_rtti(base);
1578 #if _MSVCP_VER >= 110
1579 init_future_error_rtti(base);
1580 #endif
1581 #if _MSVCP_VER > 110
1582 init__System_error_rtti(base);
1583 #endif
1584 #if _MSVCP_VER > 90
1585 init_system_error_rtti(base);
1586 init_bad_function_call_rtti(base);
1587 #endif
1588 init_failure_rtti(base);
1589 init_bad_cast_rtti(base);
1590 init_range_error_rtti(base);
1591
1592 init_exception_cxx(base);
1593 init_bad_alloc_cxx(base);
1594 init_logic_error_cxx_type_info(base);
1595 init_length_error_cxx(base);
1596 init_out_of_range_cxx(base);
1597 init_invalid_argument_cxx(base);
1598 init_runtime_error_cxx(base);
1599 #if _MSVCP_VER >= 110
1600 init_future_error_cxx(base);
1601 #endif
1602 #if _MSVCP_VER > 110
1603 init__System_error_cxx_type_info(base);
1604 #endif
1605 #if _MSVCP_VER == 100
1606 init_system_error_cxx_type_info(base);
1607 #elif _MSVCP_VER > 100
1608 init_system_error_cxx(base);
1609 #endif
1610 #if _MSVCP_VER > 90
1611 init_bad_function_call_cxx(base);
1612 #endif
1613 init_failure_cxx(base);
1614 init_range_error_cxx(base);
1615 #endif
1616 }
Windows API implementation