?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't consider no driver a test failure.
[wine/testsucceed.git] / programs / winedbg / types.c
blob0534cc4a80c17e9a00d7a71d641689282897aa00
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 types_get_info(type, TI_GET_LENGTH, &length);
158 if (length > sizeof(*tmpbuf)) return FALSE;
159 /*
160 * Bitfield operation. We have to extract the field and store
161 * it in a temporary buffer so that we get it all right.
162 */
163 lvalue->addr.Offset += offset;
164 if (!memory_read_value(lvalue, sizeof(*tmpbuf), tmpbuf)) return FALSE;
165 mask = 0xffffffff << length;
166 *tmpbuf >>= bitoffset & 7;
167 *tmpbuf &= ~mask;
168
169 lvalue->cookie = DLV_HOST;
170 lvalue->addr.Offset = (DWORD)tmpbuf;
171
172 /*
173 * OK, now we have the correct part of the number.
174 * Check to see whether the basic type is signed or not, and if so,
175 * we need to sign extend the number.
176 */
177 if (types_get_info(&lvalue->type, TI_GET_BASETYPE, &bt) &&
178 bt == btInt && (*tmpbuf & (1 << (length - 1))))
179 {
180 *tmpbuf |= mask;
181 }
182 return TRUE;
183 }
184 if (types_get_info(type, TI_GET_OFFSET, &offset))
185 {
186 lvalue->addr.Offset += offset;
187 return TRUE;
188 }
189 return FALSE;
190 }
191
192 /******************************************************************
193 * types_udt_find_element
194 *
195 */
196 BOOL types_udt_find_element(struct dbg_lvalue* lvalue, const char* name, long int* tmpbuf)
197 {
198 DWORD tag, count;
199 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
200 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
201 WCHAR* ptr;
202 char tmp[256];
203 int i;
204 struct dbg_type type;
205
206 if (!types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag) ||
207 tag != SymTagUDT)
208 return FALSE;
209
210 if (types_get_info(&lvalue->type, TI_GET_CHILDRENCOUNT, &count))
211 {
212 fcp->Start = 0;
213 while (count)
214 {
215 fcp->Count = min(count, 256);
216 if (types_get_info(&lvalue->type, TI_FINDCHILDREN, fcp))
217 {
218 type.module = lvalue->type.module;
219 for (i = 0; i < min(fcp->Count, count); i++)
220 {
221 ptr = NULL;
222 type.id = fcp->ChildId[i];
223 types_get_info(&type, TI_GET_SYMNAME, &ptr);
224 if (!ptr) continue;
225 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
226 HeapFree(GetProcessHeap(), 0, ptr);
227 if (strcmp(tmp, name)) continue;
228
229 return types_get_udt_element_lvalue(lvalue, &type, tmpbuf);
230 }
231 }
232 count -= min(count, 256);
233 fcp->Start += 256;
234 }
235 }
236 return FALSE;
237 }
238
239 /******************************************************************
240 * types_array_index
241 *
242 * Grab an element from an array
243 */
244 BOOL types_array_index(const struct dbg_lvalue* lvalue, int index,
245 struct dbg_lvalue* result)
246 {
247 DWORD tag, length, count;
248
249 if (!types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag))
250 return FALSE;
251 switch (tag)
252 {
253 case SymTagArrayType:
254 types_get_info(&lvalue->type, TI_GET_COUNT, &count);
255 if (index < 0 || index >= count) return FALSE;
256 /* fall through */
257 case SymTagPointerType:
258 /*
259 * Get the base type, so we know how much to index by.
260 */
261 types_get_info(&lvalue->type, TI_GET_TYPE, &result->type.id);
262 result->type.module = lvalue->type.module;
263 types_get_info(&result->type, TI_GET_LENGTH, &length);
264 /* Contents of array must be on same target */
265 result->addr.Mode = lvalue->addr.Mode;
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 types_get_info(&type, TI_GET_TYPE, &type_id);
308 if (types_get_info(&type, TI_GET_TYPE, &type_id) && type_id == user->u.typeid)
309 {
310 user->result = sym->TypeIndex;
311 ret = FALSE;
312 }
313 break;
314 default: break;
315 }
316 }
317 return ret;
318 }
319
320 /******************************************************************
321 * types_find_pointer
322 *
323 * Should look up in module based at linear whether (typeid*) exists
324 * Otherwise, we could create it locally
325 */
326 struct dbg_type types_find_pointer(const struct dbg_type* type)
327 {
328 struct type_find_t f;
329 struct dbg_type ret;
330
331 f.result = dbg_itype_none;
332 f.tag = SymTagPointerType;
333 f.u.typeid = type->id;
334 SymEnumTypes(dbg_curr_process->handle, type->module, types_cb, &f);
335 ret.module = type->module;
336 ret.id = f.result;
337 return ret;
338 }
339
340 /******************************************************************
341 * types_find_type
342 *
343 * Should look up in the module based at linear address whether a type
344 * named 'name' and with the correct tag exists
345 */
346 struct dbg_type types_find_type(unsigned long linear, const char* name, enum SymTagEnum tag)
347
348 {
349 struct type_find_t f;
350 struct dbg_type ret;
351
352 f.result = dbg_itype_none;
353 f.tag = tag;
354 f.u.name = name;
355 SymEnumTypes(dbg_curr_process->handle, linear, types_cb, &f);
356 ret.module = linear;
357 ret.id = f.result;
358 return ret;
359 }
360
361 /***********************************************************************
362 * print_value
363 *
364 * Implementation of the 'print' command.
365 */
366 void print_value(const struct dbg_lvalue* lvalue, char format, int level)
367 {
368 struct dbg_lvalue lvalue_field;
369 int i;
370 DWORD tag;
371 DWORD count;
372 DWORD size;
373
374 if (lvalue->type.id == dbg_itype_none)
375 {
376 /* No type, just print the addr value */
377 print_bare_address(&lvalue->addr);
378 goto leave;
379 }
380
381 if (format == 'i' || format == 's' || format == 'w' || format == 'b' || format == 'g')
382 {
383 dbg_printf("Format specifier '%c' is meaningless in 'print' command\n", format);
384 format = '\0';
385 }
386
387 if (!types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag))
388 {
389 WINE_FIXME("---error\n");
390 return;
391 }
392 switch (tag)
393 {
394 case SymTagBaseType:
395 case SymTagEnum:
396 case SymTagPointerType:
397 print_basic(lvalue, 1, format);
398 break;
399 case SymTagUDT:
400 if (types_get_info(&lvalue->type, TI_GET_CHILDRENCOUNT, &count))
401 {
402 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
403 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
404 WCHAR* ptr;
405 char tmp[256];
406 long int tmpbuf;
407 struct dbg_type type;
408
409 dbg_printf("{");
410 fcp->Start = 0;
411 while (count)
412 {
413 fcp->Count = min(count, 256);
414 if (types_get_info(&lvalue->type, TI_FINDCHILDREN, fcp))
415 {
416 for (i = 0; i < min(fcp->Count, count); i++)
417 {
418 ptr = NULL;
419 type.module = lvalue->type.module;
420 type.id = fcp->ChildId[i];
421 types_get_info(&type, TI_GET_SYMNAME, &ptr);
422 if (!ptr) continue;
423 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
424 dbg_printf("%s=", tmp);
425 HeapFree(GetProcessHeap(), 0, ptr);
426 lvalue_field = *lvalue;
427 if (types_get_udt_element_lvalue(&lvalue_field, &type, &tmpbuf))
428 {
429 print_value(&lvalue_field, format, level + 1);
430 }
431 if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
432 }
433 }
434 count -= min(count, 256);
435 fcp->Start += 256;
436 }
437 dbg_printf("}");
438 }
439 break;
440 case SymTagArrayType:
441 /*
442 * Loop over all of the entries, printing stuff as we go.
443 */
444 count = 1; size = 1;
445 types_get_info(&lvalue->type, TI_GET_COUNT, &count);
446 types_get_info(&lvalue->type, TI_GET_LENGTH, &size);
447
448 if (size == count)
449 {
450 unsigned len;
451 char buffer[256];
452 /*
453 * Special handling for character arrays.
454 */
455 /* FIXME should check basic type here (should be a char!!!!)... */
456 len = min(count, sizeof(buffer));
457 memory_get_string(dbg_curr_process->handle,
458 memory_to_linear_addr(&lvalue->addr),
459 lvalue->cookie == DLV_TARGET, TRUE, buffer, len);
460 dbg_printf("\"%s%s\"", buffer, (len < count) ? "..." : "");
461 break;
462 }
463 lvalue_field = *lvalue;
464 types_get_info(&lvalue->type, TI_GET_TYPE, &lvalue_field.type.id);
465 dbg_printf("{");
466 for (i = 0; i < count; i++)
467 {
468 print_value(&lvalue_field, format, level + 1);
469 lvalue_field.addr.Offset += size / count;
470 dbg_printf((i == count - 1) ? "}" : ", ");
471 }
472 break;
473 case SymTagFunctionType:
474 dbg_printf("Function ");
475 print_bare_address(&lvalue->addr);
476 dbg_printf(": ");
477 types_print_type(&lvalue->type, FALSE);
478 break;
479 default:
480 WINE_FIXME("Unknown tag (%lu)\n", tag);
481 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
482 break;
483 }
484
485 leave:
486
487 if (level == 0) dbg_printf("\n");
488 }
489
490 static BOOL CALLBACK print_types_cb(PSYMBOL_INFO sym, ULONG size, void* ctx)
491 {
492 struct dbg_type type;
493 type.module = sym->ModBase;
494 type.id = sym->TypeIndex;
495 dbg_printf("Mod: %08lx ID: %08lx \n", type.module, type.id);
496 types_print_type(&type, TRUE);
497 dbg_printf("\n");
498 return TRUE;
499 }
500
501 static BOOL CALLBACK print_types_mod_cb(PSTR mod_name, DWORD base, void* ctx)
502 {
503 return SymEnumTypes(dbg_curr_process->handle, base, print_types_cb, ctx);
504 }
505
506 int print_types(void)
507 {
508 SymEnumerateModules(dbg_curr_process->handle, print_types_mod_cb, NULL);
509 return 0;
510 }
511
512 int types_print_type(const struct dbg_type* type, BOOL details)
513 {
514 WCHAR* ptr;
515 char tmp[256];
516 const char* name;
517 DWORD tag, udt, count;
518 struct dbg_type subtype;
519
520 if (type->id == dbg_itype_none || !types_get_info(type, TI_GET_SYMTAG, &tag))
521 {
522 dbg_printf("--invalid--<%lxh>--", type->id);
523 return FALSE;
524 }
525
526 if (types_get_info(type, TI_GET_SYMNAME, &ptr) && ptr)
527 {
528 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
529 name = tmp;
530 HeapFree(GetProcessHeap(), 0, ptr);
531 }
532 else name = "--none--";
533
534 switch (tag)
535 {
536 case SymTagBaseType:
537 if (details) dbg_printf("Basic<%s>", name); else dbg_printf("%s", name);
538 break;
539 case SymTagPointerType:
540 types_get_info(type, TI_GET_TYPE, &subtype.id);
541 subtype.module = type->module;
542 types_print_type(&subtype, FALSE);
543 dbg_printf("*");
544 break;
545 case SymTagUDT:
546 types_get_info(type, TI_GET_UDTKIND, &udt);
547 switch (udt)
548 {
549 case UdtStruct: dbg_printf("struct %s", name); break;
550 case UdtUnion: dbg_printf("union %s", name); break;
551 case UdtClass: dbg_printf("class %s", name); break;
552 default: WINE_ERR("Unsupported UDT type (%ld) for %s", udt, name); break;
553 }
554 if (details &&
555 types_get_info(type, TI_GET_CHILDRENCOUNT, &count))
556 {
557 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
558 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
559 WCHAR* ptr;
560 char tmp[256];
561 int i;
562 struct dbg_type type_elt;
563 dbg_printf(" {");
564
565 fcp->Start = 0;
566 while (count)
567 {
568 fcp->Count = min(count, 256);
569 if (types_get_info(type, TI_FINDCHILDREN, fcp))
570 {
571 for (i = 0; i < min(fcp->Count, count); i++)
572 {
573 ptr = NULL;
574 type_elt.module = type->module;
575 type_elt.id = fcp->ChildId[i];
576 types_get_info(&type_elt, TI_GET_SYMNAME, &ptr);
577 if (!ptr) continue;
578 WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL);
579 HeapFree(GetProcessHeap(), 0, ptr);
580 dbg_printf("%s", tmp);
581 if (types_get_info(&type_elt, TI_GET_TYPE, &type_elt.id))
582 {
583 dbg_printf(":");
584 types_print_type(&type_elt, details);
585 }
586 if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
587 }
588 }
589 count -= min(count, 256);
590 fcp->Start += 256;
591 }
592 dbg_printf("}");
593 }
594 break;
595 case SymTagArrayType:
596 types_get_info(type, TI_GET_TYPE, &subtype.id);
597 subtype.module = type->module;
598 types_print_type(&subtype, details);
599 dbg_printf(" %s[]", name);
600 break;
601 case SymTagEnum:
602 dbg_printf("enum %s", name);
603 break;
604 case SymTagFunctionType:
605 types_get_info(type, TI_GET_TYPE, &subtype.id);
606 subtype.module = type->module;
607 types_print_type(&subtype, FALSE);
608 dbg_printf(" (*%s)(", name);
609 if (types_get_info(type, TI_GET_CHILDRENCOUNT, &count))
610 {
611 char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)];
612 TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer;
613 int i;
614
615 fcp->Start = 0;
616 while (count)
617 {
618 fcp->Count = min(count, 256);
619 if (types_get_info(type, TI_FINDCHILDREN, fcp))
620 {
621 for (i = 0; i < min(fcp->Count, count); i++)
622 {
623 subtype.id = fcp->ChildId[i];
624 types_print_type(&subtype, FALSE);
625 if (i < min(fcp->Count, count) - 1 || count > 256) dbg_printf(", ");
626 }
627 }
628 count -= min(count, 256);
629 fcp->Start += 256;
630 }
631 }
632 dbg_printf(")");
633 break;
634 default:
635 WINE_ERR("Unknown type %lu for %s\n", tag, name);
636 break;
637 }
638
639 return TRUE;
640 }
641
642 BOOL types_get_info(const struct dbg_type* type, IMAGEHLP_SYMBOL_TYPE_INFO ti, void* pInfo)
643 {
644 if (type->id == dbg_itype_none) return FALSE;
645 if (type->module != 0)
646 return SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, ti, pInfo);
647
648 assert(type->id >= dbg_itype_first);
649 /* helper to typecast pInfo to its expected type (_t) */
650 #define X(_t) (*((_t*)pInfo))
651
652 switch (type->id)
653 {
654 case dbg_itype_unsigned_int:
655 switch (ti)
656 {
657 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
658 case TI_GET_LENGTH: X(DWORD) = 4; break;
659 case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
660 default: WINE_FIXME("unsupported %u for u-int\n", ti); return FALSE;
661 }
662 break;
663 case dbg_itype_signed_int:
664 switch (ti)
665 {
666 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
667 case TI_GET_LENGTH: X(DWORD) = 4; break;
668 case TI_GET_BASETYPE: X(DWORD) = btInt; break;
669 default: WINE_FIXME("unsupported %u for s-int\n", ti); return FALSE;
670 }
671 break;
672 case dbg_itype_unsigned_short_int:
673 switch (ti)
674 {
675 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
676 case TI_GET_LENGTH: X(DWORD) = 2; break;
677 case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
678 default: WINE_FIXME("unsupported %u for u-short int\n", ti); return FALSE;
679 }
680 break;
681 case dbg_itype_signed_short_int:
682 switch (ti)
683 {
684 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
685 case TI_GET_LENGTH: X(DWORD) = 2; break;
686 case TI_GET_BASETYPE: X(DWORD) = btInt; break;
687 default: WINE_FIXME("unsupported %u for s-short int\n", ti); return FALSE;
688 }
689 break;
690 case dbg_itype_unsigned_char_int:
691 switch (ti)
692 {
693 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
694 case TI_GET_LENGTH: X(DWORD) = 1; break;
695 case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
696 default: WINE_FIXME("unsupported %u for u-char int\n", ti); return FALSE;
697 }
698 break;
699 case dbg_itype_signed_char_int:
700 switch (ti)
701 {
702 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
703 case TI_GET_LENGTH: X(DWORD) = 1; break;
704 case TI_GET_BASETYPE: X(DWORD) = btInt; break;
705 default: WINE_FIXME("unsupported %u for s-char int\n", ti); return FALSE;
706 }
707 break;
708 case dbg_itype_char:
709 switch (ti)
710 {
711 case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
712 case TI_GET_LENGTH: X(DWORD) = 1; break;
713 case TI_GET_BASETYPE: X(DWORD) = btChar; break;
714 default: WINE_FIXME("unsupported %u for char int\n", ti); return FALSE;
715 }
716 break;
717 case dbg_itype_astring:
718 switch (ti)
719 {
720 case TI_GET_SYMTAG: X(DWORD) = SymTagPointerType; break;
721 case TI_GET_LENGTH: X(DWORD) = 4; break;
722 case TI_GET_TYPE: X(DWORD) = dbg_itype_char; break;
723 default: WINE_FIXME("unsupported %u for a string\n", ti); return FALSE;
724 }
725 break;
726 default: WINE_FIXME("unsupported type id 0x%lx\n", type->id);
727 }
728
729 #undef X
730 return TRUE;
731 }
Quick hack tree for wine patches julliard doesn't want to commit