git.oblomov.eu Git - wine/blob - debugger/types.c

   1 /*
   2  * File types.c - datatype handling stuff for internal debugger.
   3  *
   4  * Copyright (C) 1997, Eric Youngdale.
   5  *
   6  * This really doesn't do much at the moment, but it forms the framework
   7  * upon which full support for datatype handling will eventually be hung.
   8  */
   9
  10 #include "config.h"
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13
  14 #include <assert.h>
  15 #include <fcntl.h>
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18 #include <limits.h>
  19 #include <string.h>
  20 #include <unistd.h>
  21
  22 #include "pe_image.h"
  23 #include "peexe.h"
  24 #include "debugger.h"
  25 #include "peexe.h"
  26
  27 #define NR_TYPE_HASH 521
  28
  29 int               DEBUG_nchar;
  30 static int        DEBUG_maxchar = 1024;
  31
  32 struct en_values
  33 {
  34   struct en_values* next;
  35   char            * name;
  36   int               value;
  37 };
  38
  39 struct member
  40 {
  41   struct member   * next;
  42   char            * name;
  43   struct datatype * type;
  44   int               offset;
  45   int               size;
  46 };
  47
  48 struct datatype
  49 {
  50   enum  debug_type type;
  51   struct datatype * next;
  52   char * name;
  53   union
  54   {
  55     struct
  56     {
  57       char    basic_type;
  58       char  * output_format;
  59       char    basic_size;
  60       unsigned b_signed:1;
  61     } basic;
  62     struct
  63     {
  64       unsigned short bitoff;
  65       unsigned short nbits;
  66       struct datatype * basetype;
  67     } bitfield;
  68
  69     struct
  70     {
  71       struct datatype * pointsto;
  72     } pointer;
  73     struct
  74     {
  75       struct datatype * rettype;
  76     } funct;
  77     struct
  78     {
  79       int               start;
  80       int               end;
  81       struct datatype * basictype;
  82     } array;
  83     struct
  84     {
  85       int               size;
  86       struct member * members;
  87     } structure;
  88     struct
  89     {
  90       struct en_values * members;
  91     } enumeration;
  92   } un;
  93 };
  94
  95 #define BASIC_INT               1
  96 #define BASIC_CHAR              2
  97 #define BASIC_LONG              3
  98 #define BASIC_UINT              4
  99 #define BASIC_LUI               5
 100 #define BASIC_LONGLONG          6
 101 #define BASIC_ULONGLONGI        7
 102 #define BASIC_SHORT             8
 103 #define BASIC_SHORTUI           9
 104 #define BASIC_SCHAR             10
 105 #define BASIC_UCHAR             11
 106 #define BASIC_FLT               12
 107 #define BASIC_LONG_DOUBLE       13
 108 #define BASIC_DOUBLE            14
 109 #define BASIC_CMPLX_INT         15
 110 #define BASIC_CMPLX_FLT         16
 111 #define BASIC_CMPLX_DBL         17
 112 #define BASIC_CMPLX_LONG_DBL    18
 113 #define BASIC_VOID              19
 114
 115 struct datatype * DEBUG_TypeInt = NULL;
 116 struct datatype * DEBUG_TypeIntConst = NULL;
 117 struct datatype * DEBUG_TypeUSInt = NULL;
 118 struct datatype * DEBUG_TypeString = NULL;
 119
 120 /*
 121  * All of the types that have been defined so far.
 122  */
 123 static struct datatype * type_hash_table[NR_TYPE_HASH + 1];
 124 static struct datatype * pointer_types = NULL;
 125
 126 static unsigned int type_hash( const char * name )
 127 {
 128     unsigned int hash = 0;
 129     unsigned int tmp;
 130     const char * p;
 131
 132     p = name;
 133
 134     while (*p)
 135       {
 136         hash = (hash << 4) + *p++;
 137
 138         if( (tmp = (hash & 0xf0000000)) )
 139           {
 140             hash ^= tmp >> 24;
 141           }
 142         hash &= ~tmp;
 143       }
 144     return hash % NR_TYPE_HASH;
 145 }
 146
 147
 148 static struct datatype *
 149 DEBUG_InitBasic(int type, char * name, int size, int b_signed,
 150                             char * output_format)
 151 {
 152   int hash;
 153
 154   struct datatype * dt;
 155   dt = (struct datatype *) DBG_alloc(sizeof(struct datatype));
 156
 157   if( dt != NULL )
 158     {
 159       if( name != NULL )
 160         {
 161           hash = type_hash(name);
 162         }
 163       else
 164         {
 165           hash = NR_TYPE_HASH;
 166         }
 167
 168       dt->type = DT_BASIC;
 169       dt->name = name;
 170       dt->next = type_hash_table[hash];
 171       type_hash_table[hash] = dt;
 172       dt->un.basic.basic_type = type;
 173       dt->un.basic.basic_size = size;
 174       dt->un.basic.b_signed = b_signed;
 175       dt->un.basic.output_format = output_format;
 176     }
 177
 178   return dt;
 179 }
 180
 181 static
 182 struct datatype *
 183 DEBUG_LookupDataType(enum debug_type xtype, int hash, const char * typename)
 184 {
 185   struct datatype * dt = NULL;
 186
 187   if( typename != NULL )
 188     {
 189       for( dt = type_hash_table[hash]; dt; dt = dt->next )
 190         {
 191           if( xtype != dt->type || dt->name == NULL
 192               || dt->name[0] != typename[0])
 193             {
 194               continue;
 195             }
 196
 197           if( strcmp(dt->name, typename) == 0 )
 198             {
 199               return dt;
 200             }
 201         }
 202     }
 203
 204   return dt;
 205 }
 206
 207 struct datatype *
 208 DEBUG_NewDataType(enum debug_type xtype, const char * typename)
 209 {
 210   struct datatype * dt = NULL;
 211   int hash;
 212
 213   /*
 214    * The last bucket is special, and is used to hold typeless names.
 215    */
 216   if( typename == NULL )
 217     {
 218       hash = NR_TYPE_HASH;
 219     }
 220   else
 221     {
 222       hash = type_hash(typename);
 223     }
 224
 225   dt = DEBUG_LookupDataType(xtype, hash, typename);
 226
 227   if( dt == NULL )
 228     {
 229       dt = (struct datatype *) DBG_alloc(sizeof(struct datatype));
 230
 231       if( dt != NULL )
 232         {
 233           memset(dt, 0, sizeof(*dt));
 234
 235           dt->type = xtype;
 236           if( typename != NULL )
 237             {
 238               dt->name = DBG_strdup(typename);
 239             }
 240           else
 241             {
 242               dt->name = NULL;
 243             }
 244           if( xtype == DT_POINTER )
 245             {
 246               dt->next = pointer_types;
 247               pointer_types = dt;
 248             }
 249           else
 250             {
 251               dt->next = type_hash_table[hash];
 252               type_hash_table[hash] = dt;
 253             }
 254         }
 255     }
 256
 257   return dt;
 258 }
 259
 260 struct datatype *
 261 DEBUG_FindOrMakePointerType(struct datatype * reftype)
 262 {
 263   struct datatype * dt = NULL;
 264
 265   if( reftype != NULL )
 266     {
 267       for( dt = pointer_types; dt; dt = dt->next )
 268         {
 269           if( dt->type != DT_POINTER )
 270             {
 271               continue;
 272             }
 273
 274           if( dt->un.pointer.pointsto == reftype )
 275             {
 276               return dt;
 277             }
 278         }
 279     }
 280
 281   if( dt == NULL )
 282     {
 283       dt = (struct datatype *) DBG_alloc(sizeof(struct datatype));
 284
 285       if( dt != NULL )
 286         {
 287           dt->type = DT_POINTER;
 288           dt->un.pointer.pointsto = reftype;
 289           dt->next = pointer_types;
 290           pointer_types = dt;
 291         }
 292     }
 293
 294   return dt;
 295 }
 296
 297 void
 298 DEBUG_InitTypes()
 299 {
 300   static int beenhere = 0;
 301   struct datatype * chartype;
 302
 303   if( beenhere++ != 0 )
 304     {
 305       return;
 306     }
 307
 308   /*
 309    * Special version of int used with constants of various kinds.
 310    */
 311   DEBUG_TypeIntConst = DEBUG_InitBasic(BASIC_INT,NULL,4,1,"%d");
 312
 313   /*
 314    * Initialize a few builtin types.
 315    */
 316
 317
 318   DEBUG_TypeInt = DEBUG_InitBasic(BASIC_INT,"int",4,1,"%d");
 319   chartype = DEBUG_InitBasic(BASIC_CHAR,"char",1,1,"'%c'");
 320   DEBUG_InitBasic(BASIC_LONG,"long int",4,1,"%d");
 321   DEBUG_TypeUSInt = DEBUG_InitBasic(BASIC_UINT,"unsigned int",4,0,"%d");
 322   DEBUG_InitBasic(BASIC_LUI,"long unsigned int",4,0,"%d");
 323   DEBUG_InitBasic(BASIC_LONGLONG,"long long int",8,1,"%ld");
 324   DEBUG_InitBasic(BASIC_ULONGLONGI,"long long unsigned int",8,0,"%ld");
 325   DEBUG_InitBasic(BASIC_SHORT,"short int",2,1,"%d");
 326   DEBUG_InitBasic(BASIC_SHORTUI,"short unsigned int",2,0,"%d");
 327   DEBUG_InitBasic(BASIC_SCHAR,"signed char",1,1,"'%c'");
 328   DEBUG_InitBasic(BASIC_UCHAR,"unsigned char",1,0,"'%c'");
 329   DEBUG_InitBasic(BASIC_FLT,"float",4,0,"%f");
 330   DEBUG_InitBasic(BASIC_LONG_DOUBLE,"double",8,0,"%lf");
 331   DEBUG_InitBasic(BASIC_DOUBLE,"long double",12,0,NULL);
 332   DEBUG_InitBasic(BASIC_CMPLX_INT,"complex int",8,1,NULL);
 333   DEBUG_InitBasic(BASIC_CMPLX_FLT,"complex float",8,0,NULL);
 334   DEBUG_InitBasic(BASIC_CMPLX_DBL,"complex double",16,0,NULL);
 335   DEBUG_InitBasic(BASIC_CMPLX_LONG_DBL,"complex long double",24,0,NULL);
 336   DEBUG_InitBasic(BASIC_VOID,"void",0,0,NULL);
 337
 338   DEBUG_TypeString = DEBUG_NewDataType(DT_POINTER, NULL);
 339   DEBUG_SetPointerType(DEBUG_TypeString, chartype);
 340
 341   /*
 342    * Now initialize the builtins for codeview.
 343    */
 344   DEBUG_InitCVDataTypes();
 345
 346 }
 347
 348 long long int
 349 DEBUG_GetExprValue(DBG_ADDR * addr, char ** format)
 350 {
 351   DBG_ADDR address = *addr;
 352   unsigned int rtn;
 353   struct datatype * type2 = NULL;
 354   struct en_values * e;
 355   char * def_format = "0x%x";
 356
 357   rtn = 0;
 358   address.seg = 0; /* FIXME? I don't quite get this... */
 359   assert(addr->type != NULL);
 360
 361   switch(addr->type->type)
 362     {
 363     case DT_BASIC:
 364       if (!DBG_CHECK_READ_PTR( &address,  addr->type->un.basic.basic_size))
 365         {
 366           return 0;
 367         }
 368
 369       memcpy(&rtn, (char *) addr->off, addr->type->un.basic.basic_size);
 370       if(    (addr->type->un.basic.b_signed)
 371           && ((addr->type->un.basic.basic_size & 3) != 0)
 372           && ((rtn >> (addr->type->un.basic.basic_size * 8 - 1)) != 0) )
 373         {
 374           rtn = rtn | ((-1) << (addr->type->un.basic.basic_size * 8));
 375         }
 376       if( addr->type->un.basic.output_format != NULL )
 377         {
 378           def_format = addr->type->un.basic.output_format;
 379         }
 380
 381       /*
 382        * Check for single character prints that are out of range.
 383        */
 384       if( addr->type->un.basic.basic_size == 1
 385           && strcmp(def_format, "'%c'") == 0
 386           && ((rtn < 0x20) || (rtn > 0x80)) )
 387         {
 388           def_format = "%d";
 389         }
 390       break;
 391     case DT_POINTER:
 392       if (!DBG_CHECK_READ_PTR( &address, 1 )) return 0;
 393       rtn = (unsigned int)  *((unsigned char **)addr->off);
 394       type2 = addr->type->un.pointer.pointsto;
 395       if( type2->type == DT_BASIC && type2->un.basic.basic_size == 1 )
 396         {
 397           def_format = "\"%s\"";
 398           break;
 399         }
 400       else
 401         {
 402           def_format = "0x%8.8x";
 403         }
 404       break;
 405     case DT_ARRAY:
 406     case DT_STRUCT:
 407       if (!DBG_CHECK_READ_PTR( &address, 1 )) return 0;
 408       rtn = (unsigned int)  *((unsigned char **)addr->off);
 409       def_format = "0x%8.8x";
 410       break;
 411     case DT_ENUM:
 412       if (!DBG_CHECK_READ_PTR( &address, 1 )) return 0;
 413       rtn = (unsigned int)  *((unsigned char **)addr->off);
 414       for(e = addr->type->un.enumeration.members; e; e = e->next )
 415         {
 416           if( e->value == rtn )
 417             {
 418               break;
 419             }
 420         }
 421       if( e != NULL )
 422         {
 423           rtn = (int) e->name;
 424           def_format = "%s";
 425         }
 426       else
 427         {
 428           def_format = "%d";
 429         }
 430       break;
 431     default:
 432       rtn = 0;
 433       break;
 434     }
 435
 436
 437   if( format != NULL )
 438     {
 439       *format = def_format;
 440     }
 441   return rtn;
 442 }
 443
 444 unsigned int
 445 DEBUG_TypeDerefPointer(DBG_ADDR * addr, struct datatype ** newtype)
 446 {
 447   DBG_ADDR address = *addr;
 448
 449   /*
 450    * Make sure that this really makes sense.
 451    */
 452   if( addr->type->type != DT_POINTER )
 453     {
 454       *newtype = NULL;
 455       return 0;
 456     }
 457
 458   *newtype = addr->type->un.pointer.pointsto;
 459   address.off = *(unsigned int*) (addr->off);
 460   return (unsigned int)DBG_ADDR_TO_LIN(&address); /* FIXME: is this right (or "better") ? */
 461 }
 462
 463 unsigned int
 464 DEBUG_FindStructElement(DBG_ADDR * addr, const char * ele_name, int * tmpbuf)
 465 {
 466   struct member * m;
 467   unsigned int    mask;
 468
 469   /*
 470    * Make sure that this really makes sense.
 471    */
 472   if( addr->type->type != DT_STRUCT )
 473     {
 474       addr->type = NULL;
 475       return FALSE;
 476     }
 477
 478   for(m = addr->type->un.structure.members; m; m = m->next)
 479     {
 480       if( strcmp(m->name, ele_name) == 0 )
 481         {
 482           addr->type = m->type;
 483           if( (m->offset & 7) != 0 || (m->size & 7) != 0)
 484             {
 485               /*
 486                * Bitfield operation.  We have to extract the field and store
 487                * it in a temporary buffer so that we get it all right.
 488                */
 489               *tmpbuf = ((*(int* ) (addr->off + (m->offset >> 3))) >> (m->offset & 7));
 490               addr->off = (int) tmpbuf;
 491
 492               mask = 0xffffffff << (m->size);
 493               *tmpbuf &= ~mask;
 494               /*
 495                * OK, now we have the correct part of the number.
 496                * Check to see whether the basic type is signed or not, and if so,
 497                * we need to sign extend the number.
 498                */
 499               if( m->type->type == DT_BASIC && m->type->un.basic.b_signed != 0
 500                   && (*tmpbuf & (1 << (m->size - 1))) != 0 )
 501                 {
 502                   *tmpbuf |= mask;
 503                 }
 504             }
 505           else
 506             {
 507               addr->off += (m->offset >> 3);
 508             }
 509           return TRUE;
 510         }
 511     }
 512
 513   addr->type = NULL;
 514   return FALSE;
 515 }
 516
 517 int
 518 DEBUG_SetStructSize(struct datatype * dt, int size)
 519 {
 520   assert(dt->type == DT_STRUCT);
 521
 522   if( dt->un.structure.members != NULL )
 523     {
 524       return FALSE;
 525     }
 526
 527   dt->un.structure.size = size;
 528   dt->un.structure.members = NULL;
 529
 530   return TRUE;
 531 }
 532
 533 int
 534 DEBUG_CopyFieldlist(struct datatype * dt, struct datatype * dt2)
 535 {
 536
 537   assert( dt->type == dt2->type && ((dt->type == DT_STRUCT) || (dt->type == DT_ENUM)));
 538
 539   if( dt->type == DT_STRUCT )
 540     {
 541       dt->un.structure.members = dt2->un.structure.members;
 542     }
 543   else
 544     {
 545       dt->un.enumeration.members = dt2->un.enumeration.members;
 546     }
 547
 548   return TRUE;
 549 }
 550
 551 int
 552 DEBUG_AddStructElement(struct datatype * dt, char * name, struct datatype * type,
 553                        int offset, int size)
 554 {
 555   struct member * m;
 556   struct member * last;
 557   struct en_values * e;
 558
 559   if( dt->type == DT_STRUCT )
 560     {
 561       for(last = dt->un.structure.members; last; last = last->next)
 562         {
 563           if(    (last->name[0] == name[0])
 564               && (strcmp(last->name, name) == 0) )
 565             {
 566               return TRUE;
 567             }
 568           if( last->next == NULL )
 569             {
 570               break;
 571             }
 572         }
 573       m = (struct member *) DBG_alloc(sizeof(struct member));
 574       if( m == FALSE )
 575         {
 576           return FALSE;
 577         }
 578
 579       m->name = DBG_strdup(name);
 580       m->type = type;
 581       m->offset = offset;
 582       m->size = size;
 583       if( last == NULL )
 584         {
 585           m->next = dt->un.structure.members;
 586           dt->un.structure.members = m;
 587         }
 588       else
 589         {
 590           last->next = m;
 591           m->next = NULL;
 592         }
 593       /*
 594        * If the base type is bitfield, then adjust the offsets here so that we
 595        * are able to look things up without lots of falter-all.
 596        */
 597       if( type->type == DT_BITFIELD )
 598         {
 599           m->offset += m->type->un.bitfield.bitoff;
 600           m->size = m->type->un.bitfield.nbits;
 601           m->type = m->type->un.bitfield.basetype;
 602         }
 603     }
 604   else if( dt->type == DT_ENUM )
 605     {
 606       e = (struct en_values *) DBG_alloc(sizeof(struct en_values));
 607       if( e == FALSE )
 608         {
 609           return FALSE;
 610         }
 611
 612       e->name = DBG_strdup(name);
 613       e->value = offset;
 614       e->next = dt->un.enumeration.members;
 615       dt->un.enumeration.members = e;
 616     }
 617   else
 618     {
 619       assert(FALSE);
 620     }
 621   return TRUE;
 622 }
 623
 624 struct datatype *
 625 DEBUG_GetPointerType(struct datatype * dt)
 626 {
 627   if( dt->type == DT_POINTER )
 628     {
 629       return dt->un.pointer.pointsto;
 630     }
 631
 632   return NULL;
 633 }
 634
 635 int
 636 DEBUG_SetPointerType(struct datatype * dt, struct datatype * dt2)
 637 {
 638   switch(dt->type)
 639     {
 640     case DT_POINTER:
 641       dt->un.pointer.pointsto = dt2;
 642       break;
 643     case DT_FUNC:
 644       dt->un.funct.rettype = dt2;
 645       break;
 646     default:
 647       assert(FALSE);
 648     }
 649
 650   return TRUE;
 651 }
 652
 653 int
 654 DEBUG_SetArrayParams(struct datatype * dt, int min, int max, struct datatype * dt2)
 655 {
 656   assert(dt->type == DT_ARRAY);
 657   dt->un.array.start = min;
 658   dt->un.array.end   = max;
 659   dt->un.array.basictype = dt2;
 660
 661   return TRUE;
 662 }
 663
 664 int
 665 DEBUG_SetBitfieldParams(struct datatype * dt, int offset, int nbits,
 666                         struct datatype * dt2)
 667 {
 668   assert(dt->type == DT_BITFIELD);
 669   dt->un.bitfield.bitoff   = offset;
 670   dt->un.bitfield.nbits    = nbits;
 671   dt->un.bitfield.basetype = dt2;
 672
 673   return TRUE;
 674 }
 675
 676 int DEBUG_GetObjectSize(struct datatype * dt)
 677 {
 678   if( dt == NULL )
 679     {
 680       return 0;
 681     }
 682
 683   switch(dt->type)
 684     {
 685     case DT_BASIC:
 686       return dt->un.basic.basic_size;
 687     case DT_POINTER:
 688       return sizeof(int *);
 689     case DT_STRUCT:
 690       return dt->un.structure.size;
 691     case DT_ENUM:
 692       return sizeof(int);
 693     case DT_ARRAY:
 694       return (dt->un.array.end - dt->un.array.start)
 695         * DEBUG_GetObjectSize(dt->un.array.basictype);
 696     case DT_BITFIELD:
 697       /*
 698        * Bitfields have to be handled seperately later on
 699        * when we insert the element into the structure.
 700        */
 701       return 0;
 702     case DT_TYPEDEF:
 703     case DT_FUNC:
 704     case DT_CONST:
 705       assert(FALSE);
 706     }
 707   return 0;
 708 }
 709
 710 unsigned int
 711 DEBUG_ArrayIndex(DBG_ADDR * addr, DBG_ADDR * result, int index)
 712 {
 713   int size;
 714
 715   /*
 716    * Make sure that this really makes sense.
 717    */
 718   if( addr->type->type == DT_POINTER )
 719     {
 720       /*
 721        * Get the base type, so we know how much to index by.
 722        */
 723       size = DEBUG_GetObjectSize(addr->type->un.pointer.pointsto);
 724       result->type = addr->type->un.pointer.pointsto;
 725       result->off = (*(unsigned int*) (addr->off)) + size * index;
 726     }
 727   else if (addr->type->type == DT_ARRAY)
 728     {
 729       size = DEBUG_GetObjectSize(addr->type->un.array.basictype);
 730       result->type = addr->type->un.array.basictype;
 731       result->off = addr->off + size * (index - addr->type->un.array.start);
 732     }
 733
 734   return TRUE;
 735 }
 736
 737 /***********************************************************************
 738  *           DEBUG_Print
 739  *
 740  * Implementation of the 'print' command.
 741  */
 742 void
 743 DEBUG_Print( const DBG_ADDR *addr, int count, char format, int level )
 744 {
 745   DBG_ADDR        addr1;
 746   int             i;
 747   struct member * m;
 748   char          * pnt;
 749   int             size;
 750   long long int   value;
 751
 752   if (count != 1)
 753     {
 754       fprintf( stderr, "Count other than 1 is meaningless in 'print' command\n" );
 755       return;
 756     }
 757
 758   if( addr->type == NULL )
 759   {
 760       /* No type, just print the addr value */
 761       if (addr->seg && (addr->seg != 0xffffffff))
 762           DEBUG_nchar += fprintf( stderr, "0x%04lx: ", addr->seg );
 763       DEBUG_nchar += fprintf( stderr, "0x%08lx", addr->off );
 764       goto leave;
 765   }
 766
 767   if( level == 0 )
 768     {
 769       DEBUG_nchar = 0;
 770     }
 771
 772   if( DEBUG_nchar > DEBUG_maxchar )
 773     {
 774       fprintf(stderr, "...");
 775       goto leave;
 776     }
 777
 778   if( format == 'i' || format == 's' || format == 'w' || format == 'b' )
 779     {
 780       fprintf( stderr, "Format specifier '%c' is meaningless in 'print' command\n", format );
 781       format = '\0';
 782     }
 783
 784   switch(addr->type->type)
 785     {
 786     case DT_BASIC:
 787     case DT_ENUM:
 788     case DT_CONST:
 789     case DT_POINTER:
 790       DEBUG_PrintBasic(addr, 1, format);
 791       break;
 792     case DT_STRUCT:
 793       DEBUG_nchar += fprintf(stderr, "{");
 794       for(m = addr->type->un.structure.members; m; m = m->next)
 795         {
 796           addr1 = *addr;
 797           DEBUG_FindStructElement(&addr1, m->name,
 798                                   (int *) &value);
 799           DEBUG_nchar += fprintf(stderr, "%s=", m->name);
 800           DEBUG_Print(&addr1, 1, format, level + 1);
 801           if( m->next != NULL )
 802             {
 803               DEBUG_nchar += fprintf(stderr, ", ");
 804             }
 805           if( DEBUG_nchar > DEBUG_maxchar )
 806             {
 807               fprintf(stderr, "...}");
 808               goto leave;
 809             }
 810         }
 811       DEBUG_nchar += fprintf(stderr, "}");
 812       break;
 813     case DT_ARRAY:
 814       /*
 815        * Loop over all of the entries, printing stuff as we go.
 816        */
 817       size = DEBUG_GetObjectSize(addr->type->un.array.basictype);
 818       if( size == 1 )
 819         {
 820           /*
 821            * Special handling for character arrays.
 822            */
 823           pnt = (char *) addr->off;
 824           DEBUG_nchar += fprintf(stderr, "\"");
 825           for( i=addr->type->un.array.start; i < addr->type->un.array.end; i++ )
 826             {
 827               fputc(*pnt++, stderr);
 828               DEBUG_nchar++;
 829               if( DEBUG_nchar > DEBUG_maxchar )
 830                 {
 831                   fprintf(stderr, "...\"");
 832                   goto leave;
 833                 }
 834             }
 835           DEBUG_nchar += fprintf(stderr, "\"");
 836           break;
 837         }
 838       addr1 = *addr;
 839       addr1.type = addr->type->un.array.basictype;
 840       DEBUG_nchar += fprintf(stderr, "{");
 841       for( i=addr->type->un.array.start; i <= addr->type->un.array.end; i++ )
 842         {
 843           DEBUG_Print(&addr1, 1, format, level + 1);
 844           addr1.off += size;
 845           if( i == addr->type->un.array.end )
 846             {
 847               DEBUG_nchar += fprintf(stderr, "}");
 848             }
 849           else
 850             {
 851               DEBUG_nchar += fprintf(stderr, ", ");
 852             }
 853           if( DEBUG_nchar > DEBUG_maxchar )
 854             {
 855               fprintf(stderr, "...}");
 856               goto leave;
 857             }
 858         }
 859       break;
 860     default:
 861       assert(FALSE);
 862       break;
 863     }
 864
 865 leave:
 866
 867   if( level == 0 )
 868     {
 869       DEBUG_nchar += fprintf(stderr, "\n");
 870     }
 871   return;
 872 }
 873
 874 int
 875 DEBUG_DumpTypes()
 876 {
 877   struct datatype * dt = NULL;
 878   struct member * m;
 879   int hash;
 880   int nm;
 881   char * name;
 882   char * member_name;
 883
 884   for(hash = 0; hash < NR_TYPE_HASH + 1; hash++)
 885     {
 886       for( dt = type_hash_table[hash]; dt; dt = dt->next )
 887         {
 888           name =  "none";
 889           if( dt->name != NULL )
 890             {
 891               name = dt->name;
 892             }
 893           switch(dt->type)
 894             {
 895             case DT_BASIC:
 896               fprintf(stderr, "0x%p - BASIC(%s)\n",
 897                       dt, name);
 898               break;
 899             case DT_POINTER:
 900               fprintf(stderr, "0x%p - POINTER(%s)(%p)\n",
 901                       dt, name, dt->un.pointer.pointsto);
 902               break;
 903             case DT_STRUCT:
 904               member_name = "none";
 905               nm = 0;
 906               if( dt->un.structure.members != NULL
 907                   && dt->un.structure.members->name != NULL )
 908                 {
 909                   member_name = dt->un.structure.members->name;
 910                   for( m = dt->un.structure.members; m; m = m->next)
 911                     {
 912                       nm++;
 913                     }
 914                 }
 915               fprintf(stderr, "0x%p - STRUCT(%s) %d %d %s\n", dt, name,
 916                       dt->un.structure.size, nm, member_name);
 917               break;
 918             case DT_ARRAY:
 919               fprintf(stderr, "0x%p - ARRAY(%s)(%p)\n",
 920                       dt, name, dt->un.array.basictype);
 921               break;
 922             case DT_ENUM:
 923               fprintf(stderr, "0x%p - ENUM(%s)\n",
 924                       dt, name);
 925               break;
 926             case DT_BITFIELD:
 927               fprintf(stderr, "0x%p - BITFIELD(%s)\n", dt, name);
 928               break;
 929             case DT_FUNC:
 930               fprintf(stderr, "0x%p - FUNC(%s)(%p)\n",
 931                       dt, name, dt->un.funct.rettype);
 932               break;
 933             case DT_CONST:
 934             case DT_TYPEDEF:
 935               fprintf(stderr, "What???\n");
 936               break;
 937             }
 938         }
 939     }
 940   return TRUE;
 941 }
 942
 943
 944 enum debug_type DEBUG_GetType(struct datatype * dt)
 945 {
 946   return dt->type;
 947 }
 948
 949 struct datatype *
 950 DEBUG_TypeCast(enum debug_type type, const char * name)
 951 {
 952   int                     hash;
 953   struct datatype       * rtn;
 954
 955   /*
 956    * The last bucket is special, and is used to hold typeless names.
 957    */
 958   if( name == NULL )
 959     {
 960       hash = NR_TYPE_HASH;
 961     }
 962   else
 963     {
 964       hash = type_hash(name);
 965     }
 966
 967   rtn = DEBUG_LookupDataType(type, hash, name);
 968
 969   return rtn;
 970
 971 }
 972
 973 int
 974 DEBUG_PrintTypeCast(struct datatype * dt)
 975 {
 976   char          * name;
 977
 978   name =  "none";
 979   if( dt->name != NULL )
 980     {
 981       name = dt->name;
 982     }
 983
 984   switch(dt->type)
 985     {
 986     case DT_BASIC:
 987       fprintf(stderr, "%s", name);
 988       break;
 989     case DT_POINTER:
 990       DEBUG_PrintTypeCast(dt->un.pointer.pointsto);
 991       fprintf(stderr, "*");
 992       break;
 993     case DT_STRUCT:
 994       fprintf(stderr, "struct %s", name);
 995       break;
 996     case DT_ARRAY:
 997       fprintf(stderr, "%s[]", name);
 998       break;
 999     case DT_ENUM:
1000       fprintf(stderr, "enum %s", name);
1001       break;
1002     case DT_BITFIELD:
1003       fprintf(stderr, "unsigned %s", name);
1004       break;
1005     case DT_FUNC:
1006       DEBUG_PrintTypeCast(dt->un.funct.rettype);
1007       fprintf(stderr, "(*%s)()", name);
1008       break;
1009     case DT_CONST:
1010     case DT_TYPEDEF:
1011       fprintf(stderr, "What???\n");
1012       break;
1013     }
1014
1015   return TRUE;
1016 }
1017
1018