?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Rename X11 Driver tab of winecfg to Graphics.
[wine/multimedia.git] / programs / winedbg / types.c
blob0b3e6300d8bc604054785cbb2fc73964d2806e62
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 DWORD linear = (DWORD)memory_to_linear_addr(&lvalue->addr);
43
44 assert(lvalue->cookie == DLV_TARGET || lvalue->cookie == DLV_HOST);
45
46 if (lvalue->typeid == dbg_itype_none ||
47 !types_get_info(linear, lvalue->typeid, TI_GET_SYMTAG, &tag))
48 return 0;
49
50 switch (tag)
51 {
52 case SymTagBaseType:
53 if (!types_get_info(linear, lvalue->typeid, TI_GET_LENGTH, &size) ||
54 !types_get_info(linear, lvalue->typeid, TI_GET_BASETYPE, &bt))
55 {
56 WINE_ERR("Couldn't get information\n");
57 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
58 }
59 if (size > sizeof(rtn))
60 {
61 WINE_ERR("Size too large (%lu)\n", size);
62 return 0;
63 }
64 /* FIXME: we have an ugly & non portable thing here !!! */
65 if (!memory_read_value(lvalue, size, &rtn)) return 0;
66
67 /* now let's do some promotions !! */
68 switch (bt)
69 {
70 case btInt:
71 /* propagate sign information */
72 if (((size & 3) != 0) && (rtn >> (size * 8 - 1)) != 0)
73 rtn |= (-1) << (size * 8);
74 break;
75 case btUInt:
76 case btChar:
77 break;
78 case btFloat:
79 RaiseException(DEBUG_STATUS_NOT_AN_INTEGER, 0, 0, NULL);
80 }
81 break;
82 case SymTagPointerType:
83 if (!memory_read_value(lvalue, sizeof(void*), &rtn)) return 0;
84 break;
85 case SymTagArrayType:
86 case SymTagUDT:
87 assert(lvalue->cookie == DLV_TARGET);
88 if (!memory_read_value(lvalue, sizeof(rtn), &rtn)) return 0;
89 break;
90 case SymTagEnum:
91 assert(lvalue->cookie == DLV_TARGET);
92 if (!memory_read_value(lvalue, sizeof(rtn), &rtn)) return 0;
93 break;
94 default:
95 WINE_FIXME("Unsupported tag %lu\n", tag);
96 rtn = 0;
97 break;
98 }
99
100 return rtn;
101 }
102
103 /******************************************************************
104 * types_deref
105 *
106 */
107 BOOL types_deref(const struct dbg_lvalue* lvalue, struct dbg_lvalue* result)
108 {
109 DWORD tag;
110 DWORD linear = (DWORD)memory_to_linear_addr(&lvalue->addr);
111
112 assert(lvalue->cookie == DLV_TARGET || lvalue->cookie == DLV_HOST);
113
114 memset(result, 0, sizeof(*result));
115 result->typeid = dbg_itype_none;
116
117 /*
118 * Make sure that this really makes sense.
119 */
120 if (!types_get_info(linear, lvalue->typeid, TI_GET_SYMTAG, &tag) ||
121 tag != SymTagPointerType ||
122 memory_read_value(lvalue, sizeof(result->addr.Offset), &result->addr.Offset) ||
123 !types_get_info(linear, lvalue->typeid, TI_GET_TYPE, &result->typeid))
124 return FALSE;
125
126 result->cookie = DLV_TARGET; /* see comment on DEREF below */
127 result->addr.Mode = AddrModeFlat;
128 return TRUE;
129 }
130
131 /******************************************************************
132 * types_get_udt_element_lvalue
133 *
134 * Implement a structure derefencement
135 */
136 static BOOL types_get_udt_element_lvalue(struct dbg_lvalue* lvalue, DWORD linear,
137 DWORD typeid, long int* tmpbuf)
138 {
139 DWORD offset, length, bitoffset;
140 DWORD bt;
141 unsigned mask;
142
143 types_get_info(linear, typeid, TI_GET_TYPE, &lvalue->typeid);
144 types_get_info(linear, typeid, TI_GET_OFFSET, &offset);
145
146 if (types_get_info(linear, typeid, TI_GET_BITPOSITION, &bitoffset))
147 {
148 types_get_info(linear, typeid, TI_GET_LENGTH, &length);
149 if (length > sizeof(*tmpbuf)) return FALSE;
150 /*
151 * Bitfield operation. We have to extract the field and store
152 * it in a temporary buffer so that we get it all right.
153 */
154 lvalue->addr.Offset += offset;
155 if (!memory_read_value(lvalue, sizeof(*tmpbuf), tmpbuf)) return FALSE;
156 mask = 0xffffffff << length;
157 *tmpbuf >>= bitoffset & 7;
158 *tmpbuf &= ~mask;
159
160 lvalue->cookie = DLV_HOST;
161 lvalue->addr.Mode = AddrModeFlat;
162 lvalue->addr.Offset = (DWORD)tmpbuf;
163
164 /*
165 * OK, now we have the correct part of the number.
166 * Check to see whether the basic type is signed or not, and if so,
167 * we need to sign extend the number.
168 */
169 if (types_get_info(linear, lvalue->typeid, TI_GET_BASETYPE, &bt) &&
170 bt == btInt && (*tmpbuf & (1 << (length - 1))))
171 {
172 *tmpbuf |= mask;
173 }
174 return TRUE;
175 }
176 if (types_get_info(linear, typeid, TI_GET_OFFSET, &offset))
177 {
178 lvalue->addr.Offset += offset;
179 return TRUE;
180 }
181 return FALSE;
182 }
183
184 /******************************************************************
185 * types_udt_find_element
186 *
187 */
188 BOOL types_udt_find_element(struct dbg_lvalue* lvalue, const char* name, long int* tmpbuf)
189 {
190 DWORD linear = (DWORD)memory_to_linear_addr(&lvalue->addr);
191 DWORD tag, count;
192 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
193 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
194 WCHAR* ptr;
195 char tmp[256];
196 int i;
197
198 assert(lvalue->cookie == DLV_TARGET || lvalue->cookie == DLV_HOST);
199
200 if (!types_get_info(linear, lvalue->typeid, TI_GET_SYMTAG, &tag) ||
201 tag != SymTagUDT)
202 return FALSE;
203
204 if (types_get_info(linear, lvalue->typeid, TI_GET_CHILDRENCOUNT, &count))
205 {
206 fcp->Start = 0;
207 while (count)
208 {
209 fcp->Count = min(count, 256);
210 if (types_get_info(linear, lvalue->typeid, TI_FINDCHILDREN, fcp))
211 {
212 for (i = 0; i < min(fcp->Count, count); i++)
213 {
214 ptr = NULL;
215 types_get_info(linear, fcp->ChildId[i], TI_GET_SYMNAME, &ptr);
216 if (!ptr) continue;
217 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
218 HeapFree(GetProcessHeap(), 0, ptr);
219 if (strcmp(tmp, name)) continue;
220
221 return types_get_udt_element_lvalue(lvalue, linear,
222 fcp->ChildId[i], tmpbuf);
223 }
224 }
225 count -= min(count, 256);
226 fcp->Start += 256;
227 }
228 }
229 return FALSE;
230 }
231
232 /******************************************************************
233 * types_array_index
234 *
235 * Grab an element from an array
236 */
237 BOOL types_array_index(const struct dbg_lvalue* lvalue, int index,
238 struct dbg_lvalue* result)
239 {
240 DWORD tag, length, count;
241 DWORD linear = (DWORD)memory_to_linear_addr(&lvalue->addr);
242
243 assert(lvalue->cookie == DLV_TARGET || lvalue->cookie == DLV_HOST);
244
245 if (!types_get_info(0, lvalue->typeid, TI_GET_SYMTAG, &tag))
246 return FALSE;
247 switch (tag)
248 {
249 case SymTagArrayType:
250 types_get_info(linear, lvalue->typeid, TI_GET_COUNT, &count);
251 if (index < 0 || index >= count) return FALSE;
252 /* fall through */
253 case SymTagPointerType:
254 /*
255 * Get the base type, so we know how much to index by.
256 */
257 types_get_info(linear, lvalue->typeid, TI_GET_TYPE, &result->typeid);
258 types_get_info(linear, result->typeid, TI_GET_LENGTH, &length);
259 /* Contents of array must be on same target */
260 result->cookie = lvalue->cookie;
261 result->addr.Mode = lvalue->addr.Mode;
262 memory_read_value(lvalue, sizeof(result->addr.Offset), &result->addr.Offset);
263 result->addr.Offset += index * length;
264 break;
265 default:
266 assert(FALSE);
267 }
268 return TRUE;
269 }
270
271 struct type_find_t
272 {
273 unsigned long result; /* out: the found type */
274 enum SymTagEnum tag; /* in: the tag to look for */
275 union
276 {
277 unsigned long typeid;
278 const char* name;
279 } u;
280 };
281
282 static BOOL CALLBACK types_cb(PSYMBOL_INFO sym, ULONG size, void* _user)
283 {
284 struct type_find_t* user = (struct type_find_t*)_user;
285 BOOL ret = TRUE;
286 DWORD typeid;
287
288 if (sym->Tag == user->tag)
289 {
290 switch (user->tag)
291 {
292 case SymTagUDT:
293 if (!strcmp(user->u.name, sym->Name))
294 {
295 user->result = sym->TypeIndex;
296 ret = FALSE;
297 }
298 break;
299 case SymTagPointerType:
300 types_get_info(sym->ModBase, sym->TypeIndex, TI_GET_TYPE, &typeid);
301 if (types_get_info(sym->ModBase, sym->TypeIndex, TI_GET_TYPE, &typeid) &&
302 typeid == user->u.typeid)
303 {
304 user->result = sym->TypeIndex;
305 ret = FALSE;
306 }
307 default: break;
308 }
309 }
310 return ret;
311 }
312
313 /******************************************************************
314 * types_find_pointer
315 *
316 * Should look up in module based at linear whether (typeid*) exists
317 * Otherwise, we could create it locally
318 */
319 unsigned long types_find_pointer(unsigned long linear, unsigned long typeid)
320 {
321 struct type_find_t f;
322 f.result = dbg_itype_none;
323 f.tag = SymTagPointerType;
324 f.u.typeid = typeid;
325 SymEnumTypes(dbg_curr_process->handle, linear, types_cb, &f);
326 return f.result;
327 }
328
329 /******************************************************************
330 * types_find_type
331 *
332 * Should look up in the module based at linear address whether a type
333 * named 'name' and with the correct tag exists
334 */
335 unsigned long types_find_type(unsigned long linear, const char* name, enum SymTagEnum tag)
336
337 {
338 struct type_find_t f;
339 f.result = dbg_itype_none;
340 f.tag = tag;
341 f.u.name = name;
342 SymEnumTypes(dbg_curr_process->handle, linear, types_cb, &f);
343 return f.result;
344 }
345
346 /***********************************************************************
347 * print_value
348 *
349 * Implementation of the 'print' command.
350 */
351 void print_value(const struct dbg_lvalue* lvalue, char format, int level)
352 {
353 struct dbg_lvalue lvalue_field;
354 int i;
355 unsigned long linear;
356 DWORD tag;
357 DWORD count;
358 DWORD size;
359
360 assert(lvalue->cookie == DLV_TARGET || lvalue->cookie == DLV_HOST);
361 linear = (unsigned long)memory_to_linear_addr(&lvalue->addr);
362
363 if (lvalue->typeid == dbg_itype_none)
364 {
365 /* No type, just print the addr value */
366 print_bare_address(&lvalue->addr);
367 goto leave;
368 }
369
370 if (format == 'i' || format == 's' || format == 'w' || format == 'b' || format == 'g')
371 {
372 dbg_printf("Format specifier '%c' is meaningless in 'print' command\n", format);
373 format = '\0';
374 }
375
376 if (!types_get_info(linear, lvalue->typeid, TI_GET_SYMTAG, &tag))
377 {
378 WINE_FIXME("---error\n");
379 return;
380 }
381 switch (tag)
382 {
383 case SymTagBaseType:
384 case SymTagEnum:
385 case SymTagPointerType:
386 print_basic(lvalue, 1, format);
387 break;
388 case SymTagUDT:
389 if (types_get_info(linear, lvalue->typeid, TI_GET_CHILDRENCOUNT, &count))
390 {
391 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
392 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
393 WCHAR* ptr;
394 char tmp[256];
395 long int tmpbuf;
396
397 dbg_printf("{");
398 fcp->Start = 0;
399 while (count)
400 {
401 fcp->Count = min(count, 256);
402 if (types_get_info(linear, lvalue->typeid, TI_FINDCHILDREN, fcp))
403 {
404 for (i = 0; i < min(fcp->Count, count); i++)
405 {
406 ptr = NULL;
407 types_get_info(linear, fcp->ChildId[i], TI_GET_SYMNAME, &ptr);
408 if (!ptr) continue;
409 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
410 dbg_printf("%s=", tmp);
411 HeapFree(GetProcessHeap(), 0, ptr);
412 lvalue_field = *lvalue;
413 if (types_get_udt_element_lvalue(&lvalue_field, linear,
414 fcp->ChildId[i], &tmpbuf))
415 {
416 print_value(&lvalue_field, format, level + 1);
417 }
418 if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
419 }
420 }
421 count -= min(count, 256);
422 fcp->Start += 256;
423 }
424 dbg_printf("}");
425 }
426 break;
427 case SymTagArrayType:
428 /*
429 * Loop over all of the entries, printing stuff as we go.
430 */
431 count = 1; size = 1;
432 types_get_info(linear, lvalue->typeid, TI_GET_COUNT, &count);
433 types_get_info(linear, lvalue->typeid, TI_GET_LENGTH, &size);
434
435 if (size == count)
436 {
437 unsigned len;
438 char buffer[256];
439 /*
440 * Special handling for character arrays.
441 */
442 /* FIXME should check basic type here (should be a char!!!!)... */
443 len = min(count, sizeof(buffer));
444 memory_get_string(dbg_curr_thread->handle,
445 memory_to_linear_addr(&lvalue->addr),
446 lvalue->cookie, TRUE, buffer, len);
447 dbg_printf("\"%s%s\"", buffer, (len < count) ? "..." : "");
448 break;
449 }
450 lvalue_field = *lvalue;
451 types_get_info(linear, lvalue->typeid, TI_GET_TYPE, &lvalue_field.typeid);
452 dbg_printf("{");
453 for (i = 0; i < count; i++)
454 {
455 print_value(&lvalue_field, format, level + 1);
456 lvalue_field.addr.Offset += size / count;
457 dbg_printf((i == count - 1) ? "}" : ", ");
458 }
459 break;
460 case SymTagFunctionType:
461 dbg_printf("Function ");
462 print_bare_address(&lvalue->addr);
463 dbg_printf(": ");
464 types_print_type(linear, lvalue->typeid, FALSE);
465 break;
466 default:
467 WINE_FIXME("Unknown tag (%lu)\n", tag);
468 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
469 break;
470 }
471
472 leave:
473
474 if (level == 0) dbg_printf("\n");
475 }
476
477 static BOOL CALLBACK print_types_cb(PSYMBOL_INFO sym, ULONG size, void* ctx)
478 {
479 types_print_type(sym->ModBase, sym->TypeIndex, TRUE);
480 dbg_printf("\n");
481 return TRUE;
482 }
483
484 static BOOL CALLBACK print_types_mod_cb(PSTR mod_name, DWORD base, void* ctx)
485 {
486 return SymEnumTypes(dbg_curr_process->handle, base, print_types_cb, ctx);
487 }
488
489 int print_types(void)
490 {
491 SymEnumerateModules(dbg_curr_process->handle, print_types_mod_cb, NULL);
492 return 0;
493 }
494
495 int types_print_type(DWORD linear, DWORD typeid, BOOL details)
496 {
497 WCHAR* ptr;
498 char tmp[256];
499 const char* name;
500 DWORD tag, subtype, count;
501
502 if (typeid == dbg_itype_none || !types_get_info(linear, typeid, TI_GET_SYMTAG, &tag))
503 {
504 dbg_printf("--invalid--<%lxh>--", typeid);
505 return FALSE;
506 }
507
508 if (types_get_info(linear, typeid, TI_GET_SYMNAME, &ptr) && ptr)
509 {
510 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
511 name = tmp;
512 HeapFree(GetProcessHeap(), 0, ptr);
513 }
514 else name = "--none--";
515
516 switch (tag)
517 {
518 case SymTagBaseType:
519 if (details) dbg_printf("Basic<%s>", name); else dbg_printf("%s", name);
520 break;
521 case SymTagPointerType:
522 types_get_info(linear, typeid, TI_GET_TYPE, &subtype);
523 types_print_type(linear, subtype, details);
524 dbg_printf("*");
525 break;
526 case SymTagUDT:
527 types_get_info(linear, typeid, TI_GET_UDTKIND, &subtype);
528 switch (subtype)
529 {
530 case UdtStruct: dbg_printf("struct %s", name); break;
531 case UdtUnion: dbg_printf("union %s", name); break;
532 case UdtClass: dbg_printf("class %s", name); break;
533 }
534 if (details &&
535 types_get_info(linear, typeid, TI_GET_CHILDRENCOUNT, &count))
536 {
537 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
538 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
539 WCHAR* ptr;
540 char tmp[256];
541 int i;
542
543 dbg_printf(" {");
544
545 fcp->Start = 0;
546 while (count)
547 {
548 fcp->Count = min(count, 256);
549 if (types_get_info(linear, typeid, TI_FINDCHILDREN, fcp))
550 {
551 for (i = 0; i < min(fcp->Count, count); i++)
552 {
553 ptr = NULL;
554 types_get_info(linear, fcp->ChildId[i], TI_GET_SYMNAME, &ptr);
555 if (!ptr) continue;
556 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
557 HeapFree(GetProcessHeap(), 0, ptr);
558 dbg_printf("%s", tmp);
559 if (types_get_info(linear, fcp->ChildId[i], TI_GET_TYPE, &subtype))
560 {
561 dbg_printf(":");
562 types_print_type(linear, subtype, details);
563 }
564 if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
565 }
566 }
567 count -= min(count, 256);
568 fcp->Start += 256;
569 }
570 dbg_printf("}");
571 }
572 break;
573 case SymTagArrayType:
574 types_get_info(linear, typeid, TI_GET_TYPE, &subtype);
575 types_print_type(linear, subtype, details);
576 dbg_printf(" %s[]", name);
577 break;
578 case SymTagEnum:
579 dbg_printf("enum %s", name);
580 break;
581 case SymTagFunctionType:
582 types_get_info(linear, typeid, TI_GET_TYPE, &subtype);
583 types_print_type(linear, subtype, FALSE);
584 dbg_printf(" (*%s)(", name);
585 if (types_get_info(linear, typeid, TI_GET_CHILDRENCOUNT, &count))
586 {
587 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
588 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
589 int i;
590
591 fcp->Start = 0;
592 while (count)
593 {
594 fcp->Count = min(count, 256);
595 if (types_get_info(linear, typeid, TI_FINDCHILDREN, fcp))
596 {
597 for (i = 0; i < min(fcp->Count, count); i++)
598 {
599 types_print_type(linear, fcp->ChildId[i], FALSE);
600 if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
601 }
602 }
603 count -= min(count, 256);
604 fcp->Start += 256;
605 }
606 }
607 dbg_printf(")");
608 break;
609 default:
610 WINE_ERR("Unknown type %lu for %s\n", tag, name);
611 break;
612 }
613
614 return TRUE;
615 }
616
617 BOOL types_get_info(unsigned long modbase, unsigned long typeid,
618 IMAGEHLP_SYMBOL_TYPE_INFO ti, void* pInfo)
619 {
620 if (typeid == dbg_itype_none) return FALSE;
621 if (typeid < dbg_itype_first)
622 {
623 BOOL ret;
624 DWORD tag;
625
626 ret = SymGetTypeInfo(dbg_curr_process->handle, modbase, typeid, ti, pInfo);
627 if (!ret && ti == TI_GET_LENGTH &&
628 (!SymGetTypeInfo(dbg_curr_process->handle, modbase, typeid,
629 TI_GET_SYMTAG, &tag) || tag == SymTagData))
630 {
631 WINE_FIXME("get length on symtag data is no longer supported\n");
632 assert(0);
633 }
634 return ret;
635 }
636 assert(modbase);
637
638 /* helper to typecast pInfo to its expected type (_t) */
639 #define X(_t) (*((_t*)pInfo))
640
641 switch (typeid)
642 {
643 case dbg_itype_unsigned_int:
644 switch (ti)
645 {
646 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
647 case TI_GET_LENGTH: X(DWORD) = 4; break;
648 case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
649 default: WINE_FIXME("unsupported %u for u-int\n", ti); return FALSE;
650 }
651 break;
652 case dbg_itype_signed_int:
653 switch (ti)
654 {
655 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
656 case TI_GET_LENGTH: X(DWORD) = 4; break;
657 case TI_GET_BASETYPE: X(DWORD) = btInt; break;
658 default: WINE_FIXME("unsupported %u for s-int\n", ti); return FALSE;
659 }
660 break;
661 case dbg_itype_unsigned_short_int:
662 switch (ti)
663 {
664 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
665 case TI_GET_LENGTH: X(DWORD) = 2; break;
666 case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
667 default: WINE_FIXME("unsupported %u for u-short int\n", ti); return FALSE;
668 }
669 break;
670 case dbg_itype_signed_short_int:
671 switch (ti)
672 {
673 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
674 case TI_GET_LENGTH: X(DWORD) = 2; break;
675 case TI_GET_BASETYPE: X(DWORD) = btInt; break;
676 default: WINE_FIXME("unsupported %u for s-short int\n", ti); return FALSE;
677 }
678 break;
679 case dbg_itype_unsigned_char_int:
680 switch (ti)
681 {
682 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
683 case TI_GET_LENGTH: X(DWORD) = 1; break;
684 case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
685 default: WINE_FIXME("unsupported %u for u-char int\n", ti); return FALSE;
686 }
687 break;
688 case dbg_itype_signed_char_int:
689 switch (ti)
690 {
691 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
692 case TI_GET_LENGTH: X(DWORD) = 1; break;
693 case TI_GET_BASETYPE: X(DWORD) = btInt; break;
694 default: WINE_FIXME("unsupported %u for s-char int\n", ti); return FALSE;
695 }
696 break;
697 case dbg_itype_char:
698 switch (ti)
699 {
700 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
701 case TI_GET_LENGTH: X(DWORD) = 1; break;
702 case TI_GET_BASETYPE: X(DWORD) = btChar; break;
703 default: WINE_FIXME("unsupported %u for char int\n", ti); return FALSE;
704 }
705 break;
706 case dbg_itype_astring:
707 switch (ti)
708 {
709 case TI_GET_SYMTAG: X(DWORD) = SymTagPointerType; break;
710 case TI_GET_LENGTH: X(DWORD) = 4; break;
711 case TI_GET_TYPE: X(DWORD) = dbg_itype_char; break;
712 default: WINE_FIXME("unsupported %u for a string\n", ti); return FALSE;
713 }
714 break;
715 default: WINE_FIXME("unsupported typeid 0x%lx\n", typeid);
716 }
717
718 #undef X
719 return TRUE;
720 }
Maarten's multimedia branch