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