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