?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
advpack: Add a stub for RebootCheckOnInstall.
[wine/testsucceed.git] / programs / winedbg / types.c
blobe9b9358659ad4d285e1557674a07390618a688df
1 /*
2 * File types.c - datatype handling stuff for internal debugger.
3 *
4 * Copyright (C) 1997, Eric Youngdale.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * Note: This really doesn't do much at the moment, but it forms the framework
21 * upon which full support for datatype handling will eventually be built.
22 */
23
24 #include "config.h"
25 #include <stdlib.h>
26
27 #include "debugger.h"
28 #include "wine/debug.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
31
32 /******************************************************************
33 * types_extract_as_integer
34 *
35 * Given a lvalue, try to get an integral (or pointer/address) value
36 * out of it
37 */
38 long int types_extract_as_integer(const struct dbg_lvalue* lvalue)
39 {
40 long int rtn = 0;
41 DWORD tag, size, bt;
42 DWORD64 size64;
43
44 if (lvalue->type.id == dbg_itype_none ||
45 !types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag))
46 return 0;
47
48 switch (tag)
49 {
50 case SymTagBaseType:
51 if (!types_get_info(&lvalue->type, TI_GET_LENGTH, &size64) ||
52 !types_get_info(&lvalue->type, TI_GET_BASETYPE, &bt))
53 {
54 WINE_ERR("Couldn't get information\n");
55 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
56 }
57 if (size64 > sizeof(rtn))
58 {
59 WINE_ERR("Size too large (%s)\n", wine_dbgstr_longlong(size64));
60 return 0;
61 }
62 size = (DWORD)size64;
63 /* FIXME: we have an ugly & non portable thing here !!! */
64 if (!memory_read_value(lvalue, size, &rtn)) return 0;
65
66 /* now let's do some promotions !! */
67 switch (bt)
68 {
69 case btInt:
70 /* propagate sign information */
71 if (((size & 3) != 0) && (rtn >> (size * 8 - 1)) != 0)
72 rtn |= (-1) << (size * 8);
73 break;
74 case btUInt:
75 case btChar:
76 break;
77 case btFloat:
78 RaiseException(DEBUG_STATUS_NOT_AN_INTEGER, 0, 0, NULL);
79 }
80 break;
81 case SymTagPointerType:
82 if (!memory_read_value(lvalue, sizeof(void*), &rtn)) return 0;
83 break;
84 case SymTagArrayType:
85 case SymTagUDT:
86 assert(lvalue->cookie == DLV_TARGET);
87 if (!memory_read_value(lvalue, sizeof(rtn), &rtn)) return 0;
88 break;
89 case SymTagEnum:
90 assert(lvalue->cookie == DLV_TARGET);
91 if (!memory_read_value(lvalue, sizeof(rtn), &rtn)) return 0;
92 break;
93 default:
94 WINE_FIXME("Unsupported tag %lu\n", tag);
95 rtn = 0;
96 break;
97 }
98
99 return rtn;
100 }
101
102 /******************************************************************
103 * types_deref
104 *
105 */
106 BOOL types_deref(const struct dbg_lvalue* lvalue, struct dbg_lvalue* result)
107 {
108 DWORD tag;
109
110 memset(result, 0, sizeof(*result));
111 result->type.id = dbg_itype_none;
112 result->type.module = 0;
113
114 /*
115 * Make sure that this really makes sense.
116 */
117 if (!types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag) ||
118 tag != SymTagPointerType ||
119 !memory_read_value(lvalue, sizeof(result->addr.Offset), &result->addr.Offset) ||
120 !types_get_info(&lvalue->type, TI_GET_TYPE, &result->type.id))
121 return FALSE;
122 result->type.module = lvalue->type.module;
123 result->cookie = DLV_TARGET;
124 /* FIXME: this is currently buggy.
125 * there is no way to tell were the deref:ed value is...
126 * for example:
127 * x is a pointer to struct s, x being on the stack
128 * => lvalue is in debuggee, result is in debugger
129 * x is a pointer to struct s, x being optimized into a reg
130 * => lvalue is debugger, result is debuggee
131 * x is a pointer to internal variable x
132 * => lvalue is debugger, result is debuggee
133 * so we force debuggee address space, because dereferencing pointers to
134 * internal variables is very unlikely. A correct fix would be
135 * rather large.
136 */
137 result->addr.Mode = AddrModeFlat;
138 return TRUE;
139 }
140
141 /******************************************************************
142 * types_get_udt_element_lvalue
143 *
144 * Implement a structure derefencement
145 */
146 static BOOL types_get_udt_element_lvalue(struct dbg_lvalue* lvalue,
147 const struct dbg_type* type, long int* tmpbuf)
148 {
149 DWORD offset, bitoffset;
150 DWORD bt;
151 DWORD64 length;
152
153 unsigned mask;
154
155 types_get_info(type, TI_GET_TYPE, &lvalue->type.id);
156 lvalue->type.module = type->module;
157 if (!types_get_info(type, TI_GET_OFFSET, &offset)) return FALSE;
158 lvalue->addr.Offset += offset;
159
160 if (types_get_info(type, TI_GET_BITPOSITION, &bitoffset))
161 {
162 types_get_info(type, TI_GET_LENGTH, &length);
163 /* FIXME: this test isn't sufficient, depending on start of bitfield
164 * (ie a 32 bit field can spread across 5 bytes)
165 */
166 if (length > 8 * sizeof(*tmpbuf)) return FALSE;
167 lvalue->addr.Offset += bitoffset >> 3;
168 /*
169 * Bitfield operation. We have to extract the field and store
170 * it in a temporary buffer so that we get it all right.
171 */
172 if (!memory_read_value(lvalue, sizeof(*tmpbuf), tmpbuf)) return FALSE;
173 mask = 0xffffffff << (DWORD)length;
174 *tmpbuf >>= bitoffset & 7;
175 *tmpbuf &= ~mask;
176
177 lvalue->cookie = DLV_HOST;
178 lvalue->addr.Offset = (DWORD)tmpbuf;
179
180 /*
181 * OK, now we have the correct part of the number.
182 * Check to see whether the basic type is signed or not, and if so,
183 * we need to sign extend the number.
184 */
185 if (types_get_info(&lvalue->type, TI_GET_BASETYPE, &bt) &&
186 bt == btInt && (*tmpbuf & (1 << ((DWORD)length - 1))))
187 {
188 *tmpbuf |= mask;
189 }
190 }
191 else
192 {
193 if (!memory_read_value(lvalue, sizeof(*tmpbuf), tmpbuf)) return FALSE;
194
195 }
196 return TRUE;
197 }
198
199 /******************************************************************
200 * types_udt_find_element
201 *
202 */
203 BOOL types_udt_find_element(struct dbg_lvalue* lvalue, const char* name, long int* tmpbuf)
204 {
205 DWORD tag, count;
206 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
207 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
208 WCHAR* ptr;
209 char tmp[256];
210 int i;
211 struct dbg_type type;
212
213 if (!types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag) ||
214 tag != SymTagUDT)
215 return FALSE;
216
217 if (types_get_info(&lvalue->type, TI_GET_CHILDRENCOUNT, &count))
218 {
219 fcp->Start = 0;
220 while (count)
221 {
222 fcp->Count = min(count, 256);
223 if (types_get_info(&lvalue->type, TI_FINDCHILDREN, fcp))
224 {
225 type.module = lvalue->type.module;
226 for (i = 0; i < min(fcp->Count, count); i++)
227 {
228 ptr = NULL;
229 type.id = fcp->ChildId[i];
230 types_get_info(&type, TI_GET_SYMNAME, &ptr);
231 if (!ptr) continue;
232 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
233 HeapFree(GetProcessHeap(), 0, ptr);
234 if (strcmp(tmp, name)) continue;
235
236 return types_get_udt_element_lvalue(lvalue, &type, tmpbuf);
237 }
238 }
239 count -= min(count, 256);
240 fcp->Start += 256;
241 }
242 }
243 return FALSE;
244 }
245
246 /******************************************************************
247 * types_array_index
248 *
249 * Grab an element from an array
250 */
251 BOOL types_array_index(const struct dbg_lvalue* lvalue, int index,
252 struct dbg_lvalue* result)
253 {
254 DWORD tag, count;
255 DWORD64 length;
256
257 if (!types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag))
258 return FALSE;
259 switch (tag)
260 {
261 case SymTagArrayType:
262 types_get_info(&lvalue->type, TI_GET_COUNT, &count);
263 if (index < 0 || index >= count) return FALSE;
264 /* fall through */
265 case SymTagPointerType:
266 /* Contents of array share same data (addr mode, module...) */
267 *result = *lvalue;
268 /*
269 * Get the base type, so we know how much to index by.
270 */
271 types_get_info(&lvalue->type, TI_GET_TYPE, &result->type.id);
272 types_get_info(&result->type, TI_GET_LENGTH, &length);
273 memory_read_value(lvalue, sizeof(result->addr.Offset), &result->addr.Offset);
274 result->addr.Offset += index * (DWORD)length;
275 break;
276 default:
277 assert(FALSE);
278 }
279 return TRUE;
280 }
281
282 struct type_find_t
283 {
284 unsigned long result; /* out: the found type */
285 enum SymTagEnum tag; /* in: the tag to look for */
286 union
287 {
288 unsigned long typeid; /* when tag is SymTagUDT */
289 const char* name; /* when tag is SymTagPointerType */
290 } u;
291 };
292
293 static BOOL CALLBACK types_cb(PSYMBOL_INFO sym, ULONG size, void* _user)
294 {
295 struct type_find_t* user = (struct type_find_t*)_user;
296 BOOL ret = TRUE;
297 struct dbg_type type;
298 DWORD type_id;
299
300 if (sym->Tag == user->tag)
301 {
302 switch (user->tag)
303 {
304 case SymTagUDT:
305 if (!strcmp(user->u.name, sym->Name))
306 {
307 user->result = sym->TypeIndex;
308 ret = FALSE;
309 }
310 break;
311 case SymTagPointerType:
312 type.module = sym->ModBase;
313 type.id = sym->TypeIndex;
314 if (types_get_info(&type, TI_GET_TYPE, &type_id) && type_id == user->u.typeid)
315 {
316 user->result = sym->TypeIndex;
317 ret = FALSE;
318 }
319 break;
320 default: break;
321 }
322 }
323 return ret;
324 }
325
326 /******************************************************************
327 * types_find_pointer
328 *
329 * Should look up in module based at linear whether (typeid*) exists
330 * Otherwise, we could create it locally
331 */
332 struct dbg_type types_find_pointer(const struct dbg_type* type)
333 {
334 struct type_find_t f;
335 struct dbg_type ret;
336
337 f.result = dbg_itype_none;
338 f.tag = SymTagPointerType;
339 f.u.typeid = type->id;
340 SymEnumTypes(dbg_curr_process->handle, type->module, types_cb, &f);
341 ret.module = type->module;
342 ret.id = f.result;
343 return ret;
344 }
345
346 /******************************************************************
347 * types_find_type
348 *
349 * Should look up in the module based at linear address whether a type
350 * named 'name' and with the correct tag exists
351 */
352 struct dbg_type types_find_type(unsigned long linear, const char* name, enum SymTagEnum tag)
353
354 {
355 struct type_find_t f;
356 struct dbg_type ret;
357
358 f.result = dbg_itype_none;
359 f.tag = tag;
360 f.u.name = name;
361 SymEnumTypes(dbg_curr_process->handle, linear, types_cb, &f);
362 ret.module = linear;
363 ret.id = f.result;
364 return ret;
365 }
366
367 /***********************************************************************
368 * print_value
369 *
370 * Implementation of the 'print' command.
371 */
372 void print_value(const struct dbg_lvalue* lvalue, char format, int level)
373 {
374 struct dbg_lvalue lvalue_field;
375 int i;
376 DWORD tag;
377 DWORD count;
378 DWORD64 size;
379
380 if (lvalue->type.id == dbg_itype_none)
381 {
382 /* No type, just print the addr value */
383 print_bare_address(&lvalue->addr);
384 goto leave;
385 }
386
387 if (format == 'i' || format == 's' || format == 'w' || format == 'b' || format == 'g')
388 {
389 dbg_printf("Format specifier '%c' is meaningless in 'print' command\n", format);
390 format = '\0';
391 }
392
393 if (!types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag))
394 {
395 WINE_FIXME("---error\n");
396 return;
397 }
398 switch (tag)
399 {
400 case SymTagBaseType:
401 case SymTagEnum:
402 case SymTagPointerType:
403 print_basic(lvalue, 1, format);
404 break;
405 case SymTagUDT:
406 if (types_get_info(&lvalue->type, TI_GET_CHILDRENCOUNT, &count))
407 {
408 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
409 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
410 WCHAR* ptr;
411 char tmp[256];
412 long int tmpbuf;
413 struct dbg_type type;
414
415 dbg_printf("{");
416 fcp->Start = 0;
417 while (count)
418 {
419 fcp->Count = min(count, 256);
420 if (types_get_info(&lvalue->type, TI_FINDCHILDREN, fcp))
421 {
422 for (i = 0; i < min(fcp->Count, count); i++)
423 {
424 ptr = NULL;
425 type.module = lvalue->type.module;
426 type.id = fcp->ChildId[i];
427 types_get_info(&type, TI_GET_SYMNAME, &ptr);
428 if (!ptr) continue;
429 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
430 dbg_printf("%s=", tmp);
431 HeapFree(GetProcessHeap(), 0, ptr);
432 lvalue_field = *lvalue;
433 if (types_get_udt_element_lvalue(&lvalue_field, &type, &tmpbuf))
434 {
435 print_value(&lvalue_field, format, level + 1);
436 }
437 if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
438 }
439 }
440 count -= min(count, 256);
441 fcp->Start += 256;
442 }
443 dbg_printf("}");
444 }
445 break;
446 case SymTagArrayType:
447 /*
448 * Loop over all of the entries, printing stuff as we go.
449 */
450 count = 1; size = 1;
451 types_get_info(&lvalue->type, TI_GET_COUNT, &count);
452 types_get_info(&lvalue->type, TI_GET_LENGTH, &size);
453
454 if (size == count)
455 {
456 unsigned len;
457 char buffer[256];
458 /*
459 * Special handling for character arrays.
460 */
461 /* FIXME should check basic type here (should be a char!!!!)... */
462 len = min(count, sizeof(buffer));
463 memory_get_string(dbg_curr_process,
464 memory_to_linear_addr(&lvalue->addr),
465 lvalue->cookie == DLV_TARGET, TRUE, buffer, len);
466 dbg_printf("\"%s%s\"", buffer, (len < count) ? "..." : "");
467 break;
468 }
469 lvalue_field = *lvalue;
470 types_get_info(&lvalue->type, TI_GET_TYPE, &lvalue_field.type.id);
471 dbg_printf("{");
472 for (i = 0; i < count; i++)
473 {
474 print_value(&lvalue_field, format, level + 1);
475 lvalue_field.addr.Offset += size / count;
476 dbg_printf((i == count - 1) ? "}" : ", ");
477 }
478 break;
479 case SymTagFunctionType:
480 dbg_printf("Function ");
481 print_bare_address(&lvalue->addr);
482 dbg_printf(": ");
483 types_print_type(&lvalue->type, FALSE);
484 break;
485 default:
486 WINE_FIXME("Unknown tag (%lu)\n", tag);
487 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
488 break;
489 }
490
491 leave:
492
493 if (level == 0) dbg_printf("\n");
494 }
495
496 static BOOL CALLBACK print_types_cb(PSYMBOL_INFO sym, ULONG size, void* ctx)
497 {
498 struct dbg_type type;
499 type.module = sym->ModBase;
500 type.id = sym->TypeIndex;
501 dbg_printf("Mod: %08lx ID: %08lx \n", type.module, type.id);
502 types_print_type(&type, TRUE);
503 dbg_printf("\n");
504 return TRUE;
505 }
506
507 static BOOL CALLBACK print_types_mod_cb(PSTR mod_name, DWORD base, void* ctx)
508 {
509 return SymEnumTypes(dbg_curr_process->handle, base, print_types_cb, ctx);
510 }
511
512 int print_types(void)
513 {
514 SymEnumerateModules(dbg_curr_process->handle, print_types_mod_cb, NULL);
515 return 0;
516 }
517
518 int types_print_type(const struct dbg_type* type, BOOL details)
519 {
520 WCHAR* ptr;
521 char tmp[256];
522 const char* name;
523 DWORD tag, udt, count;
524 struct dbg_type subtype;
525
526 if (type->id == dbg_itype_none || !types_get_info(type, TI_GET_SYMTAG, &tag))
527 {
528 dbg_printf("--invalid--<%lxh>--", type->id);
529 return FALSE;
530 }
531
532 if (types_get_info(type, TI_GET_SYMNAME, &ptr) && ptr)
533 {
534 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
535 name = tmp;
536 HeapFree(GetProcessHeap(), 0, ptr);
537 }
538 else name = "--none--";
539
540 switch (tag)
541 {
542 case SymTagBaseType:
543 if (details) dbg_printf("Basic<%s>", name); else dbg_printf("%s", name);
544 break;
545 case SymTagPointerType:
546 types_get_info(type, TI_GET_TYPE, &subtype.id);
547 subtype.module = type->module;
548 types_print_type(&subtype, FALSE);
549 dbg_printf("*");
550 break;
551 case SymTagUDT:
552 types_get_info(type, TI_GET_UDTKIND, &udt);
553 switch (udt)
554 {
555 case UdtStruct: dbg_printf("struct %s", name); break;
556 case UdtUnion: dbg_printf("union %s", name); break;
557 case UdtClass: dbg_printf("class %s", name); break;
558 default: WINE_ERR("Unsupported UDT type (%ld) for %s", udt, name); break;
559 }
560 if (details &&
561 types_get_info(type, TI_GET_CHILDRENCOUNT, &count))
562 {
563 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
564 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
565 WCHAR* ptr;
566 char tmp[256];
567 int i;
568 struct dbg_type type_elt;
569 dbg_printf(" {");
570
571 fcp->Start = 0;
572 while (count)
573 {
574 fcp->Count = min(count, 256);
575 if (types_get_info(type, TI_FINDCHILDREN, fcp))
576 {
577 for (i = 0; i < min(fcp->Count, count); i++)
578 {
579 ptr = NULL;
580 type_elt.module = type->module;
581 type_elt.id = fcp->ChildId[i];
582 types_get_info(&type_elt, TI_GET_SYMNAME, &ptr);
583 if (!ptr) continue;
584 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
585 HeapFree(GetProcessHeap(), 0, ptr);
586 dbg_printf("%s", tmp);
587 if (types_get_info(&type_elt, TI_GET_TYPE, &type_elt.id))
588 {
589 dbg_printf(":");
590 types_print_type(&type_elt, details);
591 }
592 if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
593 }
594 }
595 count -= min(count, 256);
596 fcp->Start += 256;
597 }
598 dbg_printf("}");
599 }
600 break;
601 case SymTagArrayType:
602 types_get_info(type, TI_GET_TYPE, &subtype.id);
603 subtype.module = type->module;
604 types_print_type(&subtype, details);
605 dbg_printf(" %s[]", name);
606 break;
607 case SymTagEnum:
608 dbg_printf("enum %s", name);
609 break;
610 case SymTagFunctionType:
611 types_get_info(type, TI_GET_TYPE, &subtype.id);
612 subtype.module = type->module;
613 types_print_type(&subtype, FALSE);
614 dbg_printf(" (*%s)(", name);
615 if (types_get_info(type, TI_GET_CHILDRENCOUNT, &count))
616 {
617 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
618 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
619 int i;
620
621 fcp->Start = 0;
622 while (count)
623 {
624 fcp->Count = min(count, 256);
625 if (types_get_info(type, TI_FINDCHILDREN, fcp))
626 {
627 for (i = 0; i < min(fcp->Count, count); i++)
628 {
629 subtype.id = fcp->ChildId[i];
630 types_get_info(&subtype, TI_GET_TYPE, &subtype.id);
631 types_print_type(&subtype, FALSE);
632 if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
633 }
634 }
635 count -= min(count, 256);
636 fcp->Start += 256;
637 }
638 }
639 dbg_printf(")");
640 break;
641 default:
642 WINE_ERR("Unknown type %lu for %s\n", tag, name);
643 break;
644 }
645
646 return TRUE;
647 }
648
649 /* helper to typecast pInfo to its expected type (_t) */
650 #define X(_t) (*((_t*)pInfo))
651
652 BOOL types_get_info(const struct dbg_type* type, IMAGEHLP_SYMBOL_TYPE_INFO ti, void* pInfo)
653 {
654 if (type->id == dbg_itype_none) return FALSE;
655 if (type->module != 0)
656 {
657 DWORD ret, tag, bt;
658 ret = SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, ti, pInfo);
659 if (!ret &&
660 SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, TI_GET_SYMTAG, &tag) &&
661 tag == SymTagBaseType &&
662 SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, TI_GET_BASETYPE, &bt))
663 {
664 static const WCHAR voidW[] = {'v','o','i','d','\0'};
665 static const WCHAR charW[] = {'c','h','a','r','\0'};
666 static const WCHAR wcharW[] = {'W','C','H','A','R','\0'};
667 static const WCHAR intW[] = {'i','n','t','\0'};
668 static const WCHAR uintW[] = {'u','n','s','i','g','n','e','d',' ','i','n','t','\0'};
669 static const WCHAR floatW[] = {'f','l','o','a','t','\0'};
670 static const WCHAR boolW[] = {'b','o','o','l','\0'};
671 static const WCHAR longW[] = {'l','o','n','g',' ','i','n','t','\0'};
672 static const WCHAR ulongW[] = {'u','n','s','i','g','n','e','d',' ','l','o','n','g',' ','i','n','t','\0'};
673 static const WCHAR complexW[] = {'c','o','m','p','l','e','x','\0'};
674 const WCHAR* name = NULL;
675
676 switch (bt)
677 {
678 case btVoid: name = voidW; break;
679 case btChar: name = charW; break;
680 case btWChar: name = wcharW; break;
681 case btInt: name = intW; break;
682 case btUInt: name = uintW; break;
683 case btFloat: name = floatW; break;
684 case btBool: name = boolW; break;
685 case btLong: name = longW; break;
686 case btULong: name = ulongW; break;
687 case btComplex: name = complexW; break;
688 default: WINE_FIXME("Unsupported basic type %ld\n", bt); return FALSE;
689 }
690 X(WCHAR*) = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(name) + 1) * sizeof(WCHAR));
691 if (X(WCHAR*))
692 {
693 lstrcpyW(X(WCHAR*), name);
694 ret = TRUE;
695 }
696 }
697 return ret;
698 }
699
700 assert(type->id >= dbg_itype_first);
701
702 switch (type->id)
703 {
704 case dbg_itype_unsigned_int:
705 switch (ti)
706 {
707 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
708 case TI_GET_LENGTH: X(DWORD64) = 4; break;
709 case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
710 default: WINE_FIXME("unsupported %u for u-int\n", ti); return FALSE;
711 }
712 break;
713 case dbg_itype_signed_int:
714 switch (ti)
715 {
716 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
717 case TI_GET_LENGTH: X(DWORD64) = 4; break;
718 case TI_GET_BASETYPE: X(DWORD) = btInt; break;
719 default: WINE_FIXME("unsupported %u for s-int\n", ti); return FALSE;
720 }
721 break;
722 case dbg_itype_unsigned_short_int:
723 switch (ti)
724 {
725 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
726 case TI_GET_LENGTH: X(DWORD64) = 2; break;
727 case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
728 default: WINE_FIXME("unsupported %u for u-short int\n", ti); return FALSE;
729 }
730 break;
731 case dbg_itype_signed_short_int:
732 switch (ti)
733 {
734 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
735 case TI_GET_LENGTH: X(DWORD64) = 2; break;
736 case TI_GET_BASETYPE: X(DWORD) = btInt; break;
737 default: WINE_FIXME("unsupported %u for s-short int\n", ti); return FALSE;
738 }
739 break;
740 case dbg_itype_unsigned_char_int:
741 switch (ti)
742 {
743 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
744 case TI_GET_LENGTH: X(DWORD64) = 1; break;
745 case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
746 default: WINE_FIXME("unsupported %u for u-char int\n", ti); return FALSE;
747 }
748 break;
749 case dbg_itype_signed_char_int:
750 switch (ti)
751 {
752 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
753 case TI_GET_LENGTH: X(DWORD64) = 1; break;
754 case TI_GET_BASETYPE: X(DWORD) = btInt; break;
755 default: WINE_FIXME("unsupported %u for s-char int\n", ti); return FALSE;
756 }
757 break;
758 case dbg_itype_char:
759 switch (ti)
760 {
761 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
762 case TI_GET_LENGTH: X(DWORD64) = 1; break;
763 case TI_GET_BASETYPE: X(DWORD) = btChar; break;
764 default: WINE_FIXME("unsupported %u for char int\n", ti); return FALSE;
765 }
766 break;
767 case dbg_itype_astring:
768 switch (ti)
769 {
770 case TI_GET_SYMTAG: X(DWORD) = SymTagPointerType; break;
771 case TI_GET_LENGTH: X(DWORD64) = 4; break;
772 case TI_GET_TYPE: X(DWORD) = dbg_itype_char; break;
773 default: WINE_FIXME("unsupported %u for a string\n", ti); return FALSE;
774 }
775 break;
776 default: WINE_FIXME("unsupported type id 0x%lx\n", type->id);
777 }
778
779 #undef X
780 return TRUE;
781 }
Quick hack tree for wine patches julliard doesn't want to commit