?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus: Use wide-char string literals.
[wine.git] / dlls / msvcrt / cpp.c
blob16efc88755f7684cc7a6e01e807738ee2d968ee0
1 /*
2 * msvcrt.dll C++ objects
3 *
4 * Copyright 2000 Jon Griffiths
5 * Copyright 2003, 2004 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdarg.h>
26
27 #include "windef.h"
28 #include "winternl.h"
29 #include "wine/exception.h"
30 #include "wine/debug.h"
31 #include "msvcrt.h"
32 #include "cppexcept.h"
33 #include "mtdll.h"
34 #include "cxx.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
37
38 struct __type_info_node
39 {
40 void *memPtr;
41 struct __type_info_node* next;
42 };
43
44 typedef exception bad_cast;
45 typedef exception bad_typeid;
46 typedef exception __non_rtti_object;
47
48 extern const vtable_ptr MSVCRT_exception_vtable;
49 extern const vtable_ptr MSVCRT_bad_typeid_vtable;
50 extern const vtable_ptr MSVCRT_bad_cast_vtable;
51 extern const vtable_ptr MSVCRT___non_rtti_object_vtable;
52 extern const vtable_ptr MSVCRT_type_info_vtable;
53
54 /* get the vtable pointer for a C++ object */
55 static inline const vtable_ptr *get_vtable( void *obj )
56 {
57 return *(const vtable_ptr **)obj;
58 }
59
60 static inline const rtti_object_locator *get_obj_locator( void *cppobj )
61 {
62 const vtable_ptr *vtable = get_vtable( cppobj );
63 return (const rtti_object_locator *)vtable[-1];
64 }
65
66 #ifndef __x86_64__
67 static void dump_obj_locator( const rtti_object_locator *ptr )
68 {
69 int i;
70 const rtti_object_hierarchy *h = ptr->type_hierarchy;
71
72 TRACE( "%p: sig=%08x base_offset=%08x flags=%08x type=%p %s hierarchy=%p\n",
73 ptr, ptr->signature, ptr->base_class_offset, ptr->flags,
74 ptr->type_descriptor, dbgstr_type_info(ptr->type_descriptor), ptr->type_hierarchy );
75 TRACE( " hierarchy: sig=%08x attr=%08x len=%d base classes=%p\n",
76 h->signature, h->attributes, h->array_len, h->base_classes );
77 for (i = 0; i < h->array_len; i++)
78 {
79 TRACE( " base class %p: num %d off %d,%d,%d attr %08x type %p %s\n",
80 h->base_classes->bases[i],
81 h->base_classes->bases[i]->num_base_classes,
82 h->base_classes->bases[i]->offsets.this_offset,
83 h->base_classes->bases[i]->offsets.vbase_descr,
84 h->base_classes->bases[i]->offsets.vbase_offset,
85 h->base_classes->bases[i]->attributes,
86 h->base_classes->bases[i]->type_descriptor,
87 dbgstr_type_info(h->base_classes->bases[i]->type_descriptor) );
88 }
89 }
90
91 #else
92
93 static void dump_obj_locator( const rtti_object_locator *ptr )
94 {
95 int i;
96 char *base = ptr->signature == 0 ? RtlPcToFileHeader((void*)ptr, (void**)&base) : (char*)ptr - ptr->object_locator;
97 const rtti_object_hierarchy *h = (const rtti_object_hierarchy*)(base + ptr->type_hierarchy);
98 const type_info *type_descriptor = (const type_info*)(base + ptr->type_descriptor);
99
100 TRACE( "%p: sig=%08x base_offset=%08x flags=%08x type=%p %s hierarchy=%p\n",
101 ptr, ptr->signature, ptr->base_class_offset, ptr->flags,
102 type_descriptor, dbgstr_type_info(type_descriptor), h );
103 TRACE( " hierarchy: sig=%08x attr=%08x len=%d base classes=%p\n",
104 h->signature, h->attributes, h->array_len, base + h->base_classes );
105 for (i = 0; i < h->array_len; i++)
106 {
107 const rtti_base_descriptor *bases = (rtti_base_descriptor*)(base +
108 ((const rtti_base_array*)(base + h->base_classes))->bases[i]);
109
110 TRACE( " base class %p: num %d off %d,%d,%d attr %08x type %p %s\n",
111 bases,
112 bases->num_base_classes,
113 bases->offsets.this_offset,
114 bases->offsets.vbase_descr,
115 bases->offsets.vbase_offset,
116 bases->attributes,
117 base + bases->type_descriptor,
118 dbgstr_type_info((const type_info*)(base + bases->type_descriptor)) );
119 }
120 }
121 #endif
122
123 /* Internal common ctor for exception */
124 static void EXCEPTION_ctor(exception *_this, const char** name)
125 {
126 _this->vtable = &MSVCRT_exception_vtable;
127 if (*name)
128 {
129 unsigned int name_len = strlen(*name) + 1;
130 _this->name = MSVCRT_malloc(name_len);
131 memcpy(_this->name, *name, name_len);
132 _this->do_free = TRUE;
133 }
134 else
135 {
136 _this->name = NULL;
137 _this->do_free = FALSE;
138 }
139 }
140
141 /******************************************************************
142 * ??0exception@@QAE@ABQBD@Z (MSVCRT.@)
143 */
144 DEFINE_THISCALL_WRAPPER(MSVCRT_exception_ctor,8)
145 exception * __thiscall MSVCRT_exception_ctor(exception * _this, const char ** name)
146 {
147 TRACE("(%p,%s)\n", _this, *name);
148 EXCEPTION_ctor(_this, name);
149 return _this;
150 }
151
152 /******************************************************************
153 * ??0exception@@QAE@ABQBDH@Z (MSVCRT.@)
154 */
155 DEFINE_THISCALL_WRAPPER(MSVCRT_exception_ctor_noalloc,12)
156 exception * __thiscall MSVCRT_exception_ctor_noalloc(exception * _this, char ** name, int noalloc)
157 {
158 TRACE("(%p,%s)\n", _this, *name);
159 _this->vtable = &MSVCRT_exception_vtable;
160 _this->name = *name;
161 _this->do_free = FALSE;
162 return _this;
163 }
164
165 /******************************************************************
166 * ??0exception@@QAE@ABV0@@Z (MSVCRT.@)
167 */
168 DEFINE_THISCALL_WRAPPER(MSVCRT_exception_copy_ctor,8)
169 exception * __thiscall MSVCRT_exception_copy_ctor(exception * _this, const exception * rhs)
170 {
171 TRACE("(%p,%p)\n", _this, rhs);
172
173 if (!rhs->do_free)
174 {
175 _this->vtable = &MSVCRT_exception_vtable;
176 _this->name = rhs->name;
177 _this->do_free = FALSE;
178 }
179 else
180 EXCEPTION_ctor(_this, (const char**)&rhs->name);
181 TRACE("name = %s\n", _this->name);
182 return _this;
183 }
184
185 /******************************************************************
186 * ??0exception@@QAE@XZ (MSVCRT.@)
187 */
188 DEFINE_THISCALL_WRAPPER(MSVCRT_exception_default_ctor,4)
189 exception * __thiscall MSVCRT_exception_default_ctor(exception * _this)
190 {
191 static const char* empty = NULL;
192
193 TRACE("(%p)\n", _this);
194 EXCEPTION_ctor(_this, &empty);
195 return _this;
196 }
197
198 /******************************************************************
199 * ??1exception@@UAE@XZ (MSVCRT.@)
200 */
201 DEFINE_THISCALL_WRAPPER(MSVCRT_exception_dtor,4)
202 void __thiscall MSVCRT_exception_dtor(exception * _this)
203 {
204 TRACE("(%p)\n", _this);
205 _this->vtable = &MSVCRT_exception_vtable;
206 if (_this->do_free) MSVCRT_free(_this->name);
207 }
208
209 /******************************************************************
210 * ??4exception@@QAEAAV0@ABV0@@Z (MSVCRT.@)
211 */
212 DEFINE_THISCALL_WRAPPER(MSVCRT_exception_opequals,8)
213 exception * __thiscall MSVCRT_exception_opequals(exception * _this, const exception * rhs)
214 {
215 TRACE("(%p %p)\n", _this, rhs);
216 if (_this != rhs)
217 {
218 MSVCRT_exception_dtor(_this);
219 MSVCRT_exception_copy_ctor(_this, rhs);
220 }
221 TRACE("name = %s\n", _this->name);
222 return _this;
223 }
224
225 /******************************************************************
226 * ??_Eexception@@UAEPAXI@Z (MSVCRT.@)
227 */
228 DEFINE_THISCALL_WRAPPER(MSVCRT_exception_vector_dtor,8)
229 void * __thiscall MSVCRT_exception_vector_dtor(exception * _this, unsigned int flags)
230 {
231 TRACE("(%p %x)\n", _this, flags);
232 if (flags & 2)
233 {
234 /* we have an array, with the number of elements stored before the first object */
235 INT_PTR i, *ptr = (INT_PTR *)_this - 1;
236
237 for (i = *ptr - 1; i >= 0; i--) MSVCRT_exception_dtor(_this + i);
238 MSVCRT_operator_delete(ptr);
239 }
240 else
241 {
242 MSVCRT_exception_dtor(_this);
243 if (flags & 1) MSVCRT_operator_delete(_this);
244 }
245 return _this;
246 }
247
248 /******************************************************************
249 * ??_Gexception@@UAEPAXI@Z (MSVCRT.@)
250 */
251 DEFINE_THISCALL_WRAPPER(MSVCRT_exception_scalar_dtor,8)
252 void * __thiscall MSVCRT_exception_scalar_dtor(exception * _this, unsigned int flags)
253 {
254 TRACE("(%p %x)\n", _this, flags);
255 MSVCRT_exception_dtor(_this);
256 if (flags & 1) MSVCRT_operator_delete(_this);
257 return _this;
258 }
259
260 /******************************************************************
261 * ?what@exception@@UBEPBDXZ (MSVCRT.@)
262 */
263 DEFINE_THISCALL_WRAPPER(MSVCRT_what_exception,4)
264 const char * __thiscall MSVCRT_what_exception(exception * _this)
265 {
266 TRACE("(%p) returning %s\n", _this, _this->name);
267 return _this->name ? _this->name : "Unknown exception";
268 }
269
270 /******************************************************************
271 * ??0bad_typeid@@QAE@ABV0@@Z (MSVCRT.@)
272 */
273 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_typeid_copy_ctor,8)
274 bad_typeid * __thiscall MSVCRT_bad_typeid_copy_ctor(bad_typeid * _this, const bad_typeid * rhs)
275 {
276 TRACE("(%p %p)\n", _this, rhs);
277 MSVCRT_exception_copy_ctor(_this, rhs);
278 _this->vtable = &MSVCRT_bad_typeid_vtable;
279 return _this;
280 }
281
282 /******************************************************************
283 * ??0bad_typeid@@QAE@PBD@Z (MSVCRT.@)
284 */
285 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_typeid_ctor,8)
286 bad_typeid * __thiscall MSVCRT_bad_typeid_ctor(bad_typeid * _this, const char * name)
287 {
288 TRACE("(%p %s)\n", _this, name);
289 EXCEPTION_ctor(_this, &name);
290 _this->vtable = &MSVCRT_bad_typeid_vtable;
291 return _this;
292 }
293
294 /******************************************************************
295 * ??_Fbad_typeid@@QAEXXZ (MSVCRT.@)
296 */
297 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_typeid_default_ctor,4)
298 bad_typeid * __thiscall MSVCRT_bad_typeid_default_ctor(bad_typeid * _this)
299 {
300 return MSVCRT_bad_typeid_ctor( _this, "bad typeid" );
301 }
302
303 /******************************************************************
304 * ??1bad_typeid@@UAE@XZ (MSVCRT.@)
305 */
306 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_typeid_dtor,4)
307 void __thiscall MSVCRT_bad_typeid_dtor(bad_typeid * _this)
308 {
309 TRACE("(%p)\n", _this);
310 MSVCRT_exception_dtor(_this);
311 }
312
313 /******************************************************************
314 * ??4bad_typeid@@QAEAAV0@ABV0@@Z (MSVCRT.@)
315 */
316 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_typeid_opequals,8)
317 bad_typeid * __thiscall MSVCRT_bad_typeid_opequals(bad_typeid * _this, const bad_typeid * rhs)
318 {
319 TRACE("(%p %p)\n", _this, rhs);
320 MSVCRT_exception_opequals(_this, rhs);
321 return _this;
322 }
323
324 /******************************************************************
325 * ??_Ebad_typeid@@UAEPAXI@Z (MSVCRT.@)
326 */
327 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_typeid_vector_dtor,8)
328 void * __thiscall MSVCRT_bad_typeid_vector_dtor(bad_typeid * _this, unsigned int flags)
329 {
330 TRACE("(%p %x)\n", _this, flags);
331 if (flags & 2)
332 {
333 /* we have an array, with the number of elements stored before the first object */
334 INT_PTR i, *ptr = (INT_PTR *)_this - 1;
335
336 for (i = *ptr - 1; i >= 0; i--) MSVCRT_bad_typeid_dtor(_this + i);
337 MSVCRT_operator_delete(ptr);
338 }
339 else
340 {
341 MSVCRT_bad_typeid_dtor(_this);
342 if (flags & 1) MSVCRT_operator_delete(_this);
343 }
344 return _this;
345 }
346
347 /******************************************************************
348 * ??_Gbad_typeid@@UAEPAXI@Z (MSVCRT.@)
349 */
350 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_typeid_scalar_dtor,8)
351 void * __thiscall MSVCRT_bad_typeid_scalar_dtor(bad_typeid * _this, unsigned int flags)
352 {
353 TRACE("(%p %x)\n", _this, flags);
354 MSVCRT_bad_typeid_dtor(_this);
355 if (flags & 1) MSVCRT_operator_delete(_this);
356 return _this;
357 }
358
359 /******************************************************************
360 * ??0__non_rtti_object@@QAE@ABV0@@Z (MSVCRT.@)
361 */
362 DEFINE_THISCALL_WRAPPER(MSVCRT___non_rtti_object_copy_ctor,8)
363 __non_rtti_object * __thiscall MSVCRT___non_rtti_object_copy_ctor(__non_rtti_object * _this,
364 const __non_rtti_object * rhs)
365 {
366 TRACE("(%p %p)\n", _this, rhs);
367 MSVCRT_bad_typeid_copy_ctor(_this, rhs);
368 _this->vtable = &MSVCRT___non_rtti_object_vtable;
369 return _this;
370 }
371
372 /******************************************************************
373 * ??0__non_rtti_object@@QAE@PBD@Z (MSVCRT.@)
374 */
375 DEFINE_THISCALL_WRAPPER(MSVCRT___non_rtti_object_ctor,8)
376 __non_rtti_object * __thiscall MSVCRT___non_rtti_object_ctor(__non_rtti_object * _this,
377 const char * name)
378 {
379 TRACE("(%p %s)\n", _this, name);
380 EXCEPTION_ctor(_this, &name);
381 _this->vtable = &MSVCRT___non_rtti_object_vtable;
382 return _this;
383 }
384
385 /******************************************************************
386 * ??1__non_rtti_object@@UAE@XZ (MSVCRT.@)
387 */
388 DEFINE_THISCALL_WRAPPER(MSVCRT___non_rtti_object_dtor,4)
389 void __thiscall MSVCRT___non_rtti_object_dtor(__non_rtti_object * _this)
390 {
391 TRACE("(%p)\n", _this);
392 MSVCRT_bad_typeid_dtor(_this);
393 }
394
395 /******************************************************************
396 * ??4__non_rtti_object@@QAEAAV0@ABV0@@Z (MSVCRT.@)
397 */
398 DEFINE_THISCALL_WRAPPER(MSVCRT___non_rtti_object_opequals,8)
399 __non_rtti_object * __thiscall MSVCRT___non_rtti_object_opequals(__non_rtti_object * _this,
400 const __non_rtti_object *rhs)
401 {
402 TRACE("(%p %p)\n", _this, rhs);
403 MSVCRT_bad_typeid_opequals(_this, rhs);
404 return _this;
405 }
406
407 /******************************************************************
408 * ??_E__non_rtti_object@@UAEPAXI@Z (MSVCRT.@)
409 */
410 DEFINE_THISCALL_WRAPPER(MSVCRT___non_rtti_object_vector_dtor,8)
411 void * __thiscall MSVCRT___non_rtti_object_vector_dtor(__non_rtti_object * _this, unsigned int flags)
412 {
413 TRACE("(%p %x)\n", _this, flags);
414 if (flags & 2)
415 {
416 /* we have an array, with the number of elements stored before the first object */
417 INT_PTR i, *ptr = (INT_PTR *)_this - 1;
418
419 for (i = *ptr - 1; i >= 0; i--) MSVCRT___non_rtti_object_dtor(_this + i);
420 MSVCRT_operator_delete(ptr);
421 }
422 else
423 {
424 MSVCRT___non_rtti_object_dtor(_this);
425 if (flags & 1) MSVCRT_operator_delete(_this);
426 }
427 return _this;
428 }
429
430 /******************************************************************
431 * ??_G__non_rtti_object@@UAEPAXI@Z (MSVCRT.@)
432 */
433 DEFINE_THISCALL_WRAPPER(MSVCRT___non_rtti_object_scalar_dtor,8)
434 void * __thiscall MSVCRT___non_rtti_object_scalar_dtor(__non_rtti_object * _this, unsigned int flags)
435 {
436 TRACE("(%p %x)\n", _this, flags);
437 MSVCRT___non_rtti_object_dtor(_this);
438 if (flags & 1) MSVCRT_operator_delete(_this);
439 return _this;
440 }
441
442 /******************************************************************
443 * ??0bad_cast@@AAE@PBQBD@Z (MSVCRT.@)
444 * ??0bad_cast@@QAE@ABQBD@Z (MSVCRT.@)
445 */
446 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_cast_ctor,8)
447 bad_cast * __thiscall MSVCRT_bad_cast_ctor(bad_cast * _this, const char ** name)
448 {
449 TRACE("(%p %s)\n", _this, *name);
450 EXCEPTION_ctor(_this, name);
451 _this->vtable = &MSVCRT_bad_cast_vtable;
452 return _this;
453 }
454
455 /******************************************************************
456 * ??0bad_cast@@QAE@ABV0@@Z (MSVCRT.@)
457 */
458 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_cast_copy_ctor,8)
459 bad_cast * __thiscall MSVCRT_bad_cast_copy_ctor(bad_cast * _this, const bad_cast * rhs)
460 {
461 TRACE("(%p %p)\n", _this, rhs);
462 MSVCRT_exception_copy_ctor(_this, rhs);
463 _this->vtable = &MSVCRT_bad_cast_vtable;
464 return _this;
465 }
466
467 /******************************************************************
468 * ??0bad_cast@@QAE@PBD@Z (MSVCRT.@)
469 */
470 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_cast_ctor_charptr,8)
471 bad_cast * __thiscall MSVCRT_bad_cast_ctor_charptr(bad_cast * _this, const char * name)
472 {
473 TRACE("(%p %s)\n", _this, name);
474 EXCEPTION_ctor(_this, &name);
475 _this->vtable = &MSVCRT_bad_cast_vtable;
476 return _this;
477 }
478
479 /******************************************************************
480 * ??_Fbad_cast@@QAEXXZ (MSVCRT.@)
481 */
482 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_cast_default_ctor,4)
483 bad_cast * __thiscall MSVCRT_bad_cast_default_ctor(bad_cast * _this)
484 {
485 return MSVCRT_bad_cast_ctor_charptr( _this, "bad cast" );
486 }
487
488 /******************************************************************
489 * ??1bad_cast@@UAE@XZ (MSVCRT.@)
490 */
491 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_cast_dtor,4)
492 void __thiscall MSVCRT_bad_cast_dtor(bad_cast * _this)
493 {
494 TRACE("(%p)\n", _this);
495 MSVCRT_exception_dtor(_this);
496 }
497
498 /******************************************************************
499 * ??4bad_cast@@QAEAAV0@ABV0@@Z (MSVCRT.@)
500 */
501 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_cast_opequals,8)
502 bad_cast * __thiscall MSVCRT_bad_cast_opequals(bad_cast * _this, const bad_cast * rhs)
503 {
504 TRACE("(%p %p)\n", _this, rhs);
505 MSVCRT_exception_opequals(_this, rhs);
506 return _this;
507 }
508
509 /******************************************************************
510 * ??_Ebad_cast@@UAEPAXI@Z (MSVCRT.@)
511 */
512 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_cast_vector_dtor,8)
513 void * __thiscall MSVCRT_bad_cast_vector_dtor(bad_cast * _this, unsigned int flags)
514 {
515 TRACE("(%p %x)\n", _this, flags);
516 if (flags & 2)
517 {
518 /* we have an array, with the number of elements stored before the first object */
519 INT_PTR i, *ptr = (INT_PTR *)_this - 1;
520
521 for (i = *ptr - 1; i >= 0; i--) MSVCRT_bad_cast_dtor(_this + i);
522 MSVCRT_operator_delete(ptr);
523 }
524 else
525 {
526 MSVCRT_bad_cast_dtor(_this);
527 if (flags & 1) MSVCRT_operator_delete(_this);
528 }
529 return _this;
530 }
531
532 /******************************************************************
533 * ??_Gbad_cast@@UAEPAXI@Z (MSVCRT.@)
534 */
535 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_cast_scalar_dtor,8)
536 void * __thiscall MSVCRT_bad_cast_scalar_dtor(bad_cast * _this, unsigned int flags)
537 {
538 TRACE("(%p %x)\n", _this, flags);
539 MSVCRT_bad_cast_dtor(_this);
540 if (flags & 1) MSVCRT_operator_delete(_this);
541 return _this;
542 }
543
544 /******************************************************************
545 * ??8type_info@@QBEHABV0@@Z (MSVCRT.@)
546 */
547 DEFINE_THISCALL_WRAPPER(MSVCRT_type_info_opequals_equals,8)
548 int __thiscall MSVCRT_type_info_opequals_equals(type_info * _this, const type_info * rhs)
549 {
550 int ret = !strcmp(_this->mangled + 1, rhs->mangled + 1);
551 TRACE("(%p %p) returning %d\n", _this, rhs, ret);
552 return ret;
553 }
554
555 /******************************************************************
556 * ??9type_info@@QBEHABV0@@Z (MSVCRT.@)
557 */
558 DEFINE_THISCALL_WRAPPER(MSVCRT_type_info_opnot_equals,8)
559 int __thiscall MSVCRT_type_info_opnot_equals(type_info * _this, const type_info * rhs)
560 {
561 int ret = !!strcmp(_this->mangled + 1, rhs->mangled + 1);
562 TRACE("(%p %p) returning %d\n", _this, rhs, ret);
563 return ret;
564 }
565
566 /******************************************************************
567 * ?before@type_info@@QBEHABV1@@Z (MSVCRT.@)
568 */
569 DEFINE_THISCALL_WRAPPER(MSVCRT_type_info_before,8)
570 int __thiscall MSVCRT_type_info_before(type_info * _this, const type_info * rhs)
571 {
572 int ret = strcmp(_this->mangled + 1, rhs->mangled + 1) < 0;
573 TRACE("(%p %p) returning %d\n", _this, rhs, ret);
574 return ret;
575 }
576
577 /******************************************************************
578 * ??1type_info@@UAE@XZ (MSVCRT.@)
579 */
580 DEFINE_THISCALL_WRAPPER(MSVCRT_type_info_dtor,4)
581 void __thiscall MSVCRT_type_info_dtor(type_info * _this)
582 {
583 TRACE("(%p)\n", _this);
584 MSVCRT_free(_this->name);
585 }
586
587 /******************************************************************
588 * ?name@type_info@@QBEPBDXZ (MSVCRT.@)
589 */
590 DEFINE_THISCALL_WRAPPER(MSVCRT_type_info_name,4)
591 const char * __thiscall MSVCRT_type_info_name(type_info * _this)
592 {
593 if (!_this->name)
594 {
595 /* Create and set the demangled name */
596 /* Note: mangled name in type_info struct always starts with a '.', while
597 * it isn't valid for mangled name.
598 * Is this '.' really part of the mangled name, or has it some other meaning ?
599 */
600 char* name = __unDName(0, _this->mangled + 1, 0,
601 MSVCRT_malloc, MSVCRT_free, UNDNAME_NO_ARGUMENTS | UNDNAME_32_BIT_DECODE);
602 if (name)
603 {
604 unsigned int len = strlen(name);
605
606 /* It seems _unDName may leave blanks at the end of the demangled name */
607 while (len && name[--len] == ' ')
608 name[len] = '\0';
609
610 if (InterlockedCompareExchangePointer((void**)&_this->name, name, NULL))
611 {
612 /* Another thread set this member since we checked above - use it */
613 MSVCRT_free(name);
614 }
615 }
616 }
617 TRACE("(%p) returning %s\n", _this, _this->name);
618 return _this->name;
619 }
620
621 /******************************************************************
622 * ?raw_name@type_info@@QBEPBDXZ (MSVCRT.@)
623 */
624 DEFINE_THISCALL_WRAPPER(MSVCRT_type_info_raw_name,4)
625 const char * __thiscall MSVCRT_type_info_raw_name(type_info * _this)
626 {
627 TRACE("(%p) returning %s\n", _this, _this->mangled);
628 return _this->mangled;
629 }
630
631 /* Unexported */
632 DEFINE_THISCALL_WRAPPER(MSVCRT_type_info_vector_dtor,8)
633 void * __thiscall MSVCRT_type_info_vector_dtor(type_info * _this, unsigned int flags)
634 {
635 TRACE("(%p %x)\n", _this, flags);
636 if (flags & 2)
637 {
638 /* we have an array, with the number of elements stored before the first object */
639 INT_PTR i, *ptr = (INT_PTR *)_this - 1;
640
641 for (i = *ptr - 1; i >= 0; i--) MSVCRT_type_info_dtor(_this + i);
642 MSVCRT_operator_delete(ptr);
643 }
644 else
645 {
646 MSVCRT_type_info_dtor(_this);
647 if (flags & 1) MSVCRT_operator_delete(_this);
648 }
649 return _this;
650 }
651
652 #if _MSVCR_VER >= 80
653
654 typedef exception bad_alloc;
655 extern const vtable_ptr MSVCRT_bad_alloc_vtable;
656
657 static void bad_alloc_ctor(bad_alloc *this, const char **name)
658 {
659 MSVCRT_exception_ctor(this, name);
660 this->vtable = &MSVCRT_bad_alloc_vtable;
661 }
662
663 /* bad_alloc class implementation */
664 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_alloc_copy_ctor,8)
665 bad_alloc * __thiscall MSVCRT_bad_alloc_copy_ctor(bad_alloc * _this, const bad_alloc * rhs)
666 {
667 TRACE("(%p %p)\n", _this, rhs);
668 MSVCRT_exception_copy_ctor(_this, rhs);
669 _this->vtable = &MSVCRT_bad_alloc_vtable;
670 return _this;
671 }
672
673 DEFINE_THISCALL_WRAPPER(MSVCRT_bad_alloc_dtor,4)
674 void __thiscall MSVCRT_bad_alloc_dtor(bad_alloc * _this)
675 {
676 TRACE("(%p)\n", _this);
677 MSVCRT_exception_dtor(_this);
678 }
679
680 #endif /* _MSVCR_VER >= 80 */
681
682 #if _MSVCR_VER >= 100
683
684 typedef struct {
685 exception e;
686 HRESULT hr;
687 } scheduler_resource_allocation_error;
688 extern const vtable_ptr MSVCRT_scheduler_resource_allocation_error_vtable;
689
690 /* ??0scheduler_resource_allocation_error@Concurrency@@QAE@PBDJ@Z */
691 /* ??0scheduler_resource_allocation_error@Concurrency@@QEAA@PEBDJ@Z */
692 DEFINE_THISCALL_WRAPPER(scheduler_resource_allocation_error_ctor_name, 12)
693 scheduler_resource_allocation_error* __thiscall scheduler_resource_allocation_error_ctor_name(
694 scheduler_resource_allocation_error *this, const char *name, HRESULT hr)
695 {
696 TRACE("(%p %s %x)\n", this, wine_dbgstr_a(name), hr);
697 MSVCRT_exception_ctor(&this->e, &name);
698 this->e.vtable = &MSVCRT_scheduler_resource_allocation_error_vtable;
699 this->hr = hr;
700 return this;
701 }
702
703 /* ??0scheduler_resource_allocation_error@Concurrency@@QAE@J@Z */
704 /* ??0scheduler_resource_allocation_error@Concurrency@@QEAA@J@Z */
705 DEFINE_THISCALL_WRAPPER(scheduler_resource_allocation_error_ctor, 8)
706 scheduler_resource_allocation_error* __thiscall scheduler_resource_allocation_error_ctor(
707 scheduler_resource_allocation_error *this, HRESULT hr)
708 {
709 return scheduler_resource_allocation_error_ctor_name(this, NULL, hr);
710 }
711
712 DEFINE_THISCALL_WRAPPER(MSVCRT_scheduler_resource_allocation_error_copy_ctor,8)
713 scheduler_resource_allocation_error* __thiscall MSVCRT_scheduler_resource_allocation_error_copy_ctor(
714 scheduler_resource_allocation_error *this,
715 const scheduler_resource_allocation_error *rhs)
716 {
717 TRACE("(%p,%p)\n", this, rhs);
718
719 if (!rhs->e.do_free)
720 memcpy(this, rhs, sizeof(*this));
721 else
722 scheduler_resource_allocation_error_ctor_name(this, rhs->e.name, rhs->hr);
723 return this;
724 }
725
726 /* ?get_error_code@scheduler_resource_allocation_error@Concurrency@@QBEJXZ */
727 /* ?get_error_code@scheduler_resource_allocation_error@Concurrency@@QEBAJXZ */
728 DEFINE_THISCALL_WRAPPER(scheduler_resource_allocation_error_get_error_code, 4)
729 HRESULT __thiscall scheduler_resource_allocation_error_get_error_code(
730 const scheduler_resource_allocation_error *this)
731 {
732 TRACE("(%p)\n", this);
733 return this->hr;
734 }
735
736 DEFINE_THISCALL_WRAPPER(MSVCRT_scheduler_resource_allocation_error_dtor,4)
737 void __thiscall MSVCRT_scheduler_resource_allocation_error_dtor(
738 scheduler_resource_allocation_error * this)
739 {
740 TRACE("(%p)\n", this);
741 MSVCRT_exception_dtor(&this->e);
742 }
743
744 typedef exception improper_lock;
745 extern const vtable_ptr MSVCRT_improper_lock_vtable;
746
747 /* ??0improper_lock@Concurrency@@QAE@PBD@Z */
748 /* ??0improper_lock@Concurrency@@QEAA@PEBD@Z */
749 DEFINE_THISCALL_WRAPPER(improper_lock_ctor_str, 8)
750 improper_lock* __thiscall improper_lock_ctor_str(improper_lock *this, const char *str)
751 {
752 TRACE("(%p %p)\n", this, str);
753 MSVCRT_exception_ctor(this, &str);
754 this->vtable = &MSVCRT_improper_lock_vtable;
755 return this;
756 }
757
758 /* ??0improper_lock@Concurrency@@QAE@XZ */
759 /* ??0improper_lock@Concurrency@@QEAA@XZ */
760 DEFINE_THISCALL_WRAPPER(improper_lock_ctor, 4)
761 improper_lock* __thiscall improper_lock_ctor(improper_lock *this)
762 {
763 return improper_lock_ctor_str(this, NULL);
764 }
765
766 DEFINE_THISCALL_WRAPPER(MSVCRT_improper_lock_copy_ctor,8)
767 improper_lock * __thiscall MSVCRT_improper_lock_copy_ctor(improper_lock * _this, const improper_lock * rhs)
768 {
769 TRACE("(%p %p)\n", _this, rhs);
770 MSVCRT_exception_copy_ctor(_this, rhs);
771 _this->vtable = &MSVCRT_improper_lock_vtable;
772 return _this;
773 }
774
775 DEFINE_THISCALL_WRAPPER(MSVCRT_improper_lock_dtor,4)
776 void __thiscall MSVCRT_improper_lock_dtor(improper_lock * _this)
777 {
778 TRACE("(%p)\n", _this);
779 MSVCRT_exception_dtor(_this);
780 }
781
782 typedef exception invalid_scheduler_policy_key;
783 extern const vtable_ptr MSVCRT_invalid_scheduler_policy_key_vtable;
784
785 /* ??0invalid_scheduler_policy_key@Concurrency@@QAE@PBD@Z */
786 /* ??0invalid_scheduler_policy_key@Concurrency@@QEAA@PEBD@Z */
787 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_key_ctor_str, 8)
788 invalid_scheduler_policy_key* __thiscall invalid_scheduler_policy_key_ctor_str(
789 invalid_scheduler_policy_key *this, const char *str)
790 {
791 TRACE("(%p %p)\n", this, str);
792 MSVCRT_exception_ctor(this, &str);
793 this->vtable = &MSVCRT_invalid_scheduler_policy_key_vtable;
794 return this;
795 }
796
797 /* ??0invalid_scheduler_policy_key@Concurrency@@QAE@XZ */
798 /* ??0invalid_scheduler_policy_key@Concurrency@@QEAA@XZ */
799 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_key_ctor, 4)
800 invalid_scheduler_policy_key* __thiscall invalid_scheduler_policy_key_ctor(
801 invalid_scheduler_policy_key *this)
802 {
803 return invalid_scheduler_policy_key_ctor_str(this, NULL);
804 }
805
806 DEFINE_THISCALL_WRAPPER(MSVCRT_invalid_scheduler_policy_key_copy_ctor,8)
807 invalid_scheduler_policy_key * __thiscall MSVCRT_invalid_scheduler_policy_key_copy_ctor(
808 invalid_scheduler_policy_key * _this, const invalid_scheduler_policy_key * rhs)
809 {
810 TRACE("(%p %p)\n", _this, rhs);
811 MSVCRT_exception_copy_ctor(_this, rhs);
812 _this->vtable = &MSVCRT_invalid_scheduler_policy_key_vtable;
813 return _this;
814 }
815
816 DEFINE_THISCALL_WRAPPER(MSVCRT_invalid_scheduler_policy_key_dtor,4)
817 void __thiscall MSVCRT_invalid_scheduler_policy_key_dtor(
818 invalid_scheduler_policy_key * _this)
819 {
820 TRACE("(%p)\n", _this);
821 MSVCRT_exception_dtor(_this);
822 }
823
824 typedef exception invalid_scheduler_policy_value;
825 extern const vtable_ptr MSVCRT_invalid_scheduler_policy_value_vtable;
826
827 /* ??0invalid_scheduler_policy_value@Concurrency@@QAE@PBD@Z */
828 /* ??0invalid_scheduler_policy_value@Concurrency@@QEAA@PEBD@Z */
829 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_value_ctor_str, 8)
830 invalid_scheduler_policy_value* __thiscall invalid_scheduler_policy_value_ctor_str(
831 invalid_scheduler_policy_value *this, const char *str)
832 {
833 TRACE("(%p %p)\n", this, str);
834 MSVCRT_exception_ctor(this, &str);
835 this->vtable = &MSVCRT_invalid_scheduler_policy_value_vtable;
836 return this;
837 }
838
839 /* ??0invalid_scheduler_policy_value@Concurrency@@QAE@XZ */
840 /* ??0invalid_scheduler_policy_value@Concurrency@@QEAA@XZ */
841 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_value_ctor, 4)
842 invalid_scheduler_policy_value* __thiscall invalid_scheduler_policy_value_ctor(
843 invalid_scheduler_policy_value *this)
844 {
845 return invalid_scheduler_policy_value_ctor_str(this, NULL);
846 }
847
848 DEFINE_THISCALL_WRAPPER(MSVCRT_invalid_scheduler_policy_value_copy_ctor,8)
849 invalid_scheduler_policy_value * __thiscall MSVCRT_invalid_scheduler_policy_value_copy_ctor(
850 invalid_scheduler_policy_value * _this, const invalid_scheduler_policy_value * rhs)
851 {
852 TRACE("(%p %p)\n", _this, rhs);
853 MSVCRT_exception_copy_ctor(_this, rhs);
854 _this->vtable = &MSVCRT_invalid_scheduler_policy_value_vtable;
855 return _this;
856 }
857
858 DEFINE_THISCALL_WRAPPER(MSVCRT_invalid_scheduler_policy_value_dtor,4)
859 void __thiscall MSVCRT_invalid_scheduler_policy_value_dtor(
860 invalid_scheduler_policy_value * _this)
861 {
862 TRACE("(%p)\n", _this);
863 MSVCRT_exception_dtor(_this);
864 }
865
866 typedef exception invalid_scheduler_policy_thread_specification;
867 extern const vtable_ptr MSVCRT_invalid_scheduler_policy_thread_specification_vtable;
868
869 /* ??0invalid_scheduler_policy_thread_specification@Concurrency@@QAE@PBD@Z */
870 /* ??0invalid_scheduler_policy_thread_specification@Concurrency@@QEAA@PEBD@Z */
871 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_thread_specification_ctor_str, 8)
872 invalid_scheduler_policy_thread_specification* __thiscall invalid_scheduler_policy_thread_specification_ctor_str(
873 invalid_scheduler_policy_thread_specification *this, const char *str)
874 {
875 TRACE("(%p %p)\n", this, str);
876 MSVCRT_exception_ctor(this, &str);
877 this->vtable = &MSVCRT_invalid_scheduler_policy_thread_specification_vtable;
878 return this;
879 }
880
881 /* ??0invalid_scheduler_policy_thread_specification@Concurrency@@QAE@XZ */
882 /* ??0invalid_scheduler_policy_thread_specification@Concurrency@@QEAA@XZ */
883 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_thread_specification_ctor, 4)
884 invalid_scheduler_policy_thread_specification* __thiscall invalid_scheduler_policy_thread_specification_ctor(
885 invalid_scheduler_policy_thread_specification *this)
886 {
887 return invalid_scheduler_policy_thread_specification_ctor_str(this, NULL);
888 }
889
890 DEFINE_THISCALL_WRAPPER(MSVCRT_invalid_scheduler_policy_thread_specification_copy_ctor,8)
891 invalid_scheduler_policy_thread_specification * __thiscall MSVCRT_invalid_scheduler_policy_thread_specification_copy_ctor(
892 invalid_scheduler_policy_thread_specification * _this, const invalid_scheduler_policy_thread_specification * rhs)
893 {
894 TRACE("(%p %p)\n", _this, rhs);
895 MSVCRT_exception_copy_ctor(_this, rhs);
896 _this->vtable = &MSVCRT_invalid_scheduler_policy_thread_specification_vtable;
897 return _this;
898 }
899
900 DEFINE_THISCALL_WRAPPER(MSVCRT_invalid_scheduler_policy_thread_specification_dtor,4)
901 void __thiscall MSVCRT_invalid_scheduler_policy_thread_specification_dtor(
902 invalid_scheduler_policy_thread_specification * _this)
903 {
904 TRACE("(%p)\n", _this);
905 MSVCRT_exception_dtor(_this);
906 }
907
908 typedef exception improper_scheduler_attach;
909 extern const vtable_ptr MSVCRT_improper_scheduler_attach_vtable;
910
911 /* ??0improper_scheduler_attach@Concurrency@@QAE@PBD@Z */
912 /* ??0improper_scheduler_attach@Concurrency@@QEAA@PEBD@Z */
913 DEFINE_THISCALL_WRAPPER(improper_scheduler_attach_ctor_str, 8)
914 improper_scheduler_attach* __thiscall improper_scheduler_attach_ctor_str(
915 improper_scheduler_attach *this, const char *str)
916 {
917 TRACE("(%p %p)\n", this, str);
918 MSVCRT_exception_ctor(this, &str);
919 this->vtable = &MSVCRT_improper_scheduler_attach_vtable;
920 return this;
921 }
922
923 /* ??0improper_scheduler_attach@Concurrency@@QAE@XZ */
924 /* ??0improper_scheduler_attach@Concurrency@@QEAA@XZ */
925 DEFINE_THISCALL_WRAPPER(improper_scheduler_attach_ctor, 4)
926 improper_scheduler_attach* __thiscall improper_scheduler_attach_ctor(
927 improper_scheduler_attach *this)
928 {
929 return improper_scheduler_attach_ctor_str(this, NULL);
930 }
931
932 DEFINE_THISCALL_WRAPPER(MSVCRT_improper_scheduler_attach_copy_ctor,8)
933 improper_scheduler_attach * __thiscall MSVCRT_improper_scheduler_attach_copy_ctor(
934 improper_scheduler_attach * _this, const improper_scheduler_attach * rhs)
935 {
936 TRACE("(%p %p)\n", _this, rhs);
937 MSVCRT_exception_copy_ctor(_this, rhs);
938 _this->vtable = &MSVCRT_improper_scheduler_attach_vtable;
939 return _this;
940 }
941
942 DEFINE_THISCALL_WRAPPER(MSVCRT_improper_scheduler_attach_dtor,4)
943 void __thiscall MSVCRT_improper_scheduler_attach_dtor(
944 improper_scheduler_attach * _this)
945 {
946 TRACE("(%p)\n", _this);
947 MSVCRT_exception_dtor(_this);
948 }
949
950 typedef exception improper_scheduler_detach;
951 extern const vtable_ptr MSVCRT_improper_scheduler_detach_vtable;
952
953 /* ??0improper_scheduler_detach@Concurrency@@QAE@PBD@Z */
954 /* ??0improper_scheduler_detach@Concurrency@@QEAA@PEBD@Z */
955 DEFINE_THISCALL_WRAPPER(improper_scheduler_detach_ctor_str, 8)
956 improper_scheduler_detach* __thiscall improper_scheduler_detach_ctor_str(
957 improper_scheduler_detach *this, const char *str)
958 {
959 TRACE("(%p %p)\n", this, str);
960 MSVCRT_exception_ctor(this, &str);
961 this->vtable = &MSVCRT_improper_scheduler_detach_vtable;
962 return this;
963 }
964
965 /* ??0improper_scheduler_detach@Concurrency@@QAE@XZ */
966 /* ??0improper_scheduler_detach@Concurrency@@QEAA@XZ */
967 DEFINE_THISCALL_WRAPPER(improper_scheduler_detach_ctor, 4)
968 improper_scheduler_detach* __thiscall improper_scheduler_detach_ctor(
969 improper_scheduler_detach *this)
970 {
971 return improper_scheduler_detach_ctor_str(this, NULL);
972 }
973
974 DEFINE_THISCALL_WRAPPER(MSVCRT_improper_scheduler_detach_copy_ctor,8)
975 improper_scheduler_detach * __thiscall MSVCRT_improper_scheduler_detach_copy_ctor(
976 improper_scheduler_detach * _this, const improper_scheduler_detach * rhs)
977 {
978 TRACE("(%p %p)\n", _this, rhs);
979 MSVCRT_exception_copy_ctor(_this, rhs);
980 _this->vtable = &MSVCRT_improper_scheduler_detach_vtable;
981 return _this;
982 }
983
984 DEFINE_THISCALL_WRAPPER(MSVCRT_improper_scheduler_detach_dtor,4)
985 void __thiscall MSVCRT_improper_scheduler_detach_dtor(
986 improper_scheduler_detach * _this)
987 {
988 TRACE("(%p)\n", _this);
989 MSVCRT_exception_dtor(_this);
990 }
991
992 #endif /* _MSVCR_VER >= 100 */
993
994 __ASM_BLOCK_BEGIN(vtables)
995
996 __ASM_VTABLE(type_info,
997 VTABLE_ADD_FUNC(MSVCRT_type_info_vector_dtor));
998 __ASM_VTABLE(exception,
999 VTABLE_ADD_FUNC(MSVCRT_exception_vector_dtor)
1000 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1001 #if _MSVCR_VER >= 80
1002 __ASM_VTABLE(exception_old,
1003 VTABLE_ADD_FUNC(MSVCRT_exception_vector_dtor)
1004 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1005 __ASM_VTABLE(bad_alloc,
1006 VTABLE_ADD_FUNC(MSVCRT_exception_vector_dtor)
1007 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1008 #endif
1009 __ASM_VTABLE(bad_typeid,
1010 VTABLE_ADD_FUNC(MSVCRT_bad_typeid_vector_dtor)
1011 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1012 __ASM_VTABLE(bad_cast,
1013 VTABLE_ADD_FUNC(MSVCRT_bad_cast_vector_dtor)
1014 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1015 __ASM_VTABLE(__non_rtti_object,
1016 VTABLE_ADD_FUNC(MSVCRT___non_rtti_object_vector_dtor)
1017 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1018 #if _MSVCR_VER >= 100
1019 __ASM_VTABLE(scheduler_resource_allocation_error,
1020 VTABLE_ADD_FUNC(MSVCRT_exception_vector_dtor)
1021 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1022 __ASM_VTABLE(improper_lock,
1023 VTABLE_ADD_FUNC(MSVCRT_exception_vector_dtor)
1024 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1025 __ASM_VTABLE(invalid_scheduler_policy_key,
1026 VTABLE_ADD_FUNC(MSVCRT_exception_vector_dtor)
1027 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1028 __ASM_VTABLE(invalid_scheduler_policy_value,
1029 VTABLE_ADD_FUNC(MSVCRT_exception_vector_dtor)
1030 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1031 __ASM_VTABLE(invalid_scheduler_policy_thread_specification,
1032 VTABLE_ADD_FUNC(MSVCRT_exception_vector_dtor)
1033 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1034 __ASM_VTABLE(improper_scheduler_attach,
1035 VTABLE_ADD_FUNC(MSVCRT_exception_vector_dtor)
1036 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1037 __ASM_VTABLE(improper_scheduler_detach,
1038 VTABLE_ADD_FUNC(MSVCRT_exception_vector_dtor)
1039 VTABLE_ADD_FUNC(MSVCRT_what_exception));
1040 #endif
1041
1042 __ASM_BLOCK_END
1043
1044 DEFINE_RTTI_DATA0( type_info, 0, ".?AVtype_info@@" )
1045 #if _MSVCR_VER >= 80
1046 DEFINE_RTTI_DATA0( exception, 0, ".?AVexception@std@@" )
1047 DEFINE_RTTI_DATA0( exception_old, 0, ".?AVexception@@" )
1048 DEFINE_RTTI_DATA1( bad_typeid, 0, &exception_rtti_base_descriptor, ".?AVbad_typeid@std@@" )
1049 DEFINE_RTTI_DATA1( bad_cast, 0, &exception_rtti_base_descriptor, ".?AVbad_cast@std@@" )
1050 DEFINE_RTTI_DATA2( __non_rtti_object, 0, &bad_typeid_rtti_base_descriptor, &exception_rtti_base_descriptor, ".?AV__non_rtti_object@std@@" )
1051 DEFINE_RTTI_DATA1( bad_alloc, 0, &exception_rtti_base_descriptor, ".?AVbad_alloc@std@@" )
1052 #else
1053 DEFINE_RTTI_DATA0( exception, 0, ".?AVexception@@" )
1054 DEFINE_RTTI_DATA1( bad_typeid, 0, &exception_rtti_base_descriptor, ".?AVbad_typeid@@" )
1055 DEFINE_RTTI_DATA1( bad_cast, 0, &exception_rtti_base_descriptor, ".?AVbad_cast@@" )
1056 DEFINE_RTTI_DATA2( __non_rtti_object, 0, &bad_typeid_rtti_base_descriptor, &exception_rtti_base_descriptor, ".?AV__non_rtti_object@@" )
1057 #endif
1058 #if _MSVCR_VER >= 100
1059 DEFINE_RTTI_DATA1(scheduler_resource_allocation_error, 0, &exception_rtti_base_descriptor,
1060 ".?AVscheduler_resource_allocation_error@Concurrency@@")
1061 DEFINE_RTTI_DATA1(improper_lock, 0, &exception_rtti_base_descriptor, ".?AVimproper_lock@Concurrency@@" )
1062 DEFINE_RTTI_DATA1(invalid_scheduler_policy_key, 0, &exception_rtti_base_descriptor,
1063 ".?AVinvalid_scheduler_policy_key@Concurrency@@" )
1064 DEFINE_RTTI_DATA1(invalid_scheduler_policy_value, 0, &exception_rtti_base_descriptor,
1065 ".?AVinvalid_scheduler_policy_value@Concurrency@@" )
1066 DEFINE_RTTI_DATA1(invalid_scheduler_policy_thread_specification, 0, &exception_rtti_base_descriptor,
1067 ".?AVinvalid_scheduler_policy_thread_specification@Concurrency@@" )
1068 DEFINE_RTTI_DATA1(improper_scheduler_attach, 0, &exception_rtti_base_descriptor,
1069 ".?AVimproper_scheduler_attach@Concurrency@@" )
1070 DEFINE_RTTI_DATA1(improper_scheduler_detach, 0, &exception_rtti_base_descriptor,
1071 ".?AVimproper_scheduler_detach@Concurrency@@" )
1072 #endif
1073
1074 DEFINE_EXCEPTION_TYPE_INFO( exception, 0, NULL, NULL )
1075 DEFINE_EXCEPTION_TYPE_INFO( bad_typeid, 1, &exception_cxx_type_info, NULL )
1076 DEFINE_EXCEPTION_TYPE_INFO( bad_cast, 1, &exception_cxx_type_info, NULL )
1077 DEFINE_EXCEPTION_TYPE_INFO( __non_rtti_object, 2, &bad_typeid_cxx_type_info, &exception_cxx_type_info )
1078 #if _MSVCR_VER >= 80
1079 DEFINE_EXCEPTION_TYPE_INFO( bad_alloc, 1, &exception_cxx_type_info, NULL )
1080 #endif
1081 #if _MSVCR_VER >= 100
1082 DEFINE_EXCEPTION_TYPE_INFO(scheduler_resource_allocation_error, 1, &exception_cxx_type_info, NULL)
1083 DEFINE_EXCEPTION_TYPE_INFO(improper_lock, 1, &exception_cxx_type_info, NULL)
1084 DEFINE_EXCEPTION_TYPE_INFO(invalid_scheduler_policy_key, 1, &exception_cxx_type_info, NULL)
1085 DEFINE_EXCEPTION_TYPE_INFO(invalid_scheduler_policy_value, 1, &exception_cxx_type_info, NULL)
1086 DEFINE_EXCEPTION_TYPE_INFO(invalid_scheduler_policy_thread_specification, 1, &exception_cxx_type_info, NULL)
1087 DEFINE_EXCEPTION_TYPE_INFO(improper_scheduler_attach, 1, &exception_cxx_type_info, NULL)
1088 DEFINE_EXCEPTION_TYPE_INFO(improper_scheduler_detach, 1, &exception_cxx_type_info, NULL)
1089 #endif
1090
1091 void msvcrt_init_exception(void *base)
1092 {
1093 #ifdef __x86_64__
1094 init_type_info_rtti(base);
1095 init_exception_rtti(base);
1096 #if _MSVCR_VER >= 80
1097 init_exception_old_rtti(base);
1098 init_bad_alloc_rtti(base);
1099 #endif
1100 init_bad_typeid_rtti(base);
1101 init_bad_cast_rtti(base);
1102 init___non_rtti_object_rtti(base);
1103 #if _MSVCR_VER >= 100
1104 init_scheduler_resource_allocation_error_rtti(base);
1105 init_improper_lock_rtti(base);
1106 init_invalid_scheduler_policy_key_rtti(base);
1107 init_invalid_scheduler_policy_value_rtti(base);
1108 init_invalid_scheduler_policy_thread_specification_rtti(base);
1109 init_improper_scheduler_attach_rtti(base);
1110 init_improper_scheduler_detach_rtti(base);
1111 #endif
1112
1113 init_exception_cxx(base);
1114 init_bad_typeid_cxx(base);
1115 init_bad_cast_cxx(base);
1116 init___non_rtti_object_cxx(base);
1117 #if _MSVCR_VER >= 80
1118 init_bad_alloc_cxx(base);
1119 #endif
1120 #if _MSVCR_VER >= 100
1121 init_scheduler_resource_allocation_error_cxx(base);
1122 init_improper_lock_cxx(base);
1123 init_invalid_scheduler_policy_key_cxx(base);
1124 init_invalid_scheduler_policy_value_cxx(base);
1125 init_invalid_scheduler_policy_thread_specification_cxx(base);
1126 init_improper_scheduler_attach_cxx(base);
1127 init_improper_scheduler_detach_cxx(base);
1128 #endif
1129 #endif
1130 }
1131
1132 #if _MSVCR_VER >= 80
1133 void throw_exception(exception_type et, HRESULT hr, const char *str)
1134 {
1135 switch(et) {
1136 case EXCEPTION_BAD_ALLOC: {
1137 bad_alloc e;
1138 bad_alloc_ctor(&e, &str);
1139 _CxxThrowException(&e, &bad_alloc_exception_type);
1140 }
1141 #if _MSVCR_VER >= 100
1142 case EXCEPTION_SCHEDULER_RESOURCE_ALLOCATION_ERROR: {
1143 scheduler_resource_allocation_error e;
1144 scheduler_resource_allocation_error_ctor_name(&e, str, hr);
1145 _CxxThrowException(&e.e, &scheduler_resource_allocation_error_exception_type);
1146 }
1147 case EXCEPTION_IMPROPER_LOCK: {
1148 improper_lock e;
1149 improper_lock_ctor_str(&e, str);
1150 _CxxThrowException(&e, &improper_lock_exception_type);
1151 }
1152 case EXCEPTION_INVALID_SCHEDULER_POLICY_KEY: {
1153 invalid_scheduler_policy_key e;
1154 invalid_scheduler_policy_key_ctor_str(&e, str);
1155 _CxxThrowException(&e, &invalid_scheduler_policy_key_exception_type);
1156 }
1157 case EXCEPTION_INVALID_SCHEDULER_POLICY_VALUE: {
1158 invalid_scheduler_policy_value e;
1159 invalid_scheduler_policy_value_ctor_str(&e, str);
1160 _CxxThrowException(&e, &invalid_scheduler_policy_value_exception_type);
1161 }
1162 case EXCEPTION_INVALID_SCHEDULER_POLICY_THREAD_SPECIFICATION: {
1163 invalid_scheduler_policy_thread_specification e;
1164 invalid_scheduler_policy_thread_specification_ctor_str(&e, str);
1165 _CxxThrowException(&e, &invalid_scheduler_policy_thread_specification_exception_type);
1166 }
1167 case EXCEPTION_IMPROPER_SCHEDULER_ATTACH: {
1168 improper_scheduler_attach e;
1169 improper_scheduler_attach_ctor_str(&e, str);
1170 _CxxThrowException(&e, &improper_scheduler_attach_exception_type);
1171 }
1172 case EXCEPTION_IMPROPER_SCHEDULER_DETACH: {
1173 improper_scheduler_detach e;
1174 improper_scheduler_detach_ctor_str(&e, str);
1175 _CxxThrowException(&e, &improper_scheduler_detach_exception_type);
1176 }
1177 #endif
1178 }
1179 }
1180 #endif
1181
1182 /******************************************************************
1183 * ?set_terminate@@YAP6AXXZP6AXXZ@Z (MSVCRT.@)
1184 *
1185 * Install a handler to be called when terminate() is called.
1186 *
1187 * PARAMS
1188 * func [I] Handler function to install
1189 *
1190 * RETURNS
1191 * The previously installed handler function, if any.
1192 */
1193 MSVCRT_terminate_function CDECL MSVCRT_set_terminate(MSVCRT_terminate_function func)
1194 {
1195 thread_data_t *data = msvcrt_get_thread_data();
1196 MSVCRT_terminate_function previous = data->terminate_handler;
1197 TRACE("(%p) returning %p\n",func,previous);
1198 data->terminate_handler = func;
1199 return previous;
1200 }
1201
1202 /******************************************************************
1203 * _get_terminate (MSVCRT.@)
1204 */
1205 MSVCRT_terminate_function CDECL MSVCRT__get_terminate(void)
1206 {
1207 thread_data_t *data = msvcrt_get_thread_data();
1208 TRACE("returning %p\n", data->terminate_handler);
1209 return data->terminate_handler;
1210 }
1211
1212 /******************************************************************
1213 * ?set_unexpected@@YAP6AXXZP6AXXZ@Z (MSVCRT.@)
1214 *
1215 * Install a handler to be called when unexpected() is called.
1216 *
1217 * PARAMS
1218 * func [I] Handler function to install
1219 *
1220 * RETURNS
1221 * The previously installed handler function, if any.
1222 */
1223 MSVCRT_unexpected_function CDECL MSVCRT_set_unexpected(MSVCRT_unexpected_function func)
1224 {
1225 thread_data_t *data = msvcrt_get_thread_data();
1226 MSVCRT_unexpected_function previous = data->unexpected_handler;
1227 TRACE("(%p) returning %p\n",func,previous);
1228 data->unexpected_handler = func;
1229 return previous;
1230 }
1231
1232 /******************************************************************
1233 * _get_unexpected (MSVCRT.@)
1234 */
1235 MSVCRT_unexpected_function CDECL MSVCRT__get_unexpected(void)
1236 {
1237 thread_data_t *data = msvcrt_get_thread_data();
1238 TRACE("returning %p\n", data->unexpected_handler);
1239 return data->unexpected_handler;
1240 }
1241
1242 /******************************************************************
1243 * ?_set_se_translator@@YAP6AXIPAU_EXCEPTION_POINTERS@@@ZP6AXI0@Z@Z (MSVCRT.@)
1244 */
1245 MSVCRT__se_translator_function CDECL MSVCRT__set_se_translator(MSVCRT__se_translator_function func)
1246 {
1247 thread_data_t *data = msvcrt_get_thread_data();
1248 MSVCRT__se_translator_function previous = data->se_translator;
1249 TRACE("(%p) returning %p\n",func,previous);
1250 data->se_translator = func;
1251 return previous;
1252 }
1253
1254 /******************************************************************
1255 * ?terminate@@YAXXZ (MSVCRT.@)
1256 *
1257 * Default handler for an unhandled exception.
1258 *
1259 * PARAMS
1260 * None.
1261 *
1262 * RETURNS
1263 * This function does not return. Either control resumes from any
1264 * handler installed by calling set_terminate(), or (by default) abort()
1265 * is called.
1266 */
1267 void CDECL MSVCRT_terminate(void)
1268 {
1269 thread_data_t *data = msvcrt_get_thread_data();
1270 if (data->terminate_handler) data->terminate_handler();
1271 MSVCRT_abort();
1272 }
1273
1274 /******************************************************************
1275 * ?unexpected@@YAXXZ (MSVCRT.@)
1276 */
1277 void CDECL MSVCRT_unexpected(void)
1278 {
1279 thread_data_t *data = msvcrt_get_thread_data();
1280 if (data->unexpected_handler) data->unexpected_handler();
1281 MSVCRT_terminate();
1282 }
1283
1284
1285 /******************************************************************
1286 * __RTtypeid (MSVCRT.@)
1287 *
1288 * Retrieve the Run Time Type Information (RTTI) for a C++ object.
1289 *
1290 * PARAMS
1291 * cppobj [I] C++ object to get type information for.
1292 *
1293 * RETURNS
1294 * Success: A type_info object describing cppobj.
1295 * Failure: If the object to be cast has no RTTI, a __non_rtti_object
1296 * exception is thrown. If cppobj is NULL, a bad_typeid exception
1297 * is thrown. In either case, this function does not return.
1298 *
1299 * NOTES
1300 * This function is usually called by compiler generated code as a result
1301 * of using one of the C++ dynamic cast statements.
1302 */
1303 #ifndef __x86_64__
1304 const type_info* CDECL MSVCRT___RTtypeid(void *cppobj)
1305 {
1306 const type_info *ret;
1307
1308 if (!cppobj)
1309 {
1310 bad_typeid e;
1311 MSVCRT_bad_typeid_ctor( &e, "Attempted a typeid of NULL pointer!" );
1312 _CxxThrowException( &e, &bad_typeid_exception_type );
1313 return NULL;
1314 }
1315
1316 __TRY
1317 {
1318 const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
1319 ret = obj_locator->type_descriptor;
1320 }
1321 __EXCEPT_PAGE_FAULT
1322 {
1323 __non_rtti_object e;
1324 MSVCRT___non_rtti_object_ctor( &e, "Bad read pointer - no RTTI data!" );
1325 _CxxThrowException( &e, &__non_rtti_object_exception_type );
1326 return NULL;
1327 }
1328 __ENDTRY
1329 return ret;
1330 }
1331
1332 #else
1333
1334 const type_info* CDECL MSVCRT___RTtypeid(void *cppobj)
1335 {
1336 const type_info *ret;
1337
1338 if (!cppobj)
1339 {
1340 bad_typeid e;
1341 MSVCRT_bad_typeid_ctor( &e, "Attempted a typeid of NULL pointer!" );
1342 _CxxThrowException( &e, &bad_typeid_exception_type );
1343 return NULL;
1344 }
1345
1346 __TRY
1347 {
1348 const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
1349 char *base;
1350
1351 if(obj_locator->signature == 0)
1352 base = RtlPcToFileHeader((void*)obj_locator, (void**)&base);
1353 else
1354 base = (char*)obj_locator - obj_locator->object_locator;
1355
1356 ret = (type_info*)(base + obj_locator->type_descriptor);
1357 }
1358 __EXCEPT_PAGE_FAULT
1359 {
1360 __non_rtti_object e;
1361 MSVCRT___non_rtti_object_ctor( &e, "Bad read pointer - no RTTI data!" );
1362 _CxxThrowException( &e, &__non_rtti_object_exception_type );
1363 return NULL;
1364 }
1365 __ENDTRY
1366 return ret;
1367 }
1368 #endif
1369
1370 /******************************************************************
1371 * __RTDynamicCast (MSVCRT.@)
1372 *
1373 * Dynamically cast a C++ object to one of its base classes.
1374 *
1375 * PARAMS
1376 * cppobj [I] Any C++ object to cast
1377 * unknown [I] Reserved, set to 0
1378 * src [I] type_info object describing cppobj
1379 * dst [I] type_info object describing the base class to cast to
1380 * do_throw [I] TRUE = throw an exception if the cast fails, FALSE = don't
1381 *
1382 * RETURNS
1383 * Success: The address of cppobj, cast to the object described by dst.
1384 * Failure: NULL, If the object to be cast has no RTTI, or dst is not a
1385 * valid cast for cppobj. If do_throw is TRUE, a bad_cast exception
1386 * is thrown and this function does not return.
1387 *
1388 * NOTES
1389 * This function is usually called by compiler generated code as a result
1390 * of using one of the C++ dynamic cast statements.
1391 */
1392 #ifndef __x86_64__
1393 void* CDECL MSVCRT___RTDynamicCast(void *cppobj, int unknown,
1394 type_info *src, type_info *dst,
1395 int do_throw)
1396 {
1397 void *ret;
1398
1399 if (!cppobj) return NULL;
1400
1401 TRACE("obj: %p unknown: %d src: %p %s dst: %p %s do_throw: %d)\n",
1402 cppobj, unknown, src, dbgstr_type_info(src), dst, dbgstr_type_info(dst), do_throw);
1403
1404 /* To cast an object at runtime:
1405 * 1.Find out the true type of the object from the typeinfo at vtable[-1]
1406 * 2.Search for the destination type in the class hierarchy
1407 * 3.If destination type is found, return base object address + dest offset
1408 * Otherwise, fail the cast
1409 *
1410 * FIXME: the unknown parameter doesn't seem to be used for anything
1411 */
1412 __TRY
1413 {
1414 int i;
1415 const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
1416 const rtti_object_hierarchy *obj_bases = obj_locator->type_hierarchy;
1417 const rtti_base_descriptor * const* base_desc = obj_bases->base_classes->bases;
1418
1419 if (TRACE_ON(msvcrt)) dump_obj_locator(obj_locator);
1420
1421 ret = NULL;
1422 for (i = 0; i < obj_bases->array_len; i++)
1423 {
1424 const type_info *typ = base_desc[i]->type_descriptor;
1425
1426 if (!strcmp(typ->mangled, dst->mangled))
1427 {
1428 /* compute the correct this pointer for that base class */
1429 void *this_ptr = (char *)cppobj - obj_locator->base_class_offset;
1430 ret = get_this_pointer( &base_desc[i]->offsets, this_ptr );
1431 break;
1432 }
1433 }
1434 /* VC++ sets do_throw to 1 when the result of a dynamic_cast is assigned
1435 * to a reference, since references cannot be NULL.
1436 */
1437 if (!ret && do_throw)
1438 {
1439 const char *msg = "Bad dynamic_cast!";
1440 bad_cast e;
1441 MSVCRT_bad_cast_ctor( &e, &msg );
1442 _CxxThrowException( &e, &bad_cast_exception_type );
1443 }
1444 }
1445 __EXCEPT_PAGE_FAULT
1446 {
1447 __non_rtti_object e;
1448 MSVCRT___non_rtti_object_ctor( &e, "Access violation - no RTTI data!" );
1449 _CxxThrowException( &e, &__non_rtti_object_exception_type );
1450 return NULL;
1451 }
1452 __ENDTRY
1453 return ret;
1454 }
1455
1456 #else
1457
1458 void* CDECL MSVCRT___RTDynamicCast(void *cppobj, int unknown,
1459 type_info *src, type_info *dst,
1460 int do_throw)
1461 {
1462 void *ret;
1463
1464 if (!cppobj) return NULL;
1465
1466 TRACE("obj: %p unknown: %d src: %p %s dst: %p %s do_throw: %d)\n",
1467 cppobj, unknown, src, dbgstr_type_info(src), dst, dbgstr_type_info(dst), do_throw);
1468
1469 __TRY
1470 {
1471 int i;
1472 const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
1473 const rtti_object_hierarchy *obj_bases;
1474 const rtti_base_array *base_array;
1475 char *base;
1476
1477 if (TRACE_ON(msvcrt)) dump_obj_locator(obj_locator);
1478
1479 if(obj_locator->signature == 0)
1480 base = RtlPcToFileHeader((void*)obj_locator, (void**)&base);
1481 else
1482 base = (char*)obj_locator - obj_locator->object_locator;
1483
1484 obj_bases = (const rtti_object_hierarchy*)(base + obj_locator->type_hierarchy);
1485 base_array = (const rtti_base_array*)(base + obj_bases->base_classes);
1486
1487 ret = NULL;
1488 for (i = 0; i < obj_bases->array_len; i++)
1489 {
1490 const rtti_base_descriptor *base_desc = (const rtti_base_descriptor*)(base + base_array->bases[i]);
1491 const type_info *typ = (const type_info*)(base + base_desc->type_descriptor);
1492
1493 if (!strcmp(typ->mangled, dst->mangled))
1494 {
1495 void *this_ptr = (char *)cppobj - obj_locator->base_class_offset;
1496 ret = get_this_pointer( &base_desc->offsets, this_ptr );
1497 break;
1498 }
1499 }
1500 if (!ret && do_throw)
1501 {
1502 const char *msg = "Bad dynamic_cast!";
1503 bad_cast e;
1504 MSVCRT_bad_cast_ctor( &e, &msg );
1505 _CxxThrowException( &e, &bad_cast_exception_type );
1506 }
1507 }
1508 __EXCEPT_PAGE_FAULT
1509 {
1510 __non_rtti_object e;
1511 MSVCRT___non_rtti_object_ctor( &e, "Access violation - no RTTI data!" );
1512 _CxxThrowException( &e, &__non_rtti_object_exception_type );
1513 return NULL;
1514 }
1515 __ENDTRY
1516 return ret;
1517 }
1518 #endif
1519
1520
1521 /******************************************************************
1522 * __RTCastToVoid (MSVCRT.@)
1523 *
1524 * Dynamically cast a C++ object to a void*.
1525 *
1526 * PARAMS
1527 * cppobj [I] The C++ object to cast
1528 *
1529 * RETURNS
1530 * Success: The base address of the object as a void*.
1531 * Failure: NULL, if cppobj is NULL or has no RTTI.
1532 *
1533 * NOTES
1534 * This function is usually called by compiler generated code as a result
1535 * of using one of the C++ dynamic cast statements.
1536 */
1537 void* CDECL MSVCRT___RTCastToVoid(void *cppobj)
1538 {
1539 void *ret;
1540
1541 if (!cppobj) return NULL;
1542
1543 __TRY
1544 {
1545 const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
1546 ret = (char *)cppobj - obj_locator->base_class_offset;
1547 }
1548 __EXCEPT_PAGE_FAULT
1549 {
1550 __non_rtti_object e;
1551 MSVCRT___non_rtti_object_ctor( &e, "Access violation - no RTTI data!" );
1552 _CxxThrowException( &e, &__non_rtti_object_exception_type );
1553 return NULL;
1554 }
1555 __ENDTRY
1556 return ret;
1557 }
1558
1559
1560 /*********************************************************************
1561 * _CxxThrowException (MSVCRT.@)
1562 */
1563 #ifndef __x86_64__
1564 void WINAPI _CxxThrowException( exception *object, const cxx_exception_type *type )
1565 {
1566 ULONG_PTR args[3];
1567
1568 args[0] = CXX_FRAME_MAGIC_VC6;
1569 args[1] = (ULONG_PTR)object;
1570 args[2] = (ULONG_PTR)type;
1571 RaiseException( CXX_EXCEPTION, EH_NONCONTINUABLE, 3, args );
1572 }
1573 #else
1574 void WINAPI _CxxThrowException( exception *object, const cxx_exception_type *type )
1575 {
1576 ULONG_PTR args[4];
1577
1578 args[0] = CXX_FRAME_MAGIC_VC6;
1579 args[1] = (ULONG_PTR)object;
1580 args[2] = (ULONG_PTR)type;
1581 RtlPcToFileHeader( (void*)type, (void**)&args[3]);
1582 RaiseException( CXX_EXCEPTION, EH_NONCONTINUABLE, 4, args );
1583 }
1584 #endif
1585
1586 #if _MSVCR_VER >= 80
1587
1588 /*********************************************************************
1589 * ?_is_exception_typeof@@YAHABVtype_info@@PAU_EXCEPTION_POINTERS@@@Z
1590 * ?_is_exception_typeof@@YAHAEBVtype_info@@PEAU_EXCEPTION_POINTERS@@@Z
1591 */
1592 #ifndef __x86_64__
1593 int __cdecl _is_exception_typeof(const type_info *ti, EXCEPTION_POINTERS *ep)
1594 {
1595 int ret = -1;
1596
1597 TRACE("(%p %p)\n", ti, ep);
1598
1599 __TRY
1600 {
1601 EXCEPTION_RECORD *rec = ep->ExceptionRecord;
1602
1603 if (rec->ExceptionCode==CXX_EXCEPTION && rec->NumberParameters==3 &&
1604 (rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC6 ||
1605 rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC7 ||
1606 rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC8))
1607 {
1608 const cxx_type_info_table *tit = ((cxx_exception_type*)rec->ExceptionInformation[2])->type_info_table;
1609 int i;
1610
1611 for (i=0; i<tit->count; i++) {
1612 if (ti==tit->info[i]->type_info || !strcmp(ti->mangled, tit->info[i]->type_info->mangled))
1613 {
1614 ret = 1;
1615 break;
1616 }
1617 }
1618
1619 if (i == tit->count)
1620 ret = 0;
1621 }
1622 }
1623 __EXCEPT_PAGE_FAULT
1624 __ENDTRY
1625
1626 if(ret == -1)
1627 MSVCRT_terminate();
1628 return ret;
1629 }
1630 #else
1631 int __cdecl _is_exception_typeof(const type_info *ti, EXCEPTION_POINTERS *ep)
1632 {
1633 int ret = -1;
1634
1635 TRACE("(%p %p)\n", ti, ep);
1636
1637 __TRY
1638 {
1639 EXCEPTION_RECORD *rec = ep->ExceptionRecord;
1640
1641 if (rec->ExceptionCode==CXX_EXCEPTION && rec->NumberParameters==4 &&
1642 (rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC6 ||
1643 rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC7 ||
1644 rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC8))
1645 {
1646 const cxx_exception_type *et = (cxx_exception_type*)rec->ExceptionInformation[2];
1647 const cxx_type_info_table *tit = (const cxx_type_info_table*)(rec->ExceptionInformation[3]+et->type_info_table);
1648 int i;
1649
1650 for (i=0; i<tit->count; i++) {
1651 const cxx_type_info *cti = (const cxx_type_info*)(rec->ExceptionInformation[3]+tit->info[i]);
1652 const type_info *except_ti = (const type_info*)(rec->ExceptionInformation[3]+cti->type_info);
1653 if (ti==except_ti || !strcmp(ti->mangled, except_ti->mangled))
1654 {
1655 ret = 1;
1656 break;
1657 }
1658 }
1659
1660 if (i == tit->count)
1661 ret = 0;
1662 }
1663 }
1664 __EXCEPT_PAGE_FAULT
1665 __ENDTRY
1666
1667 if(ret == -1)
1668 MSVCRT_terminate();
1669 return ret;
1670 }
1671 #endif
1672
1673 /*********************************************************************
1674 * __clean_type_info_names_internal (MSVCR80.@)
1675 */
1676 void CDECL __clean_type_info_names_internal(void *p)
1677 {
1678 FIXME("(%p) stub\n", p);
1679 }
1680
1681 /*********************************************************************
1682 * ?_name_internal_method@type_info@@QBEPBDPAU__type_info_node@@@Z (MSVCR100.@)
1683 */
1684 DEFINE_THISCALL_WRAPPER(type_info_name_internal_method,8)
1685 const char * __thiscall type_info_name_internal_method(type_info * _this, struct __type_info_node *node)
1686 {
1687 static int once;
1688 if (node && !once++) FIXME("type_info_node parameter ignored\n");
1689
1690 return MSVCRT_type_info_name(_this);
1691 }
1692
1693 #endif /* _MSVCR_VER >= 80 */
1694
1695 /* std::exception_ptr class helpers */
1696 typedef struct
1697 {
1698 EXCEPTION_RECORD *rec;
1699 int *ref; /* not binary compatible with native msvcr100 */
1700 } exception_ptr;
1701
1702 #if _MSVCR_VER >= 100
1703
1704 /*********************************************************************
1705 * ?__ExceptionPtrCreate@@YAXPAX@Z
1706 * ?__ExceptionPtrCreate@@YAXPEAX@Z
1707 */
1708 void __cdecl __ExceptionPtrCreate(exception_ptr *ep)
1709 {
1710 TRACE("(%p)\n", ep);
1711
1712 ep->rec = NULL;
1713 ep->ref = NULL;
1714 }
1715
1716 #ifdef __ASM_USE_THISCALL_WRAPPER
1717 extern void call_dtor(const cxx_exception_type *type, void *func, void *object);
1718
1719 __ASM_GLOBAL_FUNC( call_dtor,
1720 "movl 12(%esp),%ecx\n\t"
1721 "call *8(%esp)\n\t"
1722 "ret" );
1723 #elif __x86_64__
1724 static inline void call_dtor(const cxx_exception_type *type, unsigned int dtor, void *object)
1725 {
1726 char *base = RtlPcToFileHeader((void*)type, (void**)&base);
1727 void (__cdecl *func)(void*) = (void*)(base + dtor);
1728 func(object);
1729 }
1730 #else
1731 #define call_dtor(type, func, object) ((void (__thiscall*)(void*))(func))(object)
1732 #endif
1733
1734 /*********************************************************************
1735 * ?__ExceptionPtrDestroy@@YAXPAX@Z
1736 * ?__ExceptionPtrDestroy@@YAXPEAX@Z
1737 */
1738 void __cdecl __ExceptionPtrDestroy(exception_ptr *ep)
1739 {
1740 TRACE("(%p)\n", ep);
1741
1742 if (!ep->rec)
1743 return;
1744
1745 if (!InterlockedDecrement(ep->ref))
1746 {
1747 if (ep->rec->ExceptionCode == CXX_EXCEPTION)
1748 {
1749 const cxx_exception_type *type = (void*)ep->rec->ExceptionInformation[2];
1750 void *obj = (void*)ep->rec->ExceptionInformation[1];
1751
1752 if (type && type->destructor) call_dtor(type, type->destructor, obj);
1753 HeapFree(GetProcessHeap(), 0, obj);
1754 }
1755
1756 HeapFree(GetProcessHeap(), 0, ep->rec);
1757 HeapFree(GetProcessHeap(), 0, ep->ref);
1758 }
1759 }
1760
1761 /*********************************************************************
1762 * ?__ExceptionPtrCopy@@YAXPAXPBX@Z
1763 * ?__ExceptionPtrCopy@@YAXPEAXPEBX@Z
1764 */
1765 void __cdecl __ExceptionPtrCopy(exception_ptr *ep, const exception_ptr *copy)
1766 {
1767 TRACE("(%p %p)\n", ep, copy);
1768
1769 /* don't destroy object stored in ep */
1770 *ep = *copy;
1771 if (ep->ref)
1772 InterlockedIncrement(copy->ref);
1773 }
1774
1775 /*********************************************************************
1776 * ?__ExceptionPtrAssign@@YAXPAXPBX@Z
1777 * ?__ExceptionPtrAssign@@YAXPEAXPEBX@Z
1778 */
1779 void __cdecl __ExceptionPtrAssign(exception_ptr *ep, const exception_ptr *assign)
1780 {
1781 TRACE("(%p %p)\n", ep, assign);
1782
1783 /* don't destroy object stored in ep */
1784 if (ep->ref)
1785 InterlockedDecrement(ep->ref);
1786
1787 *ep = *assign;
1788 if (ep->ref)
1789 InterlockedIncrement(ep->ref);
1790 }
1791
1792 #endif /* _MSVCR_VER >= 100 */
1793
1794 /*********************************************************************
1795 * ?__ExceptionPtrRethrow@@YAXPBX@Z
1796 * ?__ExceptionPtrRethrow@@YAXPEBX@Z
1797 */
1798 void __cdecl __ExceptionPtrRethrow(const exception_ptr *ep)
1799 {
1800 TRACE("(%p)\n", ep);
1801
1802 if (!ep->rec)
1803 {
1804 static const char *exception_msg = "bad exception";
1805 exception e;
1806
1807 MSVCRT_exception_ctor(&e, &exception_msg);
1808 _CxxThrowException(&e, &exception_exception_type);
1809 return;
1810 }
1811
1812 RaiseException(ep->rec->ExceptionCode, ep->rec->ExceptionFlags & (~EH_UNWINDING),
1813 ep->rec->NumberParameters, ep->rec->ExceptionInformation);
1814 }
1815
1816 #if _MSVCR_VER >= 100
1817
1818 #ifdef __i386__
1819 extern void call_copy_ctor( void *func, void *this, void *src, int has_vbase );
1820 #else
1821 static inline void call_copy_ctor( void *func, void *this, void *src, int has_vbase )
1822 {
1823 TRACE( "calling copy ctor %p object %p src %p\n", func, this, src );
1824 if (has_vbase)
1825 ((void (__cdecl*)(void*, void*, BOOL))func)(this, src, 1);
1826 else
1827 ((void (__cdecl*)(void*, void*))func)(this, src);
1828 }
1829 #endif
1830
1831 /*********************************************************************
1832 * ?__ExceptionPtrCurrentException@@YAXPAX@Z
1833 * ?__ExceptionPtrCurrentException@@YAXPEAX@Z
1834 */
1835 #ifndef __x86_64__
1836 void __cdecl __ExceptionPtrCurrentException(exception_ptr *ep)
1837 {
1838 EXCEPTION_RECORD *rec = msvcrt_get_thread_data()->exc_record;
1839
1840 TRACE("(%p)\n", ep);
1841
1842 if (!rec)
1843 {
1844 ep->rec = NULL;
1845 ep->ref = NULL;
1846 return;
1847 }
1848
1849 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1850 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1851
1852 *ep->rec = *rec;
1853 *ep->ref = 1;
1854
1855 if (ep->rec->ExceptionCode == CXX_EXCEPTION)
1856 {
1857 const cxx_exception_type *et = (void*)ep->rec->ExceptionInformation[2];
1858 const cxx_type_info *ti;
1859 void **data, *obj;
1860
1861 ti = et->type_info_table->info[0];
1862 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
1863
1864 obj = (void*)ep->rec->ExceptionInformation[1];
1865 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
1866 {
1867 memcpy(data, obj, ti->size);
1868 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
1869 }
1870 else if (ti->copy_ctor)
1871 {
1872 call_copy_ctor(ti->copy_ctor, data, get_this_pointer(&ti->offsets, obj),
1873 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
1874 }
1875 else
1876 memcpy(data, get_this_pointer(&ti->offsets, obj), ti->size);
1877 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
1878 }
1879 return;
1880 }
1881 #else
1882 void __cdecl __ExceptionPtrCurrentException(exception_ptr *ep)
1883 {
1884 EXCEPTION_RECORD *rec = msvcrt_get_thread_data()->exc_record;
1885
1886 TRACE("(%p)\n", ep);
1887
1888 if (!rec)
1889 {
1890 ep->rec = NULL;
1891 ep->ref = NULL;
1892 return;
1893 }
1894
1895 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1896 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1897
1898 *ep->rec = *rec;
1899 *ep->ref = 1;
1900
1901 if (ep->rec->ExceptionCode == CXX_EXCEPTION)
1902 {
1903 const cxx_exception_type *et = (void*)ep->rec->ExceptionInformation[2];
1904 const cxx_type_info *ti;
1905 void **data, *obj;
1906 char *base = RtlPcToFileHeader((void*)et, (void**)&base);
1907
1908 ti = (const cxx_type_info*)(base + ((const cxx_type_info_table*)(base + et->type_info_table))->info[0]);
1909 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
1910
1911 obj = (void*)ep->rec->ExceptionInformation[1];
1912 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
1913 {
1914 memcpy(data, obj, ti->size);
1915 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
1916 }
1917 else if (ti->copy_ctor)
1918 {
1919 call_copy_ctor(base + ti->copy_ctor, data, get_this_pointer(&ti->offsets, obj),
1920 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
1921 }
1922 else
1923 memcpy(data, get_this_pointer(&ti->offsets, obj), ti->size);
1924 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
1925 }
1926 return;
1927 }
1928 #endif
1929
1930 #endif /* _MSVCR_VER >= 100 */
1931
1932 #if _MSVCR_VER >= 110
1933 /*********************************************************************
1934 * ?__ExceptionPtrToBool@@YA_NPBX@Z
1935 * ?__ExceptionPtrToBool@@YA_NPEBX@Z
1936 */
1937 MSVCRT_bool __cdecl __ExceptionPtrToBool(exception_ptr *ep)
1938 {
1939 return !!ep->rec;
1940 }
1941 #endif
1942
1943 #if _MSVCR_VER >= 100
1944
1945 /*********************************************************************
1946 * ?__ExceptionPtrCopyException@@YAXPAXPBX1@Z
1947 * ?__ExceptionPtrCopyException@@YAXPEAXPEBX1@Z
1948 */
1949 #ifndef __x86_64__
1950 void __cdecl __ExceptionPtrCopyException(exception_ptr *ep,
1951 exception *object, const cxx_exception_type *type)
1952 {
1953 const cxx_type_info *ti;
1954 void **data;
1955
1956 __ExceptionPtrDestroy(ep);
1957
1958 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1959 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1960 *ep->ref = 1;
1961
1962 memset(ep->rec, 0, sizeof(EXCEPTION_RECORD));
1963 ep->rec->ExceptionCode = CXX_EXCEPTION;
1964 ep->rec->ExceptionFlags = EH_NONCONTINUABLE;
1965 ep->rec->NumberParameters = 3;
1966 ep->rec->ExceptionInformation[0] = CXX_FRAME_MAGIC_VC6;
1967 ep->rec->ExceptionInformation[2] = (ULONG_PTR)type;
1968
1969 ti = type->type_info_table->info[0];
1970 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
1971 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
1972 {
1973 memcpy(data, object, ti->size);
1974 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
1975 }
1976 else if (ti->copy_ctor)
1977 {
1978 call_copy_ctor(ti->copy_ctor, data, get_this_pointer(&ti->offsets, object),
1979 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
1980 }
1981 else
1982 memcpy(data, get_this_pointer(&ti->offsets, object), ti->size);
1983 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
1984 }
1985 #else
1986 void __cdecl __ExceptionPtrCopyException(exception_ptr *ep,
1987 exception *object, const cxx_exception_type *type)
1988 {
1989 const cxx_type_info *ti;
1990 void **data;
1991 char *base;
1992
1993 RtlPcToFileHeader((void*)type, (void**)&base);
1994 __ExceptionPtrDestroy(ep);
1995
1996 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1997 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1998 *ep->ref = 1;
1999
2000 memset(ep->rec, 0, sizeof(EXCEPTION_RECORD));
2001 ep->rec->ExceptionCode = CXX_EXCEPTION;
2002 ep->rec->ExceptionFlags = EH_NONCONTINUABLE;
2003 ep->rec->NumberParameters = 4;
2004 ep->rec->ExceptionInformation[0] = CXX_FRAME_MAGIC_VC6;
2005 ep->rec->ExceptionInformation[2] = (ULONG_PTR)type;
2006 ep->rec->ExceptionInformation[3] = (ULONG_PTR)base;
2007
2008 ti = (const cxx_type_info*)(base + ((const cxx_type_info_table*)(base + type->type_info_table))->info[0]);
2009 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
2010 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
2011 {
2012 memcpy(data, object, ti->size);
2013 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
2014 }
2015 else if (ti->copy_ctor)
2016 {
2017 call_copy_ctor(base + ti->copy_ctor, data, get_this_pointer(&ti->offsets, object),
2018 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
2019 }
2020 else
2021 memcpy(data, get_this_pointer(&ti->offsets, object), ti->size);
2022 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
2023 }
2024 #endif
2025
2026 MSVCRT_bool __cdecl __ExceptionPtrCompare(const exception_ptr *ep1, const exception_ptr *ep2)
2027 {
2028 return ep1->rec == ep2->rec;
2029 }
2030
2031 #endif /* _MSVCR_VER >= 100 */
2032
2033 #if _MSVCR_VER >= 80
2034 void* __cdecl __AdjustPointer(void *obj, const this_ptr_offsets *off)
2035 {
2036 return get_this_pointer(off, obj);
2037 }
2038 #endif
2039
2040 #if _MSVCR_VER >= 140
2041
2042 typedef struct
2043 {
2044 char *name;
2045 char mangled[1];
2046 } type_info140;
2047
2048 typedef struct
2049 {
2050 SLIST_ENTRY entry;
2051 char name[1];
2052 } type_info_entry;
2053
2054 static void* CDECL type_info_entry_malloc(MSVCRT_size_t size)
2055 {
2056 type_info_entry *ret = MSVCRT_malloc(FIELD_OFFSET(type_info_entry, name) + size);
2057 return ret->name;
2058 }
2059
2060 static void CDECL type_info_entry_free(void *ptr)
2061 {
2062 ptr = (char*)ptr - FIELD_OFFSET(type_info_entry, name);
2063 MSVCRT_free(ptr);
2064 }
2065
2066 /******************************************************************
2067 * __std_type_info_compare (UCRTBASE.@)
2068 */
2069 int CDECL MSVCRT_type_info_compare(const type_info140 *l, const type_info140 *r)
2070 {
2071 int ret;
2072
2073 if (l == r) ret = 0;
2074 else ret = MSVCRT_strcmp(l->mangled + 1, r->mangled + 1);
2075 TRACE("(%p %p) returning %d\n", l, r, ret);
2076 return ret;
2077 }
2078
2079 /******************************************************************
2080 * __std_type_info_name (UCRTBASE.@)
2081 */
2082 const char* CDECL MSVCRT_type_info_name_list(type_info140 *ti, SLIST_HEADER *header)
2083 {
2084 if (!ti->name)
2085 {
2086 char* name = __unDName(0, ti->mangled + 1, 0,
2087 type_info_entry_malloc, type_info_entry_free, UNDNAME_NO_ARGUMENTS | UNDNAME_32_BIT_DECODE);
2088 if (name)
2089 {
2090 unsigned int len = strlen(name);
2091
2092 while (len && name[--len] == ' ')
2093 name[len] = '\0';
2094
2095 if (InterlockedCompareExchangePointer((void**)&ti->name, name, NULL))
2096 {
2097 type_info_entry_free(name);
2098 }
2099 else
2100 {
2101 type_info_entry *entry = (type_info_entry*)(name-FIELD_OFFSET(type_info_entry, name));
2102 InterlockedPushEntrySList(header, &entry->entry);
2103 }
2104 }
2105 }
2106 TRACE("(%p) returning %s\n", ti, ti->name);
2107 return ti->name;
2108 }
2109
2110 /******************************************************************
2111 * __std_type_info_destroy_list (UCRTBASE.@)
2112 */
2113 void CDECL MSVCRT_type_info_destroy_list(SLIST_HEADER *header)
2114 {
2115 SLIST_ENTRY *cur, *next;
2116
2117 TRACE("(%p)\n", header);
2118
2119 for(cur = InterlockedFlushSList(header); cur; cur = next)
2120 {
2121 next = cur->Next;
2122 MSVCRT_free(cur);
2123 }
2124 }
2125
2126 /******************************************************************
2127 * __std_type_info_hash (UCRTBASE.@)
2128 */
2129 MSVCRT_size_t CDECL MSVCRT_type_info_hash(const type_info140 *ti)
2130 {
2131 MSVCRT_size_t hash, fnv_prime;
2132 const char *p;
2133
2134 #ifdef _WIN64
2135 hash = 0xcbf29ce484222325;
2136 fnv_prime = 0x100000001b3;
2137 #else
2138 hash = 0x811c9dc5;
2139 fnv_prime = 0x1000193;
2140 #endif
2141
2142 TRACE("(%p)->%s\n", ti, ti->mangled);
2143
2144 for(p = ti->mangled+1; *p; p++) {
2145 hash ^= *p;
2146 hash *= fnv_prime;
2147 }
2148
2149 #ifdef _WIN64
2150 hash ^= hash >> 32;
2151 #endif
2152
2153 return hash;
2154 }
2155
2156 #endif /* _MSVCR_VER >= 140 */
2157
2158 #if _MSVCR_VER >= 100
2159
2160 enum ConcRT_EventType
2161 {
2162 CONCRT_EVENT_GENERIC,
2163 CONCRT_EVENT_START,
2164 CONCRT_EVENT_END,
2165 CONCRT_EVENT_BLOCK,
2166 CONCRT_EVENT_UNBLOCK,
2167 CONCRT_EVENT_YIELD,
2168 CONCRT_EVENT_ATTACH,
2169 CONCRT_EVENT_DETACH
2170 };
2171
2172 /* ?_Trace_ppl_function@Concurrency@@YAXABU_GUID@@EW4ConcRT_EventType@1@@Z */
2173 /* ?_Trace_ppl_function@Concurrency@@YAXAEBU_GUID@@EW4ConcRT_EventType@1@@Z */
2174 void __cdecl Concurrency__Trace_ppl_function(const GUID *guid, unsigned char level, enum ConcRT_EventType type)
2175 {
2176 FIXME("(%s %u %i) stub\n", debugstr_guid(guid), level, type);
2177 }
2178
2179 #endif /* _MSVCR_VER >= 100 */
Windows API implementation