tools/wrc/genres.c

   1 /*
   2  * Generate .res format from a resource-tree
   3  *
   4  * Copyright 1998 Bertho A. Stultiens
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * History:
  21  * 05-May-2000 BS       - Added code to support endian conversions. The
  22  *                        extra functions also aid unaligned access, but
  23  *                        this is not yet implemented.
  24  * 25-May-1998 BS       - Added simple unicode -> char conversion for resource
  25  *                        names in .s and .h files.
  26  */
  27
  28 #include "config.h"
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <stdarg.h>
  34 #include <assert.h>
  35 #include <ctype.h>
  36
  37 #include "wrc.h"
  38 #include "genres.h"
  39 #include "utils.h"
  40 #include "windef.h"
  41 #include "winbase.h"
  42 #include "wingdi.h"
  43 #include "winuser.h"
  44 #include "wine/unicode.h"
  45
  46 #define SetResSize(res, tag)    set_dword((res), (tag), (res)->size - get_dword((res), (tag)))
  47
  48 res_t *new_res(void)
  49 {
  50         res_t *r;
  51         r = xmalloc(sizeof(res_t));
  52         r->allocsize = RES_BLOCKSIZE;
  53         r->size = 0;
  54         r->dataidx = 0;
  55         r->data = xmalloc(RES_BLOCKSIZE);
  56         return r;
  57 }
  58
  59 res_t *grow_res(res_t *r, unsigned int add)
  60 {
  61         r->allocsize += add;
  62         r->data = xrealloc(r->data, r->allocsize);
  63         return r;
  64 }
  65
  66 /*
  67  *****************************************************************************
  68  * Function     : put_byte
  69  *                put_word
  70  *                put_dword
  71  * Syntax       : void put_byte(res_t *res, unsigned c)
  72  *                void put_word(res_t *res, unsigned w)
  73  *                void put_dword(res_t *res, unsigned d)
  74  * Input        :
  75  *      res     - Binary resource to put the data in
  76  *      c, w, d - Data to put
  77  * Output       : nop
  78  * Description  : Put primitives that put an item in the binary resource.
  79  *                The data array grows automatically.
  80  * Remarks      :
  81  *****************************************************************************
  82 */
  83 void put_byte(res_t *res, unsigned c)
  84 {
  85         if(res->allocsize - res->size < sizeof(char))
  86                 grow_res(res, RES_BLOCKSIZE);
  87         res->data[res->size] = (char)c;
  88         res->size += sizeof(char);
  89 }
  90
  91 void put_word(res_t *res, unsigned w)
  92 {
  93         if(res->allocsize - res->size < sizeof(WORD))
  94                 grow_res(res, RES_BLOCKSIZE);
  95         switch(byteorder)
  96         {
  97 #ifdef WORDS_BIGENDIAN
  98         default:
  99 #endif
 100         case WRC_BO_BIG:
 101                 res->data[res->size+0] = HIBYTE(w);
 102                 res->data[res->size+1] = LOBYTE(w);
 103                 break;
 104
 105 #ifndef WORDS_BIGENDIAN
 106         default:
 107 #endif
 108         case WRC_BO_LITTLE:
 109                 res->data[res->size+1] = HIBYTE(w);
 110                 res->data[res->size+0] = LOBYTE(w);
 111                 break;
 112         }
 113         res->size += sizeof(WORD);
 114 }
 115
 116 void put_dword(res_t *res, unsigned d)
 117 {
 118         if(res->allocsize - res->size < sizeof(DWORD))
 119                 grow_res(res, RES_BLOCKSIZE);
 120         switch(byteorder)
 121         {
 122 #ifdef WORDS_BIGENDIAN
 123         default:
 124 #endif
 125         case WRC_BO_BIG:
 126                 res->data[res->size+0] = HIBYTE(HIWORD(d));
 127                 res->data[res->size+1] = LOBYTE(HIWORD(d));
 128                 res->data[res->size+2] = HIBYTE(LOWORD(d));
 129                 res->data[res->size+3] = LOBYTE(LOWORD(d));
 130                 break;
 131
 132 #ifndef WORDS_BIGENDIAN
 133         default:
 134 #endif
 135         case WRC_BO_LITTLE:
 136                 res->data[res->size+3] = HIBYTE(HIWORD(d));
 137                 res->data[res->size+2] = LOBYTE(HIWORD(d));
 138                 res->data[res->size+1] = HIBYTE(LOWORD(d));
 139                 res->data[res->size+0] = LOBYTE(LOWORD(d));
 140                 break;
 141         }
 142         res->size += sizeof(DWORD);
 143 }
 144
 145 static void put_pad(res_t *res)
 146 {
 147         while(res->size & 0x3)
 148                 put_byte(res, 0);
 149 }
 150
 151 /*
 152  *****************************************************************************
 153  * Function     : set_word
 154  *                set_dword
 155  * Syntax       : void set_word(res_t *res, int ofs, unsigned w)
 156  *                void set_dword(res_t *res, int ofs, unsigned d)
 157  * Input        :
 158  *      res     - Binary resource to put the data in
 159  *      ofs     - Byte offset in data-array
 160  *      w, d    - Data to put
 161  * Output       : nop
 162  * Description  : Set the value of a binary resource data array to a
 163  *                specific value.
 164  * Remarks      :
 165  *****************************************************************************
 166 */
 167 static void set_word(res_t *res, int ofs, unsigned w)
 168 {
 169         switch(byteorder)
 170         {
 171 #ifdef WORDS_BIGENDIAN
 172         default:
 173 #endif
 174         case WRC_BO_BIG:
 175                 res->data[ofs+0] = HIBYTE(w);
 176                 res->data[ofs+1] = LOBYTE(w);
 177                 break;
 178
 179 #ifndef WORDS_BIGENDIAN
 180         default:
 181 #endif
 182         case WRC_BO_LITTLE:
 183                 res->data[ofs+1] = HIBYTE(w);
 184                 res->data[ofs+0] = LOBYTE(w);
 185                 break;
 186         }
 187 }
 188
 189 static void set_dword(res_t *res, int ofs, unsigned d)
 190 {
 191         switch(byteorder)
 192         {
 193 #ifdef WORDS_BIGENDIAN
 194         default:
 195 #endif
 196         case WRC_BO_BIG:
 197                 res->data[ofs+0] = HIBYTE(HIWORD(d));
 198                 res->data[ofs+1] = LOBYTE(HIWORD(d));
 199                 res->data[ofs+2] = HIBYTE(LOWORD(d));
 200                 res->data[ofs+3] = LOBYTE(LOWORD(d));
 201                 break;
 202
 203 #ifndef WORDS_BIGENDIAN
 204         default:
 205 #endif
 206         case WRC_BO_LITTLE:
 207                 res->data[ofs+3] = HIBYTE(HIWORD(d));
 208                 res->data[ofs+2] = LOBYTE(HIWORD(d));
 209                 res->data[ofs+1] = HIBYTE(LOWORD(d));
 210                 res->data[ofs+0] = LOBYTE(LOWORD(d));
 211                 break;
 212         }
 213 }
 214
 215 /*
 216  *****************************************************************************
 217  * Function     : get_dword
 218  * Input        :
 219  *      res     - Binary resource to put the data in
 220  *      ofs     - Byte offset in data-array
 221  * Output       : The data in native endian
 222  * Description  : Get the value of a binary resource data array in native
 223  *                endian.
 224  * Remarks      :
 225  *****************************************************************************
 226 */
 227 static DWORD get_dword(res_t *res, int ofs)
 228 {
 229         switch(byteorder)
 230         {
 231 #ifdef WORDS_BIGENDIAN
 232         default:
 233 #endif
 234         case WRC_BO_BIG:
 235                 return   (res->data[ofs+0] << 24)
 236                        | (res->data[ofs+1] << 16)
 237                        | (res->data[ofs+2] <<  8)
 238                        |  res->data[ofs+3];
 239
 240 #ifndef WORDS_BIGENDIAN
 241         default:
 242 #endif
 243         case WRC_BO_LITTLE:
 244                 return   (res->data[ofs+3] << 24)
 245                        | (res->data[ofs+2] << 16)
 246                        | (res->data[ofs+1] <<  8)
 247                        |  res->data[ofs+0];
 248         }
 249 }
 250
 251 /*
 252  *****************************************************************************
 253  * Function     : string_to_upper
 254  * Syntax       : void string_to_upper(string_t *str)
 255  * Input        :
 256  * Output       :
 257  * Description  :
 258  * Remarks      : FIXME: codepages...
 259  *****************************************************************************
 260 */
 261 static void string_to_upper(string_t *str)
 262 {
 263     int i;
 264
 265     if(str->type == str_char)
 266     {
 267         for (i = 0; i < str->size; i++) str->str.cstr[i] = toupper((unsigned char)str->str.cstr[i]);
 268     }
 269     else if(str->type == str_unicode)
 270     {
 271         for (i = 0; i < str->size; i++) str->str.wstr[i] = toupperW(str->str.wstr[i]);
 272     }
 273     else
 274     {
 275         internal_error(__FILE__, __LINE__, "Invalid string type %d\n", str->type);
 276     }
 277 }
 278
 279 /*
 280  *****************************************************************************
 281  * Function     : put_string
 282  * Syntax       : void put_string(res_t *res, string_t *str, enum str_e type,
 283  *                                int isterm, const language_t *lang)
 284  * Input        :
 285  *      res     - Binary resource to put the data in
 286  *      str     - String to put
 287  *      type    - Data has to be written in either str_char or str_unicode
 288  *      isterm  - The string is '\0' terminated (disregard the string's
 289  *                size member)
 290  * Output       : nop
 291  * Description  :
 292  * Remarks      :
 293  *****************************************************************************
 294 */
 295 static void put_string(res_t *res, const string_t *str, enum str_e type, int isterm,
 296                        const language_t *lang)
 297 {
 298     int cnt, codepage;
 299     string_t *newstr;
 300
 301     assert(res != NULL);
 302     assert(str != NULL);
 303
 304     if (lang) codepage = get_language_codepage( lang->id, lang->sub );
 305     else codepage = get_language_codepage( 0, 0 );
 306
 307     assert( codepage != -1 );
 308
 309     newstr = convert_string(str, type, codepage);
 310     if (type == str_unicode)
 311     {
 312         if (str->type == str_char)
 313         {
 314             if (!check_unicode_conversion( str, newstr, codepage ))
 315                 error( "String %s does not convert identically to Unicode and back in codepage %d. "
 316                        "Try using a Unicode string instead\n", str->str.cstr, codepage );
 317             if (check_valid_utf8( str, codepage ))
 318                 warning( "string \"%s\" seems to be UTF-8 but codepage %u is in use.\n",
 319                          str->str.cstr, codepage );
 320         }
 321         if (!isterm) put_word(res, newstr->size);
 322         for(cnt = 0; cnt < newstr->size; cnt++)
 323         {
 324             WCHAR c = newstr->str.wstr[cnt];
 325             if (isterm && !c) break;
 326             put_word(res, c);
 327         }
 328         if (isterm) put_word(res, 0);
 329     }
 330     else  /* str_char */
 331     {
 332         if (!isterm) put_byte(res, newstr->size);
 333         for(cnt = 0; cnt < newstr->size; cnt++)
 334         {
 335             char c = newstr->str.cstr[cnt];
 336             if (isterm && !c) break;
 337             put_byte(res, c);
 338         }
 339         if (isterm) put_byte(res, 0);
 340     }
 341     free_string(newstr);
 342 }
 343
 344 /*
 345  *****************************************************************************
 346  * Function     : put_name_id
 347  * Syntax       : void put_name_id(res_t *res, name_id_t *nid, int upcase, const language_t *lang)
 348  * Input        :
 349  * Output       :
 350  * Description  :
 351  * Remarks      :
 352  *****************************************************************************
 353 */
 354 static void put_name_id(res_t *res, name_id_t *nid, int upcase, const language_t *lang)
 355 {
 356         if(nid->type == name_ord)
 357         {
 358                 if(win32)
 359                         put_word(res, 0xffff);
 360                 else
 361                         put_byte(res, 0xff);
 362                 put_word(res, (WORD)nid->name.i_name);
 363         }
 364         else if(nid->type == name_str)
 365         {
 366                 if(upcase)
 367                         string_to_upper(nid->name.s_name);
 368                 put_string(res, nid->name.s_name, win32 ? str_unicode : str_char, TRUE, lang);
 369         }
 370         else
 371         {
 372                 internal_error(__FILE__, __LINE__, "Invalid name_id type %d\n", nid->type);
 373         }
 374 }
 375
 376 /*
 377  *****************************************************************************
 378  * Function     : put_lvc
 379  * Syntax       : void put_lvc(res_t *res, lvc_t *lvc)
 380  * Input        :
 381  * Output       :
 382  * Description  :
 383  * Remarks      :
 384  *****************************************************************************
 385 */
 386 static void put_lvc(res_t *res, lvc_t *lvc)
 387 {
 388         if(lvc && lvc->language)
 389                 put_word(res, MAKELANGID(lvc->language->id, lvc->language->sub));
 390         else
 391                 put_word(res, 0);       /* Neutral */
 392         if(lvc && lvc->version)
 393                 put_dword(res, *(lvc->version));
 394         else
 395                 put_dword(res, 0);
 396         if(lvc && lvc->characts)
 397                 put_dword(res, *(lvc->characts));
 398         else
 399                 put_dword(res, 0);
 400 }
 401
 402 /*
 403  *****************************************************************************
 404  * Function     : put_raw_data
 405  * Syntax       : void put_raw_data(res_t *res, raw_data_t *raw, int offset)
 406  * Input        :
 407  * Output       :
 408  * Description  :
 409  * Remarks      :
 410  *****************************************************************************
 411 */
 412 static void put_raw_data(res_t *res, raw_data_t *raw, int offset)
 413 {
 414         unsigned int wsize = raw->size - offset;
 415         if(res->allocsize - res->size < wsize)
 416                 grow_res(res, wsize);
 417         memcpy(&(res->data[res->size]), raw->data + offset, wsize);
 418         res->size += wsize;
 419 }
 420
 421 /*
 422  *****************************************************************************
 423  * Function     : put_res_header
 424  * Syntax       : input_res_header(res_t *res, int type, name_id_t *ntype,
 425  *                                  name_id_t *name, DWORD memopt, lvc_t *lvc)
 426  *
 427  * Input        :
 428  *      res     - Binary resource descriptor to write to
 429  *      type    - Resource identifier (if ntype == NULL)
 430  *      ntype   - Name id of type
 431  *      name    - Resource's name
 432  *      memopt  - Resource's memory options to write
 433  *      lvc     - Language, version and characteristics (win32 only)
 434  * Output       : An index to the resource size field. The resource size field
 435  *                contains the header size upon exit.
 436  * Description  :
 437  * Remarks      :
 438  *****************************************************************************
 439 */
 440 static int put_res_header(res_t *res, int type, name_id_t *ntype, name_id_t *name,
 441                           DWORD memopt, lvc_t *lvc)
 442 {
 443         if(win32)
 444         {
 445                 put_dword(res, 0);              /* We will overwrite these later */
 446                 put_dword(res, 0);
 447                 if(!ntype)
 448                 {
 449                         put_word(res, 0xffff);          /* ResType */
 450                         put_word(res, type);
 451                 }
 452                 else
 453                         put_name_id(res, ntype, TRUE, lvc->language);
 454                 put_name_id(res, name, TRUE, lvc->language); /* ResName */
 455                 put_pad(res);
 456                 put_dword(res, 0);              /* DataVersion */
 457                 put_word(res, memopt);          /* Memory options */
 458                 put_lvc(res, lvc);              /* Language, version and characts */
 459                 set_dword(res, 0*sizeof(DWORD), res->size);     /* Set preliminary resource */
 460                 set_dword(res, 1*sizeof(DWORD), res->size);     /* Set HeaderSize */
 461                 res->dataidx = res->size;
 462                 return 0;
 463         }
 464         else /* win16 */
 465         {
 466                 int tag;
 467                 if(!ntype)
 468                 {
 469                         put_byte(res, 0xff);            /* ResType */
 470                         put_word(res, type);
 471                 }
 472                 else
 473                         put_name_id(res, ntype, TRUE, NULL);
 474                 put_name_id(res, name, TRUE, NULL); /* ResName */
 475                 put_word(res, memopt);          /* Memory options */
 476                 tag = res->size;
 477                 put_dword(res, 0);              /* ResSize overwritten later*/
 478                 set_dword(res, tag, res->size);
 479                 res->dataidx = res->size;
 480                 return tag;
 481         }
 482 }
 483
 484 /*
 485  *****************************************************************************
 486  * Function     : accelerator2res
 487  * Syntax       : res_t *accelerator2res(name_id_t *name, accelerator_t *acc)
 488  * Input        :
 489  *      name    - Name/ordinal of the resource
 490  *      acc     - The accelerator descriptor
 491  * Output       : New .res format structure
 492  * Description  :
 493  * Remarks      :
 494  *****************************************************************************
 495 */
 496 static res_t *accelerator2res(name_id_t *name, accelerator_t *acc)
 497 {
 498         int restag;
 499         res_t *res;
 500         event_t *ev;
 501         assert(name != NULL);
 502         assert(acc != NULL);
 503
 504         ev = acc->events;
 505         res = new_res();
 506         if(win32)
 507         {
 508                 restag = put_res_header(res, WRC_RT_ACCELERATOR, NULL, name, acc->memopt, &(acc->lvc));
 509                 while(ev)
 510                 {
 511                         put_word(res, ev->flags | (ev->next ? 0 : 0x80));
 512                         put_word(res, ev->key);
 513                         put_word(res, ev->id);
 514                         put_word(res, 0);       /* Padding */
 515                         ev = ev->next;
 516                 }
 517                 put_pad(res);
 518         }
 519         else /* win16 */
 520         {
 521                 restag = put_res_header(res, WRC_RT_ACCELERATOR, NULL, name, acc->memopt, NULL);
 522                 while(ev)
 523                 {
 524                         put_byte(res, ev->flags | (ev->next ? 0 : 0x80));
 525                         put_word(res, ev->key);
 526                         put_word(res, ev->id);
 527                         ev = ev->next;
 528                 }
 529         }
 530         /* Set ResourceSize */
 531         SetResSize(res, restag);
 532         return res;
 533 }
 534
 535 /*
 536  *****************************************************************************
 537  * Function     : dialog2res
 538  * Syntax       : res_t *dialog2res(name_id_t *name, dialog_t *dlg)
 539  * Input        :
 540  *      name    - Name/ordinal of the resource
 541  *      dlg     - The dialog descriptor
 542  * Output       : New .res format structure
 543  * Description  :
 544  * Remarks      :
 545  *****************************************************************************
 546 */
 547 static res_t *dialog2res(name_id_t *name, dialog_t *dlg)
 548 {
 549         int restag;
 550         res_t *res;
 551         control_t *ctrl;
 552         int tag_nctrl;
 553         int nctrl = 0;
 554         assert(name != NULL);
 555         assert(dlg != NULL);
 556
 557         ctrl = dlg->controls;
 558         res = new_res();
 559         if(win32)
 560         {
 561                 restag = put_res_header(res, WRC_RT_DIALOG, NULL, name, dlg->memopt, &(dlg->lvc));
 562
 563                 put_dword(res, dlg->style->or_mask);
 564                 put_dword(res, dlg->gotexstyle ? dlg->exstyle->or_mask : 0);
 565                 tag_nctrl = res->size;
 566                 put_word(res, 0);               /* Number of controls */
 567                 put_word(res, dlg->x);
 568                 put_word(res, dlg->y);
 569                 put_word(res, dlg->width);
 570                 put_word(res, dlg->height);
 571                 if(dlg->menu)
 572                         put_name_id(res, dlg->menu, TRUE, dlg->lvc.language);
 573                 else
 574                         put_word(res, 0);
 575                 if(dlg->dlgclass)
 576                         put_name_id(res, dlg->dlgclass, TRUE, dlg->lvc.language);
 577                 else
 578                         put_word(res, 0);
 579                 if(dlg->title)
 580                         put_string(res, dlg->title, str_unicode, TRUE, dlg->lvc.language);
 581                 else
 582                         put_word(res, 0);
 583                 if(dlg->font)
 584                 {
 585                         put_word(res, dlg->font->size);
 586                         put_string(res, dlg->font->name, str_unicode, TRUE, dlg->lvc.language);
 587                 }
 588
 589                 put_pad(res);
 590                 while(ctrl)
 591                 {
 592                         /* FIXME: what is default control style? */
 593                         put_dword(res, ctrl->gotstyle ? ctrl->style->or_mask: WS_CHILD);
 594                         put_dword(res, ctrl->gotexstyle ? ctrl->exstyle->or_mask : 0);
 595                         put_word(res, ctrl->x);
 596                         put_word(res, ctrl->y);
 597                         put_word(res, ctrl->width);
 598                         put_word(res, ctrl->height);
 599                         put_word(res, ctrl->id);
 600                         if(ctrl->ctlclass)
 601                                 put_name_id(res, ctrl->ctlclass, TRUE, dlg->lvc.language);
 602                         else
 603                                 internal_error(__FILE__, __LINE__, "Control has no control-class\n");
 604                         if(ctrl->title)
 605                                 put_name_id(res, ctrl->title, FALSE, dlg->lvc.language);
 606                         else
 607                                 put_word(res, 0);
 608                         if(ctrl->extra)
 609                         {
 610                                 put_word(res, ctrl->extra->size+2);
 611                                 put_pad(res);
 612                                 put_raw_data(res, ctrl->extra, 0);
 613                         }
 614                         else
 615                                 put_word(res, 0);
 616
 617                         if(ctrl->next)
 618                                 put_pad(res);
 619                         nctrl++;
 620                         ctrl = ctrl->next;
 621                 }
 622                 /* Set number of controls */
 623                 set_word(res, tag_nctrl, (WORD)nctrl);
 624         }
 625         else /* win16 */
 626         {
 627                 restag = put_res_header(res, WRC_RT_DIALOG, NULL, name, dlg->memopt, NULL);
 628
 629                 put_dword(res, dlg->gotstyle ? dlg->style->or_mask : WS_POPUPWINDOW);
 630                 tag_nctrl = res->size;
 631                 put_byte(res, 0);               /* Number of controls */
 632                 put_word(res, dlg->x);
 633                 put_word(res, dlg->y);
 634                 put_word(res, dlg->width);
 635                 put_word(res, dlg->height);
 636                 if(dlg->menu)
 637                         put_name_id(res, dlg->menu, TRUE, NULL);
 638                 else
 639                         put_byte(res, 0);
 640                 if(dlg->dlgclass)
 641                         put_name_id(res, dlg->dlgclass, TRUE, NULL);
 642                 else
 643                         put_byte(res, 0);
 644                 if(dlg->title)
 645                         put_string(res, dlg->title, str_char, TRUE, NULL);
 646                 else
 647                         put_byte(res, 0);
 648                 if(dlg->font)
 649                 {
 650                         put_word(res, dlg->font->size);
 651                         put_string(res, dlg->font->name, str_char, TRUE, NULL);
 652                 }
 653
 654                 while(ctrl)
 655                 {
 656                         put_word(res, ctrl->x);
 657                         put_word(res, ctrl->y);
 658                         put_word(res, ctrl->width);
 659                         put_word(res, ctrl->height);
 660                         put_word(res, ctrl->id);
 661                         put_dword(res, ctrl->gotstyle ? ctrl->style->or_mask: WS_CHILD);
 662                         if(ctrl->ctlclass)
 663                         {
 664                                 if(ctrl->ctlclass->type == name_ord
 665                                 && ctrl->ctlclass->name.i_name >= 0x80
 666                                 && ctrl->ctlclass->name.i_name <= 0x85)
 667                                         put_byte(res, ctrl->ctlclass->name.i_name);
 668                                 else if(ctrl->ctlclass->type == name_str)
 669                                         put_name_id(res, ctrl->ctlclass, FALSE, NULL);
 670                                 else
 671                                         error("Unknown control-class %04x\n", ctrl->ctlclass->name.i_name);
 672                         }
 673                         else
 674                                 internal_error(__FILE__, __LINE__, "Control has no control-class\n");
 675                         if(ctrl->title)
 676                                 put_name_id(res, ctrl->title, FALSE, NULL);
 677                         else
 678                                 put_byte(res, 0);
 679
 680                         /* FIXME: What is this extra byte doing here? */
 681                         put_byte(res, 0);
 682
 683                         nctrl++;
 684                         ctrl = ctrl->next;
 685                 }
 686                 /* Set number of controls */
 687                 ((char *)res->data)[tag_nctrl] = (char)nctrl;
 688         }
 689         /* Set ResourceSize */
 690         SetResSize(res, restag);
 691         return res;
 692 }
 693
 694 /*
 695  *****************************************************************************
 696  * Function     : dialogex2res
 697  * Syntax       : res_t *dialogex2res(name_id_t *name, dialogex_t *dlgex)
 698  * Input        :
 699  *      name    - Name/ordinal of the resource
 700  *      dlgex   - The dialogex descriptor
 701  * Output       : New .res format structure
 702  * Description  :
 703  * Remarks      :
 704  *****************************************************************************
 705 */
 706 static res_t *dialogex2res(name_id_t *name, dialogex_t *dlgex)
 707 {
 708         int restag;
 709         res_t *res;
 710         control_t *ctrl;
 711         int tag_nctrl;
 712         int nctrl = 0;
 713         assert(name != NULL);
 714         assert(dlgex != NULL);
 715
 716         ctrl = dlgex->controls;
 717         res = new_res();
 718         if(win32)
 719         {
 720                 restag = put_res_header(res, WRC_RT_DIALOG, NULL, name, dlgex->memopt, &(dlgex->lvc));
 721
 722                 /* FIXME: MS doc says that the first word must contain 0xffff
 723                  * and the second 0x0001 to signal a DLGTEMPLATEEX. Borland's
 724                  * compiler reverses the two words.
 725                  * I don't know which one to choose, but I write it as Mr. B
 726                  * writes it.
 727                  */
 728                 put_word(res, 1);               /* Signature */
 729                 put_word(res, 0xffff);          /* DlgVer */
 730                 put_dword(res, dlgex->gothelpid ? dlgex->helpid : 0);
 731                 put_dword(res, dlgex->gotexstyle ? dlgex->exstyle->or_mask : 0);
 732                 put_dword(res, dlgex->gotstyle ? dlgex->style->or_mask : WS_POPUPWINDOW);
 733                 tag_nctrl = res->size;
 734                 put_word(res, 0);               /* Number of controls */
 735                 put_word(res, dlgex->x);
 736                 put_word(res, dlgex->y);
 737                 put_word(res, dlgex->width);
 738                 put_word(res, dlgex->height);
 739                 if(dlgex->menu)
 740                         put_name_id(res, dlgex->menu, TRUE, dlgex->lvc.language);
 741                 else
 742                         put_word(res, 0);
 743                 if(dlgex->dlgclass)
 744                         put_name_id(res, dlgex->dlgclass, TRUE, dlgex->lvc.language);
 745                 else
 746                         put_word(res, 0);
 747                 if(dlgex->title)
 748                         put_string(res, dlgex->title, str_unicode, TRUE, dlgex->lvc.language);
 749                 else
 750                         put_word(res, 0);
 751                 if(dlgex->font)
 752                 {
 753                         put_word(res, dlgex->font->size);
 754                         put_word(res, dlgex->font->weight);
 755                         /* FIXME: ? TRUE should be sufficient to say that it's
 756                          * italic, but Borland's compiler says it's 0x0101.
 757                          * I just copy it here, and hope for the best.
 758                          */
 759                         put_word(res, dlgex->font->italic ? 0x0101 : 0);
 760                         put_string(res, dlgex->font->name, str_unicode, TRUE, dlgex->lvc.language);
 761                 }
 762
 763                 put_pad(res);
 764                 while(ctrl)
 765                 {
 766                         put_dword(res, ctrl->gothelpid ? ctrl->helpid : 0);
 767                         put_dword(res, ctrl->gotexstyle ? ctrl->exstyle->or_mask : 0);
 768                         /* FIXME: what is default control style? */
 769                         put_dword(res, ctrl->gotstyle ? ctrl->style->or_mask : WS_CHILD | WS_VISIBLE);
 770                         put_word(res, ctrl->x);
 771                         put_word(res, ctrl->y);
 772                         put_word(res, ctrl->width);
 773                         put_word(res, ctrl->height);
 774                         put_dword(res, ctrl->id);
 775                         if(ctrl->ctlclass)
 776                                 put_name_id(res, ctrl->ctlclass, TRUE, dlgex->lvc.language);
 777                         else
 778                                 internal_error(__FILE__, __LINE__, "Control has no control-class\n");
 779                         if(ctrl->title)
 780                                 put_name_id(res, ctrl->title, FALSE, dlgex->lvc.language);
 781                         else
 782                                 put_word(res, 0);
 783                         if(ctrl->extra)
 784                         {
 785                                 put_pad(res);
 786                                 put_word(res, ctrl->extra->size);
 787                                 put_raw_data(res, ctrl->extra, 0);
 788                         }
 789                         else
 790                                 put_word(res, 0);
 791
 792                         put_pad(res);
 793                         nctrl++;
 794                         ctrl = ctrl->next;
 795                 }
 796                 /* Set number of controls */
 797                 set_word(res, tag_nctrl, (WORD)nctrl);
 798                 /* Set ResourceSize */
 799                 SetResSize(res, restag);
 800                 put_pad(res);
 801         }
 802         else /* win16 */
 803         {
 804                 /* Do not generate anything in 16-bit mode */
 805                 free(res->data);
 806                 free(res);
 807                 return NULL;
 808         }
 809         return res;
 810 }
 811
 812 /*
 813  *****************************************************************************
 814  * Function     : menuitem2res
 815  * Syntax       : void menuitem2res(res_t *res, menu_item_t *item)
 816  * Input        :
 817  * Output       :
 818  * Description  :
 819  * Remarks      : Self recursive
 820  *****************************************************************************
 821 */
 822 static void menuitem2res(res_t *res, menu_item_t *menitem, const language_t *lang)
 823 {
 824         menu_item_t *itm = menitem;
 825         if(win32)
 826         {
 827                 while(itm)
 828                 {
 829                         put_word(res, itm->state | (itm->popup ? MF_POPUP : 0) | (!itm->next ? MF_END : 0));
 830                         if(!itm->popup)
 831                                 put_word(res, itm->id);
 832                         if(itm->name)
 833                                 put_string(res, itm->name, str_unicode, TRUE, lang);
 834                         else
 835                                 put_word(res, 0);
 836                         if(itm->popup)
 837                                 menuitem2res(res, itm->popup, lang);
 838                         itm = itm->next;
 839                 }
 840         }
 841         else /* win16 */
 842         {
 843                 while(itm)
 844                 {
 845                         put_word(res, itm->state | (itm->popup ? MF_POPUP : 0) | (!itm->next ? MF_END : 0));
 846                         if(!itm->popup)
 847                                 put_word(res, itm->id);
 848                         if(itm->name)
 849                                 put_string(res, itm->name, str_char, TRUE, lang);
 850                         else
 851                                 put_byte(res, 0);
 852                         if(itm->popup)
 853                                 menuitem2res(res, itm->popup, lang);
 854                         itm = itm->next;
 855                 }
 856         }
 857
 858 }
 859
 860 /*
 861  *****************************************************************************
 862  * Function     : menu2res
 863  * Syntax       : res_t *menu2res(name_id_t *name, menu_t *men)
 864  * Input        :
 865  *      name    - Name/ordinal of the resource
 866  *      men     - The menu descriptor
 867  * Output       : New .res format structure
 868  * Description  :
 869  * Remarks      :
 870  *****************************************************************************
 871 */
 872 static res_t *menu2res(name_id_t *name, menu_t *men)
 873 {
 874         int restag;
 875         res_t *res;
 876         assert(name != NULL);
 877         assert(men != NULL);
 878
 879         res = new_res();
 880         restag = put_res_header(res, WRC_RT_MENU, NULL, name, men->memopt, win32 ? &(men->lvc) : NULL);
 881
 882         put_dword(res, 0);              /* Menuheader: Version and HeaderSize */
 883         menuitem2res(res, men->items, win32 ? men->lvc.language : NULL);
 884         /* Set ResourceSize */
 885         SetResSize(res, restag);
 886         if(win32)
 887                 put_pad(res);
 888         return res;
 889 }
 890
 891 /*
 892  *****************************************************************************
 893  * Function     : menuexitem2res
 894  * Syntax       : void menuexitem2res(res_t *res, menuex_item_t *item)
 895  * Input        :
 896  * Output       : nop
 897  * Description  :
 898  * Remarks      : Self recursive
 899  *****************************************************************************
 900 */
 901 static void menuexitem2res(res_t *res, menuex_item_t *menitem, const language_t *lang)
 902 {
 903         menuex_item_t *itm = menitem;
 904         assert(win32 != 0);
 905         while(itm)
 906         {
 907                 put_dword(res, itm->gottype ? itm->type : 0);
 908                 put_dword(res, itm->gotstate ? itm->state : 0);
 909                 put_dword(res, itm->gotid ? itm->id : 0);       /* FIXME: Docu. says word */
 910                 put_word(res, (itm->popup ? 0x01 : 0) | (!itm->next ? MF_END : 0));
 911                 if(itm->name)
 912                         put_string(res, itm->name, str_unicode, TRUE, lang);
 913                 else
 914                         put_word(res, 0);
 915                 put_pad(res);
 916                 if(itm->popup)
 917                 {
 918                         put_dword(res, itm->gothelpid ? itm->helpid : 0);
 919                         menuexitem2res(res, itm->popup, lang);
 920                 }
 921                 itm = itm->next;
 922         }
 923
 924 }
 925
 926 /*
 927  *****************************************************************************
 928  * Function     : menuex2res
 929  * Syntax       : res_t *menuex2res(name_id_t *name, menuex_t *menex)
 930  * Input        :
 931  *      name    - Name/ordinal of the resource
 932  *      menex   - The menuex descriptor
 933  * Output       : New .res format structure
 934  * Description  :
 935  * Remarks      :
 936  *****************************************************************************
 937 */
 938 static res_t *menuex2res(name_id_t *name, menuex_t *menex)
 939 {
 940         int restag;
 941         res_t *res;
 942         assert(name != NULL);
 943         assert(menex != NULL);
 944
 945         res = new_res();
 946         if(win32)
 947         {
 948                 restag = put_res_header(res, WRC_RT_MENU, NULL, name, menex->memopt, &(menex->lvc));
 949
 950                 put_word(res, 1);               /* Menuheader: Version */
 951                 put_word(res, 4);               /* Offset */
 952                 put_dword(res, 0);              /* HelpId */
 953                 put_pad(res);
 954                 menuexitem2res(res, menex->items, menex->lvc.language);
 955                 /* Set ResourceSize */
 956                 SetResSize(res, restag);
 957                 put_pad(res);
 958         }
 959         else /* win16 */
 960         {
 961                 /* Do not generate anything in 16-bit mode */
 962                 free(res->data);
 963                 free(res);
 964                 return NULL;
 965         }
 966         return res;
 967 }
 968
 969 /*
 970  *****************************************************************************
 971  * Function     : cursorgroup2res
 972  * Syntax       : res_t *cursorgroup2res(name_id_t *name, cursor_group_t *curg)
 973  * Input        :
 974  *      name    - Name/ordinal of the resource
 975  *      curg    - The cursor descriptor
 976  * Output       : New .res format structure
 977  * Description  :
 978  * Remarks      :
 979  *****************************************************************************
 980 */
 981 static res_t *cursorgroup2res(name_id_t *name, cursor_group_t *curg)
 982 {
 983         int restag;
 984         res_t *res;
 985         cursor_t *cur;
 986         assert(name != NULL);
 987         assert(curg != NULL);
 988
 989         res = new_res();
 990         restag = put_res_header(res, WRC_RT_GROUP_CURSOR, NULL, name, curg->memopt, &(curg->lvc));
 991         if(win32)
 992         {
 993                 put_word(res, 0);       /* Reserved */
 994                 /* FIXME: The ResType in the NEWHEADER structure should
 995                  * contain 14 according to the MS win32 doc. This is
 996                  * not the case with the BRC compiler and I really doubt
 997                  * the latter. Putting one here is compliant to win16 spec,
 998                  * but who knows the true value?
 999                  */
1000                 put_word(res, 2);       /* ResType */
1001                 put_word(res, curg->ncursor);
1002 #if 0
1003                 for(cur = curg->cursorlist; cur; cur = cur->next)
1004 #else
1005                 cur = curg->cursorlist;
1006                 while(cur->next)
1007                         cur = cur->next;
1008                 for(; cur; cur = cur->prev)
1009 #endif
1010                 {
1011                         put_word(res, cur->width);
1012                         /* FIXME: The height of a cursor is half the size of
1013                          * the bitmap's height. BRC puts the height from the
1014                          * BITMAPINFOHEADER here instead of the cursorfile's
1015                          * height. MS doesn't seem to care...
1016                          */
1017                         put_word(res, cur->height);
1018                         /* FIXME: The next two are reversed in BRC and I don't
1019                          * know why. Probably a bug. But, we can safely ignore
1020                          * it because win16 does not support color cursors.
1021                          * A warning should have been generated by the parser.
1022                          */
1023                         put_word(res, cur->planes);
1024                         put_word(res, cur->bits);
1025                         /* FIXME: The +4 is the hotspot in the cursor resource.
1026                          * However, I could not find this in the documentation.
1027                          * The hotspot bytes must either be included or MS
1028                          * doesn't care.
1029                          */
1030                         put_dword(res, cur->data->size +4);
1031                         put_word(res, cur->id);
1032                 }
1033         }
1034         else /* win16 */
1035         {
1036                 put_word(res, 0);       /* Reserved */
1037                 put_word(res, 2);       /* ResType */
1038                 put_word(res, curg->ncursor);
1039 #if 0
1040                 for(cur = curg->cursorlist; cur; cur = cur->next)
1041 #else
1042                 cur = curg->cursorlist;
1043                 while(cur->next)
1044                         cur = cur->next;
1045                 for(; cur; cur = cur->prev)
1046 #endif
1047                 {
1048                         put_word(res, cur->width);
1049                         /* FIXME: The height of a cursor is half the size of
1050                          * the bitmap's height. BRC puts the height from the
1051                          * BITMAPINFOHEADER here instead of the cursorfile's
1052                          * height. MS doesn't seem to care...
1053                          */
1054                         put_word(res, cur->height);
1055                         /* FIXME: The next two are reversed in BRC and I don't
1056                          * know why. Probably a bug. But, we can safely ignore
1057                          * it because win16 does not support color cursors.
1058                          * A warning should have been generated by the parser.
1059                          */
1060                         put_word(res, cur->planes);
1061                         put_word(res, cur->bits);
1062                         /* FIXME: The +4 is the hotspot in the cursor resource.
1063                          * However, I could not find this in the documentation.
1064                          * The hotspot bytes must either be included or MS
1065                          * doesn't care.
1066                          */
1067                         put_dword(res, cur->data->size +4);
1068                         put_word(res, cur->id);
1069                 }
1070         }
1071         SetResSize(res, restag);        /* Set ResourceSize */
1072         if(win32)
1073                 put_pad(res);
1074
1075         return res;
1076 }
1077
1078 /*
1079  *****************************************************************************
1080  * Function     : cursor2res
1081  * Syntax       : res_t *cursor2res(cursor_t *cur)
1082  * Input        :
1083  *      cur     - The cursor descriptor
1084  * Output       : New .res format structure
1085  * Description  :
1086  * Remarks      :
1087  *****************************************************************************
1088 */
1089 static res_t *cursor2res(cursor_t *cur)
1090 {
1091         int restag;
1092         res_t *res;
1093         name_id_t name;
1094
1095         assert(cur != NULL);
1096
1097         res = new_res();
1098         name.type = name_ord;
1099         name.name.i_name = cur->id;
1100         restag = put_res_header(res, WRC_RT_CURSOR, NULL, &name, WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE, &(cur->lvc));
1101         put_word(res, cur->xhot);
1102         put_word(res, cur->yhot);
1103         put_raw_data(res, cur->data, 0);
1104
1105         SetResSize(res, restag);        /* Set ResourceSize */
1106         if(win32)
1107                 put_pad(res);
1108
1109         return res;
1110 }
1111
1112 /*
1113  *****************************************************************************
1114  * Function     : icongroup2res
1115  * Syntax       : res_t *icongroup2res(name_id_t *name, icon_group_t *icog)
1116  * Input        :
1117  *      name    - Name/ordinal of the resource
1118  *      icog    - The icon group descriptor
1119  * Output       : New .res format structure
1120  * Description  :
1121  * Remarks      :
1122  *****************************************************************************
1123 */
1124 static res_t *icongroup2res(name_id_t *name, icon_group_t *icog)
1125 {
1126         int restag;
1127         res_t *res;
1128         icon_t *ico;
1129         assert(name != NULL);
1130         assert(icog != NULL);
1131
1132         res = new_res();
1133         restag = put_res_header(res, WRC_RT_GROUP_ICON, NULL, name, icog->memopt, &(icog->lvc));
1134         if(win32)
1135         {
1136                 put_word(res, 0);       /* Reserved */
1137                 /* FIXME: The ResType in the NEWHEADER structure should
1138                  * contain 14 according to the MS win32 doc. This is
1139                  * not the case with the BRC compiler and I really doubt
1140                  * the latter. Putting one here is compliant to win16 spec,
1141                  * but who knows the true value?
1142                  */
1143                 put_word(res, 1);       /* ResType */
1144                 put_word(res, icog->nicon);
1145                 for(ico = icog->iconlist; ico; ico = ico->next)
1146                 {
1147                         put_byte(res, ico->width);
1148                         put_byte(res, ico->height);
1149                         put_byte(res, ico->nclr);
1150                         put_byte(res, 0);       /* Reserved */
1151                         put_word(res, ico->planes);
1152                         put_word(res, ico->bits);
1153                         put_dword(res, ico->data->size);
1154                         put_word(res, ico->id);
1155                 }
1156         }
1157         else /* win16 */
1158         {
1159                 put_word(res, 0);       /* Reserved */
1160                 put_word(res, 1);       /* ResType */
1161                 put_word(res, icog->nicon);
1162                 for(ico = icog->iconlist; ico; ico = ico->next)
1163                 {
1164                         put_byte(res, ico->width);
1165                         put_byte(res, ico->height);
1166                         put_byte(res, ico->nclr);
1167                         put_byte(res, 0);       /* Reserved */
1168                         put_word(res, ico->planes);
1169                         put_word(res, ico->bits);
1170                         put_dword(res, ico->data->size);
1171                         put_word(res, ico->id);
1172                 }
1173         }
1174         SetResSize(res, restag);        /* Set ResourceSize */
1175         if(win32)
1176                 put_pad(res);
1177
1178         return res;
1179 }
1180
1181 /*
1182  *****************************************************************************
1183  * Function     : icon2res
1184  * Syntax       : res_t *icon2res(icon_t *ico)
1185  * Input        :
1186  *      ico     - The icon descriptor
1187  * Output       : New .res format structure
1188  * Description  :
1189  * Remarks      :
1190  *****************************************************************************
1191 */
1192 static res_t *icon2res(icon_t *ico)
1193 {
1194         int restag;
1195         res_t *res;
1196         name_id_t name;
1197
1198         assert(ico != NULL);
1199
1200         res = new_res();
1201         name.type = name_ord;
1202         name.name.i_name = ico->id;
1203         restag = put_res_header(res, WRC_RT_ICON, NULL, &name, WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE, &(ico->lvc));
1204         put_raw_data(res, ico->data, 0);
1205
1206         SetResSize(res, restag);        /* Set ResourceSize */
1207         if(win32)
1208                 put_pad(res);
1209
1210         return res;
1211 }
1212
1213 /*
1214  *****************************************************************************
1215  * Function     : anicurico2res
1216  * Syntax       : res_t *anicurico2res(name_id_t *name, ani_curico_t *ani)
1217  * Input        :
1218  *      name    - Name/ordinal of the resource
1219  *      ani     - The animated object descriptor
1220  * Output       : New .res format structure
1221  * Description  :
1222  * Remarks      : The endian of the object's structures have been converted
1223  *                by the loader.
1224  *                There are rumors that win311 could handle animated stuff.
1225  *                That is why they are generated for both win16 and win32
1226  *                compile.
1227  *****************************************************************************
1228 */
1229 static res_t *anicurico2res(name_id_t *name, ani_curico_t *ani, enum res_e type)
1230 {
1231         int restag;
1232         res_t *res;
1233         assert(name != NULL);
1234         assert(ani != NULL);
1235
1236         res = new_res();
1237         restag = put_res_header(res, type == res_anicur ? WRC_RT_ANICURSOR : WRC_RT_ANIICON,
1238                                 NULL, name, ani->memopt, NULL);
1239         put_raw_data(res, ani->data, 0);
1240         /* Set ResourceSize */
1241         SetResSize(res, restag);
1242         if(win32)
1243                 put_pad(res);
1244         return res;
1245 }
1246
1247 /*
1248  *****************************************************************************
1249  * Function     : bitmap2res
1250  * Syntax       : res_t *bitmap2res(name_id_t *name, bitmap_t *bmp)
1251  * Input        :
1252  *      name    - Name/ordinal of the resource
1253  *      bmp     - The bitmap descriptor
1254  * Output       : New .res format structure
1255  * Description  :
1256  * Remarks      : The endian of the bitmap structures have been converted
1257  *                by the loader.
1258  *****************************************************************************
1259 */
1260 static res_t *bitmap2res(name_id_t *name, bitmap_t *bmp)
1261 {
1262         int restag;
1263         res_t *res;
1264         assert(name != NULL);
1265         assert(bmp != NULL);
1266
1267         res = new_res();
1268         restag = put_res_header(res, WRC_RT_BITMAP, NULL, name, bmp->memopt, &(bmp->data->lvc));
1269         if(bmp->data->data[0] == 'B'
1270         && bmp->data->data[1] == 'M'
1271         && ((BITMAPFILEHEADER *)bmp->data->data)->bfSize == bmp->data->size
1272         && bmp->data->size >= sizeof(BITMAPFILEHEADER))
1273         {
1274                 /* The File header is still attached, don't write it */
1275                 put_raw_data(res, bmp->data, sizeof(BITMAPFILEHEADER));
1276         }
1277         else
1278         {
1279                 put_raw_data(res, bmp->data, 0);
1280         }
1281         /* Set ResourceSize */
1282         SetResSize(res, restag);
1283         if(win32)
1284                 put_pad(res);
1285         return res;
1286 }
1287
1288 /*
1289  *****************************************************************************
1290  * Function     : font2res
1291  * Syntax       : res_t *font2res(name_id_t *name, font_t *fnt)
1292  * Input        :
1293  *      name    - Name/ordinal of the resource
1294  *      fnt     - The font descriptor
1295  * Output       : New .res format structure
1296  * Description  :
1297  * Remarks      : The data has been prepared just after parsing.
1298  *****************************************************************************
1299 */
1300 static res_t *font2res(name_id_t *name, font_t *fnt)
1301 {
1302         int restag;
1303         res_t *res;
1304         assert(name != NULL);
1305         assert(fnt != NULL);
1306
1307         res = new_res();
1308         restag = put_res_header(res, WRC_RT_FONT, NULL, name, fnt->memopt, &(fnt->data->lvc));
1309         put_raw_data(res, fnt->data, 0);
1310         /* Set ResourceSize */
1311         SetResSize(res, restag);
1312         if(win32)
1313                 put_pad(res);
1314         return res;
1315 }
1316
1317 /*
1318  *****************************************************************************
1319  * Function     : fontdir2res
1320  * Syntax       : res_t *fontdir2res(name_id_t *name, fontdir_t *fnd)
1321  * Input        :
1322  *      name    - Name/ordinal of the resource
1323  *      fntdir  - The fontdir descriptor
1324  * Output       : New .res format structure
1325  * Description  :
1326  * Remarks      : The data has been prepared just after parsing.
1327  *****************************************************************************
1328 */
1329 static res_t *fontdir2res(name_id_t *name, fontdir_t *fnd)
1330 {
1331         int restag;
1332         res_t *res;
1333         assert(name != NULL);
1334         assert(fnd != NULL);
1335
1336         res = new_res();
1337         restag = put_res_header(res, WRC_RT_FONTDIR, NULL, name, fnd->memopt, &(fnd->data->lvc));
1338         put_raw_data(res, fnd->data, 0);
1339         /* Set ResourceSize */
1340         SetResSize(res, restag);
1341         if(win32)
1342                 put_pad(res);
1343         return res;
1344 }
1345
1346 /*
1347  *****************************************************************************
1348  * Function     : html2res
1349  * Syntax       : res_t *html2res(name_id_t *name, html_t *html)
1350  * Input        :
1351  *      name    - Name/ordinal of the resource
1352  *      rdt     - The html descriptor
1353  * Output       : New .res format structure
1354  * Description  :
1355  * Remarks      :
1356  *****************************************************************************
1357 */
1358 static res_t *html2res(name_id_t *name, html_t *html)
1359 {
1360         int restag;
1361         res_t *res;
1362         assert(name != NULL);
1363         assert(html != NULL);
1364
1365         res = new_res();
1366         restag = put_res_header(res, WRC_RT_HTML, NULL, name, html->memopt, &(html->data->lvc));
1367         put_raw_data(res, html->data, 0);
1368         /* Set ResourceSize */
1369         SetResSize(res, restag);
1370         if(win32)
1371                 put_pad(res);
1372         return res;
1373 }
1374
1375 /*
1376  *****************************************************************************
1377  * Function     : rcdata2res
1378  * Syntax       : res_t *rcdata2res(name_id_t *name, rcdata_t *rdt)
1379  * Input        :
1380  *      name    - Name/ordinal of the resource
1381  *      rdt     - The rcdata descriptor
1382  * Output       : New .res format structure
1383  * Description  :
1384  * Remarks      :
1385  *****************************************************************************
1386 */
1387 static res_t *rcdata2res(name_id_t *name, rcdata_t *rdt)
1388 {
1389         int restag;
1390         res_t *res;
1391         assert(name != NULL);
1392         assert(rdt != NULL);
1393
1394         res = new_res();
1395         restag = put_res_header(res, WRC_RT_RCDATA, NULL, name, rdt->memopt, &(rdt->data->lvc));
1396         put_raw_data(res, rdt->data, 0);
1397         /* Set ResourceSize */
1398         SetResSize(res, restag);
1399         if(win32)
1400                 put_pad(res);
1401         return res;
1402 }
1403
1404 /*
1405  *****************************************************************************
1406  * Function     : messagetable2res
1407  * Syntax       : res_t *messagetable2res(name_id_t *name, messagetable_t *msg)
1408  * Input        :
1409  *      name    - Name/ordinal of the resource
1410  *      msg     - The messagetable descriptor
1411  * Output       : New .res format structure
1412  * Description  :
1413  * Remarks      : The data has been converted to the appropriate endian
1414  *                after it was parsed.
1415  *****************************************************************************
1416 */
1417 static res_t *messagetable2res(name_id_t *name, messagetable_t *msg)
1418 {
1419         int restag;
1420         res_t *res;
1421         assert(name != NULL);
1422         assert(msg != NULL);
1423
1424         res = new_res();
1425         restag = put_res_header(res, WRC_RT_MESSAGETABLE, NULL, name, msg->memopt, &(msg->data->lvc));
1426         put_raw_data(res, msg->data, 0);
1427         /* Set ResourceSize */
1428         SetResSize(res, restag);
1429         if(win32)
1430                 put_pad(res);
1431         return res;
1432 }
1433
1434 /*
1435  *****************************************************************************
1436  * Function     : stringtable2res
1437  * Syntax       : res_t *stringtable2res(stringtable_t *stt)
1438  * Input        :
1439  *      stt     - The stringtable descriptor
1440  * Output       : New .res format structure
1441  * Description  :
1442  * Remarks      :
1443  *****************************************************************************
1444 */
1445 static res_t *stringtable2res(stringtable_t *stt)
1446 {
1447         res_t *res;
1448         name_id_t name;
1449         int i;
1450         int restag;
1451         DWORD lastsize = 0;
1452
1453         assert(stt != NULL);
1454         res = new_res();
1455
1456         for(; stt; stt = stt->next)
1457         {
1458                 if(!stt->nentries)
1459                 {
1460                         warning("Empty internal stringtable\n");
1461                         continue;
1462                 }
1463                 name.type = name_ord;
1464                 name.name.i_name = (stt->idbase >> 4) + 1;
1465                 restag = put_res_header(res, WRC_RT_STRING, NULL, &name, stt->memopt, win32 ? &(stt->lvc) : NULL);
1466                 for(i = 0; i < stt->nentries; i++)
1467                 {
1468                         if(stt->entries[i].str && stt->entries[i].str->size)
1469                         {
1470                                 put_string(res, stt->entries[i].str, win32 ? str_unicode : str_char,
1471                                            FALSE, win32 ? stt->lvc.language : NULL);
1472                         }
1473                         else
1474                         {
1475                                 if (win32)
1476                                         put_word(res, 0);
1477                                 else
1478                                         put_byte(res, 0);
1479                         }
1480                 }
1481                 /* Set ResourceSize */
1482                 SetResSize(res, restag - lastsize);
1483                 if(win32)
1484                         put_pad(res);
1485                 lastsize = res->size;
1486         }
1487         return res;
1488 }
1489
1490 /*
1491  *****************************************************************************
1492  * Function     : user2res
1493  * Syntax       : res_t *user2res(name_id_t *name, user_t *usr)
1494  * Input        :
1495  *      name    - Name/ordinal of the resource
1496  *      usr     - The userresource descriptor
1497  * Output       : New .res format structure
1498  * Description  :
1499  * Remarks      :
1500  *****************************************************************************
1501 */
1502 static res_t *user2res(name_id_t *name, user_t *usr)
1503 {
1504         int restag;
1505         res_t *res;
1506         assert(name != NULL);
1507         assert(usr != NULL);
1508
1509         res = new_res();
1510         restag = put_res_header(res, 0, usr->type, name, usr->memopt, &(usr->data->lvc));
1511         put_raw_data(res, usr->data, 0);
1512         /* Set ResourceSize */
1513         SetResSize(res, restag);
1514         if(win32)
1515                 put_pad(res);
1516         return res;
1517 }
1518
1519 /*
1520  *****************************************************************************
1521  * Function     : versionblock2res
1522  * Syntax       : void versionblock2res(res_t *res, ver_block_t *blk)
1523  * Input        :
1524  *      res     - Binary resource to write to
1525  *      blk     - The version block to be written
1526  * Output       :
1527  * Description  :
1528  * Remarks      : Self recursive
1529  *****************************************************************************
1530 */
1531 static void versionblock2res(res_t *res, ver_block_t *blk, int level, const language_t *lang)
1532 {
1533         ver_value_t *val;
1534         int blksizetag;
1535         int valblksizetag;
1536         int valvalsizetag;
1537         int tag;
1538         int i;
1539
1540         blksizetag = res->size;
1541         put_word(res, 0);       /* Will be overwritten later */
1542         put_word(res, 0);
1543         if(win32)
1544                 put_word(res, 0);       /* level ? */
1545         put_string(res, blk->name, win32 ? str_unicode : str_char, TRUE, lang);
1546         put_pad(res);
1547         for(val = blk->values; val; val = val->next)
1548         {
1549                 if(val->type == val_str)
1550                 {
1551                         valblksizetag = res->size;
1552                         put_word(res, 0);       /* Will be overwritten later */
1553                         valvalsizetag = res->size;
1554                         put_word(res, 0);       /* Will be overwritten later */
1555                         if(win32)
1556                         {
1557                                 put_word(res, level);
1558                         }
1559                         put_string(res, val->key, win32 ? str_unicode : str_char, TRUE, lang);
1560                         put_pad(res);
1561                         tag = res->size;
1562                         put_string(res, val->value.str, win32 ? str_unicode : str_char, TRUE, lang);
1563                         if(win32)
1564                                 set_word(res, valvalsizetag, (WORD)((res->size - tag) >> 1));
1565                         else
1566                                 set_word(res, valvalsizetag, (WORD)(res->size - tag));
1567                         set_word(res, valblksizetag, (WORD)(res->size - valblksizetag));
1568                         put_pad(res);
1569                 }
1570                 else if(val->type == val_words)
1571                 {
1572                         valblksizetag = res->size;
1573                         put_word(res, 0);       /* Will be overwritten later */
1574                         valvalsizetag = res->size;
1575                         put_word(res, 0);       /* Will be overwritten later */
1576                         if(win32)
1577                         {
1578                                 put_word(res, level);
1579                         }
1580                         put_string(res, val->key, win32 ? str_unicode : str_char, TRUE, lang);
1581                         put_pad(res);
1582                         tag = res->size;
1583                         for(i = 0; i < val->value.words->nwords; i++)
1584                         {
1585                                 put_word(res, val->value.words->words[i]);
1586                         }
1587                         set_word(res, valvalsizetag, (WORD)(res->size - tag));
1588                         set_word(res, valblksizetag, (WORD)(res->size - valblksizetag));
1589                         put_pad(res);
1590                 }
1591                 else if(val->type == val_block)
1592                 {
1593                         versionblock2res(res, val->value.block, level+1, lang);
1594                 }
1595                 else
1596                 {
1597                         internal_error(__FILE__, __LINE__, "Invalid value indicator %d in VERSIONINFO\n", val->type);
1598                 }
1599         }
1600
1601         /* Set blocksize */
1602         set_word(res, blksizetag, (WORD)(res->size - blksizetag));
1603 }
1604
1605 /*
1606  *****************************************************************************
1607  * Function     : versioninfo2res
1608  * Syntax       : res_t *versioninfo2res(name_id_t *name, versioninfo_t *ver)
1609  * Input        :
1610  *      name    - Name/ordinal of the resource
1611  *      ver     - The versioninfo descriptor
1612  * Output       : New .res format structure
1613  * Description  :
1614  * Remarks      :
1615  *****************************************************************************
1616 */
1617 static res_t *versioninfo2res(name_id_t *name, versioninfo_t *ver)
1618 {
1619         int restag;
1620         int rootblocksizetag;
1621         int valsizetag;
1622         int tag;
1623         res_t *res;
1624         string_t vsvi;
1625         ver_block_t *blk;
1626
1627         assert(name != NULL);
1628         assert(ver != NULL);
1629
1630         vsvi.type = str_char;
1631         vsvi.str.cstr = xstrdup("VS_VERSION_INFO");
1632         vsvi.size = 15; /* Excl. termination */
1633
1634         res = new_res();
1635         restag = put_res_header(res, WRC_RT_VERSION, NULL, name, ver->memopt, &(ver->lvc));
1636         rootblocksizetag = res->size;
1637         put_word(res, 0);       /* BlockSize filled in later */
1638         valsizetag = res->size;
1639         put_word(res, 0);       /* ValueSize filled in later*/
1640         if(win32)
1641                 put_word(res, 0);       /* Tree-level ? */
1642         put_string(res, &vsvi, win32 ? str_unicode : str_char,
1643                    TRUE, win32 ? ver->lvc.language : NULL);
1644         if(win32)
1645                 put_pad(res);
1646         tag = res->size;
1647         put_dword(res, VS_FFI_SIGNATURE);
1648         put_dword(res, VS_FFI_STRUCVERSION);
1649         put_dword(res, (ver->filever_maj1 << 16) + (ver->filever_maj2 & 0xffff));
1650         put_dword(res, (ver->filever_min1 << 16) + (ver->filever_min2 & 0xffff));
1651         put_dword(res, (ver->prodver_maj1 << 16) + (ver->prodver_maj2 & 0xffff));
1652         put_dword(res, (ver->prodver_min1 << 16) + (ver->prodver_min2 & 0xffff));
1653         put_dword(res, ver->fileflagsmask);
1654         put_dword(res, ver->fileflags);
1655         put_dword(res, ver->fileos);
1656         put_dword(res, ver->filetype);
1657         put_dword(res, ver->filesubtype);
1658         put_dword(res, 0);              /* FileDateMS */
1659         put_dword(res, 0);              /* FileDateLS */
1660         /* Set ValueSize */
1661         set_word(res, valsizetag, (WORD)(res->size - tag));
1662         /* Descend into the blocks */
1663         for(blk = ver->blocks; blk; blk = blk->next)
1664                 versionblock2res(res, blk, 0, win32 ? ver->lvc.language : NULL);
1665         /* Set root block's size */
1666         set_word(res, rootblocksizetag, (WORD)(res->size - rootblocksizetag));
1667
1668         SetResSize(res, restag);
1669         if(win32)
1670                 put_pad(res);
1671
1672         free(vsvi.str.cstr);
1673         return res;
1674 }
1675
1676 /*
1677  *****************************************************************************
1678  * Function     : toolbaritem2res
1679  * Syntax       : void toolbaritem2res(res_t *res, toolbar_item_t *tbitem)
1680  * Input        :
1681  * Output       : nop
1682  * Description  :
1683  * Remarks      : Self recursive
1684  *****************************************************************************
1685 */
1686 static void toolbaritem2res(res_t *res, toolbar_item_t *tbitem)
1687 {
1688         toolbar_item_t *itm = tbitem;
1689         assert(win32 != 0);
1690         while(itm)
1691         {
1692                 put_word(res, itm->id);
1693                 itm = itm->next;
1694         }
1695
1696 }
1697
1698 /*
1699  *****************************************************************************
1700  * Function     : toolbar2res
1701  * Syntax       : res_t *toolbar2res(name_id_t *name, toolbar_t *toolbar)
1702  * Input        :
1703  *      name    - Name/ordinal of the resource
1704  *      toolbar - The toolbar descriptor
1705  * Output       : New .res format structure
1706  * Description  :
1707  * Remarks      :
1708  *****************************************************************************
1709 */
1710 static res_t *toolbar2res(name_id_t *name, toolbar_t *toolbar)
1711 {
1712         int restag;
1713         res_t *res;
1714         assert(name != NULL);
1715         assert(toolbar != NULL);
1716
1717         res = new_res();
1718         if(win32)
1719         {
1720                 restag = put_res_header(res, WRC_RT_TOOLBAR, NULL, name, toolbar->memopt, &(toolbar->lvc));
1721
1722                 put_word(res, 1);               /* Menuheader: Version */
1723                 put_word(res, toolbar->button_width); /* (in pixels?) */
1724                 put_word(res, toolbar->button_height); /* (in pixels?) */
1725                 put_word(res, toolbar->nitems);
1726                 put_pad(res);
1727                 toolbaritem2res(res, toolbar->items);
1728                 /* Set ResourceSize */
1729                 SetResSize(res, restag);
1730                 put_pad(res);
1731         }
1732         else /* win16 */
1733         {
1734                 /* Do not generate anything in 16-bit mode */
1735                 free(res->data);
1736                 free(res);
1737                 return NULL;
1738         }
1739         return res;
1740 }
1741
1742 /*
1743  *****************************************************************************
1744  * Function     : dlginit2res
1745  * Syntax       : res_t *dlginit2res(name_id_t *name, dlginit_t *dit)
1746  * Input        :
1747  *      name    - Name/ordinal of the resource
1748  *      rdt     - The dlginit descriptor
1749  * Output       : New .res format structure
1750  * Description  :
1751  * Remarks      :
1752  *****************************************************************************
1753 */
1754 static res_t *dlginit2res(name_id_t *name, dlginit_t *dit)
1755 {
1756         int restag;
1757         res_t *res;
1758         assert(name != NULL);
1759         assert(dit != NULL);
1760
1761         res = new_res();
1762         restag = put_res_header(res, WRC_RT_DLGINIT, NULL, name, dit->memopt, &(dit->data->lvc));
1763         put_raw_data(res, dit->data, 0);
1764         /* Set ResourceSize */
1765         SetResSize(res, restag);
1766         if(win32)
1767                 put_pad(res);
1768         return res;
1769 }
1770
1771 /*
1772  *****************************************************************************
1773  * Function     : prep_nid_for_label
1774  * Syntax       : char *prep_nid_for_label(const name_id_t *nid)
1775  * Input        :
1776  * Output       :
1777  * Description  : Converts a resource name into the first 32 (or less)
1778  *                characters of the name with conversions.
1779  * Remarks      :
1780  *****************************************************************************
1781 */
1782 #define MAXNAMELEN      32
1783 char *prep_nid_for_label(const name_id_t *nid)
1784 {
1785         static char buf[MAXNAMELEN+1];
1786
1787         assert(nid != NULL);
1788
1789         if(nid->type == name_str && nid->name.s_name->type == str_unicode)
1790         {
1791                 WCHAR *sptr;
1792                 int i;
1793                 sptr = nid->name.s_name->str.wstr;
1794                 buf[0] = '\0';
1795                 for(i = 0; *sptr && i < MAXNAMELEN; i++)
1796                 {
1797                         if((unsigned)*sptr < 0x80 && isprint(*sptr & 0xff))
1798                                 buf[i] = *sptr++;
1799                         else
1800                                 warning("Resourcename (str_unicode) contain unprintable characters or invalid translation, ignored\n");
1801                 }
1802                 buf[i] = '\0';
1803         }
1804         else if(nid->type == name_str && nid->name.s_name->type == str_char)
1805         {
1806                 char *cptr;
1807                 int i;
1808                 cptr = nid->name.s_name->str.cstr;
1809                 buf[0] = '\0';
1810                 for(i = 0; *cptr && i < MAXNAMELEN; i++)
1811                 {
1812                         if((unsigned)*cptr < 0x80 && isprint(*cptr & 0xff))
1813                                 buf[i] = *cptr++;
1814                         else
1815                                 warning("Resourcename (str_char) contain unprintable characters, ignored\n");
1816                 }
1817                 buf[i] = '\0';
1818         }
1819         else if(nid->type == name_ord)
1820         {
1821                 sprintf(buf, "%u", nid->name.i_name);
1822         }
1823         else
1824         {
1825                 internal_error(__FILE__, __LINE__, "Resource name_id with invalid type %d\n", nid->type);
1826         }
1827         return buf;
1828 }
1829 #undef MAXNAMELEN
1830
1831 /*
1832  *****************************************************************************
1833  * Function     : make_c_name
1834  * Syntax       : char *make_c_name(const char *base, const name_id_t *nid, const language_t *lan)
1835  * Input        :
1836  * Output       :
1837  * Description  : Converts a resource name into a valid c-identifier in the
1838  *                form "_base_nid".
1839  * Remarks      :
1840  *****************************************************************************
1841 */
1842 char *make_c_name(const char *base, const name_id_t *nid, const language_t *lan)
1843 {
1844         int nlen;
1845         char *buf;
1846         char *ret;
1847         char lanbuf[6];
1848
1849         sprintf(lanbuf, "%d", lan ? MAKELANGID(lan->id, lan->sub) : 0);
1850         buf = prep_nid_for_label(nid);
1851         nlen = strlen(buf) + strlen(lanbuf);
1852         nlen += strlen(base) + 4; /* three time '_' and '\0' */
1853         ret = xmalloc(nlen);
1854         strcpy(ret, "_");
1855         strcat(ret, base);
1856         strcat(ret, "_");
1857         strcat(ret, buf);
1858         strcat(ret, "_");
1859         strcat(ret, lanbuf);
1860         return ret;
1861 }
1862
1863 /*
1864  *****************************************************************************
1865  * Function     : get_c_typename
1866  * Syntax       : const char *get_c_typename(enum res_e type)
1867  * Input        :
1868  * Output       :
1869  * Description  : Convert resource enum to char string to be used in c-name
1870  *                creation.
1871  * Remarks      :
1872  *****************************************************************************
1873 */
1874 const char *get_c_typename(enum res_e type)
1875 {
1876         switch(type)
1877         {
1878         case res_acc:   return "Acc";
1879         case res_anicur:return "AniCur";
1880         case res_aniico:return "AniIco";
1881         case res_bmp:   return "Bmp";
1882         case res_cur:   return "Cur";
1883         case res_curg:  return "CurGrp";
1884         case res_dlg:
1885         case res_dlgex: return "Dlg";
1886         case res_fnt:   return "Fnt";
1887         case res_fntdir:return "FntDir";
1888         case res_ico:   return "Ico";
1889         case res_icog:  return "IcoGrp";
1890         case res_men:
1891         case res_menex: return "Men";
1892         case res_rdt:   return "RCDat";
1893         case res_stt:   return "StrTab";
1894         case res_usr:   return "Usr";
1895         case res_msg:   return "MsgTab";
1896         case res_ver:   return "VerInf";
1897         case res_toolbar:       return "TlBr";
1898         case res_dlginit: return "DlgInit";
1899         default:        return "Oops";
1900         }
1901 }
1902
1903 /*
1904  *****************************************************************************
1905  * Function     : resources2res
1906  * Syntax       : void resources2res(resource_t *top)
1907  * Input        :
1908  *      top     - The resource-tree to convert
1909  * Output       :
1910  * Description  : Convert logical resource descriptors into binary data
1911  * Remarks      :
1912  *****************************************************************************
1913 */
1914 void resources2res(resource_t *top)
1915 {
1916         while(top)
1917         {
1918                 switch(top->type)
1919                 {
1920                 case res_acc:
1921                         if(!top->binres)
1922                                 top->binres = accelerator2res(top->name, top->res.acc);
1923                         break;
1924                 case res_bmp:
1925                         if(!top->binres)
1926                                 top->binres = bitmap2res(top->name, top->res.bmp);
1927                         break;
1928                 case res_cur:
1929                         if(!top->binres)
1930                                 top->binres = cursor2res(top->res.cur);
1931                         break;
1932                 case res_curg:
1933                         if(!top->binres)
1934                                 top->binres = cursorgroup2res(top->name, top->res.curg);
1935                         break;
1936                 case res_dlg:
1937                         if(!top->binres)
1938                                 top->binres = dialog2res(top->name, top->res.dlg);
1939                         break;
1940                 case res_dlgex:
1941                         if(!top->binres)
1942                                 top->binres = dialogex2res(top->name, top->res.dlgex);
1943                         break;
1944                 case res_fnt:
1945                         if(!top->binres)
1946                                 top->binres = font2res(top->name, top->res.fnt);
1947                         break;
1948                 case res_fntdir:
1949                         if(!top->binres)
1950                                 top->binres = fontdir2res(top->name, top->res.fnd);
1951                         break;
1952                 case res_ico:
1953                         if(!top->binres)
1954                                 top->binres = icon2res(top->res.ico);
1955                         break;
1956                 case res_icog:
1957                         if(!top->binres)
1958                                 top->binres = icongroup2res(top->name, top->res.icog);
1959                         break;
1960                 case res_men:
1961                         if(!top->binres)
1962                                 top->binres = menu2res(top->name, top->res.men);
1963                         break;
1964                 case res_menex:
1965                         if(!top->binres)
1966                                 top->binres = menuex2res(top->name, top->res.menex);
1967                         break;
1968                 case res_html:
1969                         if(!top->binres)
1970                                 top->binres = html2res(top->name, top->res.html);
1971                         break;
1972                 case res_rdt:
1973                         if(!top->binres)
1974                                 top->binres = rcdata2res(top->name, top->res.rdt);
1975                         break;
1976                 case res_stt:
1977                         if(!top->binres)
1978                                 top->binres = stringtable2res(top->res.stt);
1979                         break;
1980                 case res_usr:
1981                         if(!top->binres)
1982                                 top->binres = user2res(top->name, top->res.usr);
1983                         break;
1984                 case res_msg:
1985                         if(!top->binres)
1986                                 top->binres = messagetable2res(top->name, top->res.msg);
1987                         break;
1988                 case res_ver:
1989                         if(!top->binres)
1990                                 top->binres = versioninfo2res(top->name, top->res.ver);
1991                         break;
1992                 case res_toolbar:
1993                         if(!top->binres)
1994                                 top->binres = toolbar2res(top->name, top->res.tbt);
1995                         break;
1996                 case res_dlginit:
1997                         if(!top->binres)
1998                             top->binres = dlginit2res(top->name, top->res.dlgi);
1999                         break;
2000                 case res_anicur:
2001                 case res_aniico:
2002                         if(!top->binres)
2003                             top->binres = anicurico2res(top->name, top->res.ani, top->type);
2004                         break;
2005                 default:
2006                         internal_error(__FILE__, __LINE__, "Unknown resource type encountered %d in binary res generation\n", top->type);
2007                 }
2008                 top->c_name = make_c_name(get_c_typename(top->type), top->name, top->lan);
2009                 top = top->next;
2010         }
2011 }