tools/wrc/dumpres.c

   1 /*
   2  * Copyrignt 1998 Bertho A. Stultiens (BS)
   3  *
   4  * 16-Apr-1998 BS       - Yeah, dump it to stdout.
   5  *
   6  */
   7
   8 #include "config.h"
   9
  10 #include <assert.h>
  11 #include <stdio.h>
  12 #include <ctype.h>
  13
  14 #include "wrc.h"
  15 #include "dumpres.h"
  16
  17 /*
  18  *****************************************************************************
  19  * Function     : get_typename
  20  * Syntax       : char *get_typename(resource_t* r)
  21  * Input        :
  22  *      r       - Resource description
  23  * Output       : A pointer to a string representing the resource type
  24  * Description  :
  25  * Remarks      :
  26  *****************************************************************************
  27 */
  28 char *get_typename(resource_t* r)
  29 {
  30         switch(r->type){
  31         case res_acc:   return "ACCELERATOR";
  32         case res_bmp:   return "BITMAP";
  33         case res_cur:   return "CURSOR";
  34         case res_curg:  return "GROUP_CURSOR";
  35         case res_dlg:   return "DIALOG";
  36         case res_dlgex: return "DIALOGEX";
  37         case res_fnt:   return "FONT";
  38         case res_ico:   return "ICON";
  39         case res_icog:  return "GROUP_ICON";
  40         case res_men:   return "MENU";
  41         case res_menex: return "MENUEX";
  42         case res_rdt:   return "RCDATA";
  43         case res_stt:   return "STRINGTABLE";
  44         case res_usr:   return "UserResource";
  45         case res_msg:   return "MESSAGETABLE";
  46         case res_ver:   return "VERSIONINFO";
  47         case res_dlginit: return "DLGINIT";
  48         case res_toolbar: return "TOOLBAR";
  49         default:        return "Unknown";
  50         }
  51 }
  52
  53 /*
  54  *****************************************************************************
  55  * Function     : strncpyWtoA
  56  * Syntax       : char *strncpyWtoA(char *cs, short *ws, int maxlen)
  57  * Input        :
  58  *      cs      - Pointer to buffer to receive result
  59  *      ws      - Source wide-string
  60  *      maxlen  - Max chars to copy
  61  * Output       : 'cs'
  62  * Description  : Copy a unicode string to ascii. Copying stops after the
  63  *                first occuring '\0' or when maxlen-1 chars are copied. The
  64  *                String is always nul terminated.
  65  * Remarks      : No codepage translation is done.
  66  *****************************************************************************
  67 */
  68 char *strncpyWtoA(char *cs, short *ws, int maxlen)
  69 {
  70         char *cptr = cs;
  71         short *wsMax = ws + maxlen;
  72         while(ws < wsMax)
  73         {
  74                 if(*ws < -128 || *ws > 127)
  75                         printf("***Warning: Unicode string contains non-printable chars***");
  76                 *cptr++ = (char)*ws++;
  77                 maxlen--;
  78         }
  79         *cptr = '\0';
  80         return cs;
  81 }
  82
  83 /*
  84  *****************************************************************************
  85  * Function     : print_string
  86  * Syntax       : void print_string(string_t *str)
  87  * Input        :
  88  * Output       :
  89  * Description  :
  90  * Remarks      :
  91  *****************************************************************************
  92 */
  93 void print_string(string_t *str)
  94 {
  95         char buffer[512];
  96         if(!str)
  97                 printf("<none>");
  98         else if(str->type == str_char)
  99                 printf("\"%s\"", str->str.cstr);
 100         else
 101         {
 102                 strncpyWtoA(buffer, str->str.wstr, sizeof(buffer));
 103                 printf("L\"%s\"", buffer);
 104         }
 105 }
 106
 107 /*
 108  *****************************************************************************
 109  * Function     : get_nameid_str
 110  * Syntax       : char *get_nameid_str(name_id_t *n)
 111  * Input        :
 112  *      n       - nameid to convert to text
 113  * Output       : A pointer to the name.
 114  * Description  :
 115  * Remarks      : Not reentrant because of static buffer
 116  *****************************************************************************
 117 */
 118 char *get_nameid_str(name_id_t *n)
 119 {
 120         static char buffer[256];
 121
 122         if(!n)
 123                 return "<none>";
 124
 125         if(n->type == name_ord)
 126         {
 127                 sprintf(buffer, "%d", n->name.i_name);
 128                 return buffer;
 129         }
 130         else if(n->type == name_str)
 131         {
 132                 if(n->name.s_name->type == str_char)
 133                         return n->name.s_name->str.cstr;
 134                 else
 135                 {
 136                         strncpyWtoA(buffer, n->name.s_name->str.wstr, sizeof(buffer));
 137                         return buffer;
 138                 }
 139         }
 140         else
 141                 return "Hoooo, report this: wrong type in nameid";
 142 }
 143
 144 /*
 145  *****************************************************************************
 146  * Function     : dump_memopt
 147  * Syntax       : void dump_memopt(DWORD memopt)
 148  * Input        :
 149  *      memopt  - flag bits of the options set
 150  * Output       :
 151  * Description  :
 152  * Remarks      :
 153  *****************************************************************************
 154 */
 155 void dump_memopt(DWORD memopt)
 156 {
 157         printf("Memory/load options: ");
 158         if(memopt & 0x0040)
 159                 printf("PRELOAD ");
 160         else
 161                 printf("LOADONCALL ");
 162         if(memopt & 0x0010)
 163                 printf("MOVEABLE ");
 164         else
 165                 printf("FIXED ");
 166         if(memopt & 0x0020)
 167                 printf("PURE ");
 168         else
 169                 printf("IMPURE ");
 170         if(memopt & 0x1000)
 171                 printf("DISCARDABLE");
 172         printf("\n");
 173 }
 174
 175 /*
 176  *****************************************************************************
 177  * Function     : dump_lvc
 178  * Syntax       : void dump_lvc(lvc_t *l)
 179  * Input        :
 180  *      l       - pointer to lvc structure
 181  * Output       :
 182  * Description  : Dump language, version and characteristics
 183  * Remarks      :
 184  *****************************************************************************
 185 */
 186 void dump_lvc(lvc_t *l)
 187 {
 188         if(l->language)
 189                 printf("LANGUAGE %04x, %04x\n", l->language->id, l->language->sub);
 190         else
 191                 printf("LANGUAGE <not set>\n");
 192
 193         if(l->version)
 194                 printf("VERSION %08lx\n", *(l->version));
 195         else
 196                 printf("VERSION <not set>\n");
 197
 198         if(l->characts)
 199                 printf("CHARACTERISTICS %08lx\n", *(l->characts));
 200         else
 201                 printf("CHARACTERISTICS <not set>\n");
 202 }
 203
 204 /*
 205  *****************************************************************************
 206  * Function     : dump_raw_data
 207  * Syntax       : void dump_raw_data(raw_data_t *d)
 208  * Input        :
 209  *      d       - Raw data descriptor
 210  * Output       :
 211  * Description  :
 212  * Remarks      :
 213  *****************************************************************************
 214 */
 215 void dump_raw_data(raw_data_t *d)
 216 {
 217         int n;
 218         int i;
 219         int j;
 220
 221         if(!d)
 222         {
 223                 printf("<none>");
 224                 return;
 225         }
 226         printf("Rawdata size: %d\n", d->size);
 227         if(debuglevel < 2)
 228                 return;
 229
 230         for(n = 0; n < d->size; n++)
 231         {
 232                 if((n % 16) == 0)
 233                 {
 234                         if(n)
 235                         {
 236                                 printf("- ");
 237                                 for(i = 0; i < 16; i++)
 238                                         printf("%c", isprint(d->data[n-16+i]) ? d->data[n-16+i] : '.');
 239                                 printf("\n%08x: ", n);
 240                         }
 241                         else
 242                                 printf("%08x: ", n);
 243                 }
 244                 printf("%02x ", d->data[n] & 0xff);
 245         }
 246         printf("- ");
 247         j = d->size % 16;
 248         if(!j)
 249                 j = 16;
 250         for(i = 0; i < j; i++)
 251                 printf("%c", isprint(d->data[n-j+i]) ? d->data[n-j+i] : '.');
 252         printf("\n");
 253 }
 254
 255 /*
 256  *****************************************************************************
 257  * Function     : dump_accelerator
 258  * Syntax       : void dump_accelerator(resource_t *acc)
 259  * Input        :
 260  *      acc     - Accelerator resource descriptor
 261  * Output       : nop
 262  * Description  :
 263  * Remarks      :
 264  *****************************************************************************
 265 */
 266 void dump_accelerator(accelerator_t *acc)
 267 {
 268         event_t *ev = acc->events;
 269
 270         dump_memopt(acc->memopt);
 271         dump_lvc(&(acc->lvc));
 272
 273         printf("Events: %s\n", ev ? "" : "<none>");
 274         while(ev)
 275         {
 276                 printf("Key=");
 277                 if(isprint(ev->key))
 278                         printf("\"%c\"", ev->key);
 279                 else if(iscntrl(ev->key))
 280                         printf("\"^%c\"", ev->key +'@');
 281                 else
 282                         printf("\\x%02x", ev->key & 0xff);
 283
 284                 printf(" Id=%d flags=%04x\n", ev->id, ev->flags);
 285                 ev = ev->next;
 286         }
 287 }
 288
 289 /*
 290  *****************************************************************************
 291  * Function     : dump_cursor
 292  * Syntax       : void dump_cursor(cursor_t *cur)
 293  * Input        :
 294  *      cur     - Cursor resource descriptor
 295  * Output       : nop
 296  * Description  :
 297  * Remarks      :
 298  *****************************************************************************
 299 */
 300 void dump_cursor(cursor_t *cur)
 301 {
 302         printf("Id: %d\n", cur->id);
 303         printf("Width: %d\n", cur->width);
 304         printf("Height: %d\n", cur->height);
 305         printf("X Hotspot: %d\n", cur->xhot);
 306         printf("Y Hotspot: %d\n", cur->yhot);
 307         dump_raw_data(cur->data);
 308 }
 309
 310 /*
 311  *****************************************************************************
 312  * Function     : dump_cursor_group
 313  * Syntax       : void dump_cursor_group(cursor_group_t *cur)
 314  * Input        :
 315  *      cur     - Cursor group resource descriptor
 316  * Output       : nop
 317  * Description  :
 318  * Remarks      :
 319  *****************************************************************************
 320 */
 321 void dump_cursor_group(cursor_group_t *curg)
 322 {
 323         dump_memopt(curg->memopt);
 324         printf("There are %d cursors in this group\n", curg->ncursor);
 325 }
 326
 327 /*
 328  *****************************************************************************
 329  * Function     : dump_icon
 330  * Syntax       : void dump_icon(icon_t *ico)
 331  * Input        :
 332  *      ico     - Icon resource descriptor
 333  * Output       : nop
 334  * Description  :
 335  * Remarks      :
 336  *****************************************************************************
 337 */
 338 void dump_icon(icon_t *ico)
 339 {
 340         printf("Id: %d\n", ico->id);
 341         printf("Width: %d\n", ico->width);
 342         printf("Height: %d\n", ico->height);
 343         printf("NColor: %d\n", ico->nclr);
 344         printf("NPlanes: %d\n", ico->planes);
 345         printf("NBits: %d\n", ico->bits);
 346         dump_raw_data(ico->data);
 347 }
 348
 349 /*
 350  *****************************************************************************
 351  * Function     : dump_icon_group
 352  * Syntax       : void dump_icon_group(icon_group_t *ico)
 353  * Input        :
 354  *      ico     - Icon group resource descriptor
 355  * Output       : nop
 356  * Description  :
 357  * Remarks      :
 358  *****************************************************************************
 359 */
 360 void dump_icon_group(icon_group_t *icog)
 361 {
 362         dump_memopt(icog->memopt);
 363         printf("There are %d icons in this group\n", icog->nicon);
 364 }
 365
 366 /*
 367  *****************************************************************************
 368  * Function     : dump_font
 369  * Syntax       : void dump_font(font_t *fnt)
 370  * Input        :
 371  *      fnt     - Font resource descriptor
 372  * Output       : nop
 373  * Description  :
 374  * Remarks      :
 375  *****************************************************************************
 376 */
 377 void dump_font(font_t *fnt)
 378 {
 379         dump_memopt(fnt->memopt);
 380         dump_raw_data(fnt->data);
 381 }
 382
 383 /*
 384  *****************************************************************************
 385  * Function     : dump_bitmap
 386  * Syntax       : void dump_bitmap(bitmap_t *bmp)
 387  * Input        :
 388  *      bmp     - Bitmap resource descriptor
 389  * Output       : nop
 390  * Description  :
 391  * Remarks      :
 392  *****************************************************************************
 393 */
 394 void dump_bitmap(bitmap_t *bmp)
 395 {
 396         dump_memopt(bmp->memopt);
 397         dump_raw_data(bmp->data);
 398 }
 399
 400 /*
 401  *****************************************************************************
 402  * Function     : dump_rcdata
 403  * Syntax       : void dump_rcdata(rcdata_t *rdt)
 404  * Input        :
 405  *      rdt     - RCData resource descriptor
 406  * Output       : nop
 407  * Description  :
 408  * Remarks      :
 409  *****************************************************************************
 410 */
 411 void dump_rcdata(rcdata_t *rdt)
 412 {
 413         dump_memopt(rdt->memopt);
 414         dump_raw_data(rdt->data);
 415 }
 416
 417 /*
 418  *****************************************************************************
 419  * Function     : dump_user
 420  * Syntax       : void dump_user(user_t *usr)
 421  * Input        :
 422  *      usr     - User resource descriptor
 423  * Output       : nop
 424  * Description  :
 425  * Remarks      :
 426  *****************************************************************************
 427 */
 428 void dump_user(user_t *usr)
 429 {
 430         dump_memopt(usr->memopt);
 431         printf("Class %s\n", get_nameid_str(usr->type));
 432         dump_raw_data(usr->data);
 433 }
 434
 435 /*
 436  *****************************************************************************
 437  * Function     : dump_messagetable
 438  * Syntax       : void dump_messagetable(messagetable_t *msg)
 439  * Input        :
 440  *      msg     - Messagetable resource descriptor
 441  * Output       : nop
 442  * Description  :
 443  * Remarks      :
 444  *****************************************************************************
 445 */
 446 void dump_messagetable(messagetable_t *msg)
 447 {
 448         dump_raw_data(msg->data);
 449 }
 450
 451 /*
 452  *****************************************************************************
 453  * Function     : dump_stringtable
 454  * Syntax       : void dump_stringtable(stringtable_t *stt)
 455  * Input        :
 456  *      stt     - Stringtable resource descriptor
 457  * Output       : nop
 458  * Description  :
 459  * Remarks      :
 460  *****************************************************************************
 461 */
 462 void dump_stringtable(stringtable_t *stt)
 463 {
 464         int i;
 465         for(; stt; stt = stt->next)
 466         {
 467                 printf("{\n");
 468                 dump_memopt(stt->memopt);
 469                 dump_lvc(&(stt->lvc));
 470                 for(i = 0; i < stt->nentries; i++)
 471                 {
 472                         printf("Id=%-5d (%d) ", stt->idbase+i, stt->entries[i].id);
 473                         if(stt->entries[i].str)
 474                                 print_string(stt->entries[i].str);
 475                         else
 476                                 printf("<none>");
 477                         printf("\n");
 478                 }
 479                 printf("}\n");
 480         }
 481 }
 482
 483 /*
 484  *****************************************************************************
 485  * Function     : dump_control
 486  * Syntax       : void dump_control(control_t *ctrl)
 487  * Input        :
 488  *      ctrl    - Control resource descriptor
 489  * Output       :
 490  * Description  :
 491  * Remarks      :
 492  *****************************************************************************
 493 */
 494 void dump_control(control_t *ctrl)
 495 {
 496         printf("Control {\n\tClass: %s\n", get_nameid_str(ctrl->ctlclass));
 497         printf("\tText: "); get_nameid_str(ctrl->title); printf("\n");
 498         printf("\tId: %d\n", ctrl->id);
 499         printf("\tx, y, w, h: %d, %d, %d, %d\n", ctrl->x, ctrl->y, ctrl->width, ctrl->height);
 500         if(ctrl->gotstyle)
 501         {
 502                 assert(ctrl->style != NULL);
 503                 assert(ctrl->style->and_mask == 0);
 504                 printf("\tStyle: %08lx\n", ctrl->style->or_mask);
 505         }
 506         if(ctrl->gotexstyle)
 507         {
 508                 assert(ctrl->exstyle != NULL);
 509                 assert(ctrl->exstyle->and_mask == 0);
 510                 printf("\tExStyle: %08lx\n", ctrl->exstyle->or_mask);
 511         }
 512         if(ctrl->gothelpid)
 513                 printf("\tHelpid: %ld\n", ctrl->helpid);
 514         if(ctrl->extra)
 515         {
 516                 printf("\t");
 517                 dump_raw_data(ctrl->extra);
 518         }
 519         printf("}\n");
 520 }
 521
 522 /*
 523  *****************************************************************************
 524  * Function     : dump_dialog
 525  * Syntax       : void dump_dialog(dialog_t *dlg)
 526  * Input        :
 527  *      dlg     - Dialog resource descriptor
 528  * Output       :
 529  * Description  :
 530  * Remarks      :
 531  *****************************************************************************
 532 */
 533 void dump_dialog(dialog_t *dlg)
 534 {
 535         control_t *c = dlg->controls;
 536
 537         dump_memopt(dlg->memopt);
 538         dump_lvc(&(dlg->lvc));
 539         printf("x, y, w, h: %d, %d, %d, %d\n", dlg->x, dlg->y, dlg->width, dlg->height);
 540         if(dlg->gotstyle)
 541         {
 542                 assert(dlg->style != NULL);
 543                 assert(dlg->style->and_mask == 0);
 544                 printf("Style: %08lx\n", dlg->style->or_mask);
 545
 546         }
 547         if(dlg->gotexstyle)
 548         {
 549                 assert(dlg->exstyle != NULL);
 550                 assert(dlg->exstyle->and_mask == 0);
 551                 printf("ExStyle: %08lx\n", dlg->exstyle->or_mask);
 552         }
 553         printf("Menu: %s\n", get_nameid_str(dlg->menu));
 554         printf("Class: %s\n", get_nameid_str(dlg->dlgclass));
 555         printf("Title: "); print_string(dlg->title); printf("\n");
 556         printf("Font: ");
 557         if(!dlg->font)
 558                 printf("<none>\n");
 559         else
 560         {
 561                 printf("%d, ", dlg->font->size);
 562                 print_string(dlg->font->name);
 563                 printf("\n");
 564         }
 565         while(c)
 566         {
 567                 dump_control(c);
 568                 c = c->next;
 569         }
 570 }
 571
 572 /*
 573  *****************************************************************************
 574  * Function     : dump_dialogex
 575  * Syntax       : void dump_dialogex(dialogex_t *dlgex)
 576  * Input        :
 577  *      dlgex   - DialogEx resource descriptor
 578  * Output       :
 579  * Description  :
 580  * Remarks      :
 581  *****************************************************************************
 582 */
 583 void dump_dialogex(dialogex_t *dlgex)
 584 {
 585         control_t *c = dlgex->controls;
 586
 587         dump_memopt(dlgex->memopt);
 588         dump_lvc(&(dlgex->lvc));
 589         printf("x, y, w, h: %d, %d, %d, %d\n", dlgex->x, dlgex->y, dlgex->width, dlgex->height);
 590         if(dlgex->gotstyle)
 591         {
 592                 assert(dlgex->style != NULL);
 593                 assert(dlgex->style->and_mask == 0);
 594                 printf("Style: %08lx\n", dlgex->style->or_mask);
 595         }
 596         if(dlgex->gotexstyle)
 597         {
 598                 assert(dlgex->exstyle != NULL);
 599                 assert(dlgex->exstyle->and_mask == 0);
 600                 printf("ExStyle: %08lx\n", dlgex->exstyle->or_mask);
 601         }
 602         if(dlgex->gothelpid)
 603                 printf("Helpid: %ld\n", dlgex->helpid);
 604         printf("Menu: %s\n", get_nameid_str(dlgex->menu));
 605         printf("Class: %s\n", get_nameid_str(dlgex->dlgclass));
 606         printf("Title: "); print_string(dlgex->title); printf("\n");
 607         printf("Font: ");
 608         if(!dlgex->font)
 609                 printf("<none>\n");
 610         else
 611         {
 612                 printf("%d, ", dlgex->font->size);
 613                 print_string(dlgex->font->name);
 614                 printf(", %d, %d\n", dlgex->font->weight, dlgex->font->italic);
 615         }
 616         while(c)
 617         {
 618                 dump_control(c);
 619                 c = c->next;
 620         }
 621 }
 622
 623 /*
 624  *****************************************************************************
 625  * Function     : dump_menu_item
 626  * Syntax       : void dump_menu_item(menu_item_t *item)
 627  * Input        :
 628  * Output       :
 629  * Description  :
 630  * Remarks      :
 631  *****************************************************************************
 632 */
 633 void dump_menu_item(menu_item_t *item)
 634 {
 635         while(item)
 636         {
 637                 if(item->popup)
 638                 {
 639                         printf("POPUP ");
 640                         print_string(item->name);
 641                         printf("\n");
 642                         dump_menu_item(item->popup);
 643                 }
 644                 else
 645                 {
 646                         printf("MENUITEM ");
 647                         if(item->name)
 648                         {
 649                                 print_string(item->name);
 650                                 printf(", %d, %08lx", item->id, item->state);
 651                         }
 652                         else
 653                                 printf("SEPARATOR");
 654                         printf("\n");
 655                 }
 656                 item = item->next;
 657         }
 658 }
 659
 660 /*
 661  *****************************************************************************
 662  * Function     : dump_menu
 663  * Syntax       : void dump_menu(menu_t *men)
 664  * Input        :
 665  *      men     - Menu resource descriptor
 666  * Output       :
 667  * Description  :
 668  * Remarks      :
 669  *****************************************************************************
 670 */
 671 void dump_menu(menu_t *men)
 672 {
 673         dump_memopt(men->memopt);
 674         dump_lvc(&(men->lvc));
 675         dump_menu_item(men->items);
 676 }
 677
 678 /*
 679  *****************************************************************************
 680  * Function     : dump_menuex_item
 681  * Syntax       : void dump_menuex_item(menuex_item_t *item)
 682  * Input        :
 683  * Output       :
 684  * Description  :
 685  * Remarks      :
 686  *****************************************************************************
 687 */
 688 void dump_menuex_item(menuex_item_t *item)
 689 {
 690         while(item)
 691         {
 692                 if(item->popup)
 693                 {
 694                         printf("POPUP ");
 695                         print_string(item->name);
 696                         if(item->gotid)
 697                                 printf(", Id=%d", item->id);
 698                         if(item->gottype)
 699                                 printf(", Type=%ld", item->type);
 700                         if(item->gotstate)
 701                                 printf(", State=%08lx", item->state);
 702                         if(item->gothelpid)
 703                                 printf(", HelpId=%d", item->helpid);
 704                         printf("\n");
 705                         dump_menuex_item(item->popup);
 706                 }
 707                 else
 708                 {
 709                         printf("MENUITEM ");
 710                         if(item->name)
 711                         {
 712                                 print_string(item->name);
 713                                 if(item->gotid)
 714                                         printf(", Id=%d", item->id);
 715                                 if(item->gottype)
 716                                         printf(", Type=%ld", item->type);
 717                                 if(item->gotstate)
 718                                         printf(", State=%08lx", item->state);
 719                                 if(item->gothelpid)
 720                                         printf(", HelpId=%d", item->helpid);
 721                         }
 722                         else
 723                                 printf("SEPARATOR");
 724                         printf("\n");
 725                 }
 726                 item = item->next;
 727         }
 728 }
 729
 730 /*
 731  *****************************************************************************
 732  * Function     : dump_menuex
 733  * Syntax       : void dump_menuex(dialogex_t *menex)
 734  * Input        :
 735  *      menex   - MenuEx resource descriptor
 736  * Output       :
 737  * Description  :
 738  * Remarks      :
 739  *****************************************************************************
 740 */
 741 void dump_menuex(menuex_t *menex)
 742 {
 743         dump_memopt(menex->memopt);
 744         dump_lvc(&(menex->lvc));
 745         dump_menuex_item(menex->items);
 746 }
 747
 748 /*
 749  *****************************************************************************
 750  * Function     : dump_ver_value
 751  * Syntax       : void dump_ver_value(ver_value_t *val)
 752  * Input        :
 753  * Output       :
 754  * Description  :
 755  * Remarks      :
 756  *****************************************************************************
 757 */
 758 void dump_ver_value(ver_value_t *val)
 759 {
 760         extern void dump_ver_block(ver_block_t *);
 761         if(val->type == val_str)
 762         {
 763                 printf("VALUE ");
 764                 print_string(val->key);
 765                 printf(" ");
 766                 print_string(val->value.str);
 767                 printf("\n");
 768         }
 769         else if(val->type == val_words)
 770         {
 771                 int i;
 772                 printf("VALUE");
 773                 print_string(val->key);
 774                 for(i = 0; i < val->value.words->nwords; i++)
 775                         printf(" %04x", val->value.words->words[i]);
 776                 printf("\n");
 777         }
 778         else if(val->type == val_block)
 779         {
 780                 dump_ver_block(val->value.block);
 781         }
 782 }
 783
 784 /*
 785  *****************************************************************************
 786  * Function     : dump_ver_block
 787  * Syntax       : void dump_ver_block(ver_block_t *blk)
 788  * Input        :
 789  * Output       :
 790  * Description  :
 791  * Remarks      :
 792  *****************************************************************************
 793 */
 794 void dump_ver_block(ver_block_t *blk)
 795 {
 796         ver_value_t *val = blk->values;
 797         printf("BLOCK ");
 798         print_string(blk->name);
 799         printf("\n{\n");
 800         while(val)
 801         {
 802                 dump_ver_value(val);
 803                 val = val->next;
 804         }
 805         printf("}\n");
 806 }
 807
 808 /*
 809  *****************************************************************************
 810  * Function     : dump_versioninfo
 811  * Syntax       : void dump_versioninfo(versioninfo_t *ver)
 812  * Input        :
 813  *      ver     - Versioninfo resource descriptor
 814  * Output       :
 815  * Description  :
 816  * Remarks      :
 817  *****************************************************************************
 818 */
 819 void dump_versioninfo(versioninfo_t *ver)
 820 {
 821         ver_block_t *blk = ver->blocks;
 822
 823         if(ver->gotit.fv)
 824                 printf("FILEVERSION %04x, %04x, %04x, %04x\n",
 825                         ver->filever_maj1,
 826                         ver->filever_maj2,
 827                         ver->filever_min1,
 828                         ver->filever_min2);
 829         if(ver->gotit.pv)
 830                 printf("PRODUCTVERSION %04x, %04x, %04x, %04x\n",
 831                         ver->prodver_maj1,
 832                         ver->prodver_maj2,
 833                         ver->prodver_min1,
 834                         ver->prodver_min2);
 835         if(ver->gotit.fo)
 836                 printf("FILEOS %08x\n", ver->fileos);
 837         if(ver->gotit.ff)
 838                 printf("FILEFLAGS %08x\n", ver->fileflags);
 839         if(ver->gotit.ffm)
 840                 printf("FILEFLAGSMASK %08x\n", ver->fileflagsmask);
 841         if(ver->gotit.ft)
 842                 printf("FILETYPE %08x\n", ver->filetype);
 843         if(ver->gotit.fst)
 844                 printf("FILESUBTYPE %08x\n", ver->filesubtype);
 845         while(blk)
 846         {
 847                 dump_ver_block(blk);
 848                 blk = blk->next;
 849         }
 850 }
 851
 852 /*
 853  *****************************************************************************
 854  * Function     : dump_toolbar_item
 855  * Syntax       : void dump_toolbar_item(toolbar_item_t *item)
 856  * Input        :
 857  * Output       :
 858  * Description  :
 859  * Remarks      :
 860  *****************************************************************************
 861 */
 862 void dump_toolbar_items(toolbar_item_t *items)
 863 {
 864         while(items)
 865         {
 866                 if(items->id)
 867                         printf("   BUTTON %d", items->id );
 868                 else
 869                         printf("   SEPARATOR");
 870
 871                 printf("\n");
 872
 873                 items = items->next;
 874         }
 875 }
 876
 877 /*
 878  *****************************************************************************
 879  * Function     : dump_toolbar
 880  * Syntax       : void dump_toolbar(toolbar_t *toolbar)
 881  * Input        :
 882  *      toolbar - Toolbar resource descriptor
 883  * Output       :
 884  * Description  :
 885  * Remarks      :
 886  *****************************************************************************
 887 */
 888 void dump_toolbar(toolbar_t *toolbar)
 889 {
 890         dump_memopt(toolbar->memopt);
 891         dump_lvc(&(toolbar->lvc));
 892         dump_toolbar_items(toolbar->items);
 893 }
 894
 895 /*
 896  *****************************************************************************
 897  * Function     : dump_dlginit
 898  * Syntax       : void dump_dlginit(dlginit_t *dit)
 899  * Input        :
 900  *      dit     - DlgInit resource descriptor
 901  * Output       :
 902  * Description  :
 903  * Remarks      :
 904  *****************************************************************************
 905 */
 906 void dump_dlginit(dlginit_t *dit)
 907 {
 908         dump_memopt(dit->memopt);
 909         dump_lvc(&(dit->lvc));
 910         dump_raw_data(dit->data);
 911 }
 912
 913 /*
 914  *****************************************************************************
 915  * Function     :
 916  * Syntax       :
 917  * Input        :
 918  * Output       :
 919  * Description  :
 920  * Remarks      :
 921  *****************************************************************************
 922 */
 923 /*
 924  *****************************************************************************
 925  * Function     : dump_resources
 926  * Syntax       : void dump_resources(resource_t *top)
 927  * Input        :
 928  *      top     - Top of the resource tree
 929  * Output       :
 930  *      nop
 931  * Description  : Dump the parsed resource-tree to stdout
 932  * Remarks      :
 933  *****************************************************************************
 934 */
 935 void dump_resources(resource_t *top)
 936 {
 937         printf("Internal resource-tree dump:\n");
 938         while(top)
 939         {
 940                 printf("Resource: %s\nId: %s\n",
 941                        get_typename(top),
 942                        get_nameid_str(top->name));
 943                 switch(top->type)
 944                 {
 945                 case res_acc:
 946                         dump_accelerator(top->res.acc);
 947                         break;
 948                 case res_bmp:
 949                         dump_bitmap(top->res.bmp);
 950                         break;
 951                 case res_cur:
 952                         dump_cursor(top->res.cur);
 953                         break;
 954                 case res_curg:
 955                         dump_cursor_group(top->res.curg);
 956                         break;
 957                 case res_dlg:
 958                         dump_dialog(top->res.dlg);
 959                         break;
 960                 case res_dlgex:
 961                         dump_dialogex(top->res.dlgex);
 962                         break;
 963                 case res_fnt:
 964                         dump_font(top->res.fnt);
 965                         break;
 966                 case res_icog:
 967                         dump_icon_group(top->res.icog);
 968                         break;
 969                 case res_ico:
 970                         dump_icon(top->res.ico);
 971                         break;
 972                 case res_men:
 973                         dump_menu(top->res.men);
 974                         break;
 975                 case res_menex:
 976                         dump_menuex(top->res.menex);
 977                         break;
 978                 case res_rdt:
 979                         dump_rcdata(top->res.rdt);
 980                         break;
 981                 case res_stt:
 982                         dump_stringtable(top->res.stt);
 983                         break;
 984                 case res_usr:
 985                         dump_user(top->res.usr);
 986                         break;
 987                 case res_msg:
 988                         dump_messagetable(top->res.msg);
 989                         break;
 990                 case res_ver:
 991                         dump_versioninfo(top->res.ver);
 992                         break;
 993                 case res_dlginit:
 994                         dump_dlginit(top->res.dlgi);
 995                         break;
 996                 case res_toolbar:
 997                         dump_toolbar(top->res.tbt);
 998                         break;
 999                 default:
1000                         printf("Report this: Unknown resource type parsed %08x\n", top->type);
1001                 }
1002                 printf("\n");
1003                 top = top->next;
1004         }
1005 }
1006