git.oblomov.eu Git - wine/blob - tools/wrc/newstruc.c

   1 /*
   2  * Create dynamic new structures of various types
   3  * and some utils in that trend.
   4  *
   5  * Copyright 1998 Bertho A. Stultiens
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <assert.h>
  28 #include <ctype.h>
  29
  30 #include "wrc.h"
  31 #include "newstruc.h"
  32 #include "utils.h"
  33 #include "parser.h"
  34
  35 #include "wingdi.h"     /* for BITMAPINFOHEADER */
  36
  37 #include <pshpack2.h>
  38 typedef struct
  39 {
  40     DWORD biSize;
  41     WORD  biWidth;
  42     WORD  biHeight;
  43     WORD  biPlanes;
  44     WORD  biBitCount;
  45 } BITMAPOS2HEADER;
  46 #include <poppack.h>
  47
  48 /* Generate new_* functions that have no parameters (NOTE: no ';') */
  49 __NEW_STRUCT_FUNC(dialog)
  50 __NEW_STRUCT_FUNC(dialogex)
  51 __NEW_STRUCT_FUNC(name_id)
  52 __NEW_STRUCT_FUNC(menu)
  53 __NEW_STRUCT_FUNC(menuex)
  54 __NEW_STRUCT_FUNC(menu_item)
  55 __NEW_STRUCT_FUNC(menuex_item)
  56 __NEW_STRUCT_FUNC(control)
  57 __NEW_STRUCT_FUNC(icon)
  58 __NEW_STRUCT_FUNC(cursor)
  59 __NEW_STRUCT_FUNC(versioninfo)
  60 __NEW_STRUCT_FUNC(ver_value)
  61 __NEW_STRUCT_FUNC(ver_block)
  62 __NEW_STRUCT_FUNC(stt_entry)
  63 __NEW_STRUCT_FUNC(accelerator)
  64 __NEW_STRUCT_FUNC(event)
  65 __NEW_STRUCT_FUNC(raw_data)
  66 __NEW_STRUCT_FUNC(lvc)
  67 __NEW_STRUCT_FUNC(res_count)
  68 __NEW_STRUCT_FUNC(string)
  69 __NEW_STRUCT_FUNC(toolbar_item)
  70 __NEW_STRUCT_FUNC(ani_any)
  71
  72 /* New instances for all types of structures */
  73 /* Very inefficient (in size), but very functional :-]
  74  * Especially for type-checking.
  75  */
  76 resource_t *new_resource(enum res_e t, void *res, int memopt, language_t *lan)
  77 {
  78         resource_t *r = (resource_t *)xmalloc(sizeof(resource_t));
  79         r->type = t;
  80         r->res.overlay = res;
  81         r->memopt = memopt;
  82         r->lan = lan;
  83         return r;
  84 }
  85
  86 version_t *new_version(DWORD v)
  87 {
  88         version_t *vp = (version_t *)xmalloc(sizeof(version_t));
  89         *vp = v;
  90         return vp;
  91 }
  92
  93 characts_t *new_characts(DWORD c)
  94 {
  95         characts_t *cp = (characts_t *)xmalloc(sizeof(characts_t));
  96         *cp = c;
  97         return cp;
  98 }
  99
 100 language_t *new_language(int id, int sub)
 101 {
 102         language_t *lan = (language_t *)xmalloc(sizeof(language_t));
 103         lan->id = id;
 104         lan->sub = sub;
 105         return lan;
 106 }
 107
 108 language_t *dup_language(language_t *l)
 109 {
 110         if(!l) return NULL;
 111         return new_language(l->id, l->sub);
 112 }
 113
 114 version_t *dup_version(version_t *v)
 115 {
 116         if(!v) return NULL;
 117         return new_version(*v);
 118 }
 119
 120 characts_t *dup_characts(characts_t *c)
 121 {
 122         if(!c) return NULL;
 123         return new_characts(*c);
 124 }
 125
 126 rcdata_t *new_rcdata(raw_data_t *rd, int *memopt)
 127 {
 128         rcdata_t *rc = (rcdata_t *)xmalloc(sizeof(rcdata_t));
 129         rc->data = rd;
 130         if(memopt)
 131         {
 132                 rc->memopt = *memopt;
 133                 free(memopt);
 134         }
 135         else
 136                 rc->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
 137         return rc;
 138 }
 139
 140 font_id_t *new_font_id(int size, string_t *face, int weight, int italic)
 141 {
 142         font_id_t *fid = (font_id_t *)xmalloc(sizeof(font_id_t));
 143         fid->name = face;
 144         fid->size = size;
 145         fid->weight = weight;
 146         fid->italic = italic;
 147         return fid;
 148 }
 149
 150 user_t *new_user(name_id_t *type, raw_data_t *rd, int *memopt)
 151 {
 152         user_t *usr = (user_t *)xmalloc(sizeof(user_t));
 153         usr->data = rd;
 154         if(memopt)
 155         {
 156                 usr->memopt = *memopt;
 157                 free(memopt);
 158         }
 159         else
 160                 usr->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
 161         usr->type = type;
 162         return usr;
 163 }
 164
 165 font_t *new_font(raw_data_t *rd, int *memopt)
 166 {
 167         font_t *fnt = (font_t *)xmalloc(sizeof(font_t));
 168         fnt->data = rd;
 169         if(memopt)
 170         {
 171                 fnt->memopt = *memopt;
 172                 free(memopt);
 173         }
 174         else
 175                 fnt->memopt = WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE;
 176         return fnt;
 177 }
 178
 179 fontdir_t *new_fontdir(raw_data_t *rd, int *memopt)
 180 {
 181         fontdir_t *fnd = (fontdir_t *)xmalloc(sizeof(fontdir_t));
 182         fnd->data = rd;
 183         if(memopt)
 184         {
 185                 fnd->memopt = *memopt;
 186                 free(memopt);
 187         }
 188         else
 189                 fnd->memopt = WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE;
 190         return fnd;
 191 }
 192
 193
 194 /*
 195  * Convert bitmaps to proper endian
 196  */
 197 static void convert_bitmap_swap_v3(BITMAPINFOHEADER *bih)
 198 {
 199         bih->biSize             = BYTESWAP_DWORD(bih->biSize);
 200         bih->biWidth            = BYTESWAP_DWORD(bih->biWidth);
 201         bih->biHeight           = BYTESWAP_DWORD(bih->biHeight);
 202         bih->biPlanes           = BYTESWAP_WORD(bih->biPlanes);
 203         bih->biBitCount         = BYTESWAP_WORD(bih->biBitCount);
 204         bih->biCompression      = BYTESWAP_DWORD(bih->biCompression);
 205         bih->biSizeImage        = BYTESWAP_DWORD(bih->biSizeImage);
 206         bih->biXPelsPerMeter    = BYTESWAP_DWORD(bih->biXPelsPerMeter);
 207         bih->biYPelsPerMeter    = BYTESWAP_DWORD(bih->biYPelsPerMeter);
 208         bih->biClrUsed          = BYTESWAP_DWORD(bih->biClrUsed);
 209         bih->biClrImportant     = BYTESWAP_DWORD(bih->biClrImportant);
 210 }
 211
 212 static void convert_bitmap_swap_v4(BITMAPV4HEADER *b4h)
 213 {
 214         convert_bitmap_swap_v3((BITMAPINFOHEADER *)b4h);
 215         b4h->bV4RedMask         = BYTESWAP_DWORD(b4h->bV4RedMask);
 216         b4h->bV4GreenMask       = BYTESWAP_DWORD(b4h->bV4GreenMask);
 217         b4h->bV4BlueMask        = BYTESWAP_DWORD(b4h->bV4BlueMask);
 218         b4h->bV4AlphaMask       = BYTESWAP_DWORD(b4h->bV4AlphaMask);
 219         b4h->bV4CSType          = BYTESWAP_DWORD(b4h->bV4CSType);
 220         b4h->bV4Endpoints.ciexyzRed.ciexyzX     = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzRed.ciexyzX);
 221         b4h->bV4Endpoints.ciexyzRed.ciexyzY     = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzRed.ciexyzY);
 222         b4h->bV4Endpoints.ciexyzRed.ciexyzZ     = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzRed.ciexyzZ);
 223         b4h->bV4Endpoints.ciexyzGreen.ciexyzX   = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzGreen.ciexyzX);
 224         b4h->bV4Endpoints.ciexyzGreen.ciexyzY   = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzGreen.ciexyzY);
 225         b4h->bV4Endpoints.ciexyzGreen.ciexyzZ   = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzGreen.ciexyzZ);
 226         b4h->bV4Endpoints.ciexyzBlue.ciexyzX    = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzBlue.ciexyzX);
 227         b4h->bV4Endpoints.ciexyzBlue.ciexyzY    = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzBlue.ciexyzY);
 228         b4h->bV4Endpoints.ciexyzBlue.ciexyzZ    = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzBlue.ciexyzZ);
 229         b4h->bV4GammaRed        = BYTESWAP_DWORD(b4h->bV4GammaRed);
 230         b4h->bV4GammaGreen      = BYTESWAP_DWORD(b4h->bV4GammaGreen);
 231         b4h->bV4GammaBlue       = BYTESWAP_DWORD(b4h->bV4GammaBlue);
 232 }
 233
 234 static void convert_bitmap_swap_os2(BITMAPOS2HEADER *boh)
 235 {
 236         boh->biSize             = BYTESWAP_DWORD(boh->biSize);
 237         boh->biWidth            = BYTESWAP_WORD(boh->biWidth);
 238         boh->biHeight           = BYTESWAP_WORD(boh->biHeight);
 239         boh->biPlanes           = BYTESWAP_WORD(boh->biPlanes);
 240         boh->biBitCount         = BYTESWAP_WORD(boh->biBitCount);
 241 }
 242
 243 #define FL_SIGBE        0x01
 244 #define FL_SIZEBE       0x02
 245 #define FL_V4           0x04
 246 #define FL_OS2          0x08
 247 static int convert_bitmap(char *data, int size)
 248 {
 249         BITMAPINFOHEADER *bih = (BITMAPINFOHEADER *)data;
 250         BITMAPV4HEADER *b4h = (BITMAPV4HEADER *)data;
 251         BITMAPOS2HEADER *boh = (BITMAPOS2HEADER *)data;
 252         int type = 0;
 253         int returnSize = 0;           /* size to be returned */
 254 #ifdef WORDS_BIGENDIAN
 255         DWORD bisizel = BYTESWAP_DWORD(sizeof(BITMAPINFOHEADER));
 256         DWORD b4sizel = BYTESWAP_DWORD(sizeof(BITMAPV4HEADER));
 257         DWORD bosizel = BYTESWAP_DWORD(sizeof(BITMAPOS2HEADER));
 258         DWORD bisizeb = sizeof(BITMAPINFOHEADER);
 259         DWORD b4sizeb = sizeof(BITMAPV4HEADER);
 260         DWORD bosizeb = sizeof(BITMAPOS2HEADER);
 261 #else
 262         DWORD bisizel = sizeof(BITMAPINFOHEADER);
 263         DWORD b4sizel = sizeof(BITMAPV4HEADER);
 264         DWORD bosizel = sizeof(BITMAPOS2HEADER);
 265         DWORD bisizeb = BYTESWAP_DWORD(sizeof(BITMAPINFOHEADER));
 266         DWORD b4sizeb = BYTESWAP_DWORD(sizeof(BITMAPV4HEADER));
 267         DWORD bosizeb = BYTESWAP_DWORD(sizeof(BITMAPOS2HEADER));
 268 #endif
 269
 270
 271     /*
 272      * Originally the bih and b4h pointers were simply incremented here,
 273      * and memmoved at the end of the function.  This causes alignment
 274      * issues on solaris, so we do the memmove here rather than at the end.
 275      */
 276         if(data[0] == 'B' && data[1] == 'M')
 277         {
 278                 /* Little endian signature */
 279          memmove(data, data+sizeof(BITMAPFILEHEADER), size - sizeof(BITMAPFILEHEADER));
 280          returnSize = sizeof(BITMAPFILEHEADER);
 281         }
 282         else if(data[0] == 'M' && data[1] == 'B')
 283         {
 284                 type |= FL_SIGBE;       /* Big endian signature */
 285          memmove(data, data+sizeof(BITMAPFILEHEADER), size - sizeof(BITMAPFILEHEADER));
 286          returnSize = sizeof(BITMAPFILEHEADER);
 287
 288         }
 289
 290         if(bih->biSize == bisizel)
 291         {
 292                 /* Little endian */
 293         }
 294         else if(bih->biSize == bisizeb)
 295         {
 296                 type |= FL_SIZEBE;
 297         }
 298         else if(bih->biSize == b4sizel)
 299         {
 300                 type |= FL_V4;
 301         }
 302         else if(bih->biSize == b4sizeb)
 303         {
 304                 type |= FL_SIZEBE | FL_V4;
 305         }
 306         else if(!bih->biSize || bih->biSize == bosizel)
 307         {
 308                 type |= FL_OS2;
 309         }
 310         else if(bih->biSize == bosizeb)
 311         {
 312                 type |= FL_SIZEBE | FL_OS2;
 313         }
 314         else
 315                 yyerror("Invalid bitmap format, bih->biSize = %ld", bih->biSize);
 316
 317         switch(type)
 318         {
 319         default:
 320                 break;
 321         case FL_SIZEBE:
 322         case FL_SIZEBE | FL_V4:
 323         case FL_SIZEBE | FL_OS2:
 324                 yywarning("Bitmap v%c signature little-endian, but size big-endian", type & FL_V4 ? '4' : '3');
 325                 break;
 326         case FL_SIGBE:
 327         case FL_SIGBE | FL_V4:
 328         case FL_SIGBE | FL_OS2:
 329                 yywarning("Bitmap v%c signature big-endian, but size little-endian", type & FL_V4 ? '4' : '3');
 330                 break;
 331         }
 332
 333         switch(byteorder)
 334         {
 335 #ifdef WORDS_BIGENDIAN
 336         default:
 337 #endif
 338         case WRC_BO_BIG:
 339                 if(!(type & FL_SIZEBE))
 340                 {
 341                         if(type & FL_V4)
 342                                 convert_bitmap_swap_v4(b4h);
 343                         else if(type & FL_OS2)
 344                         {
 345                                 convert_bitmap_swap_os2(boh);
 346                         }
 347                         else
 348                                 convert_bitmap_swap_v3(bih);
 349                 }
 350                 break;
 351 #ifndef WORDS_BIGENDIAN
 352         default:
 353 #endif
 354         case WRC_BO_LITTLE:
 355                 if(type & FL_SIZEBE)
 356                 {
 357                         if(type & FL_V4)
 358                                 convert_bitmap_swap_v4(b4h);
 359                         else if(type & FL_OS2)
 360                         {
 361                                 convert_bitmap_swap_os2(boh);
 362                         }
 363                         else
 364                                 convert_bitmap_swap_v3(bih);
 365                 }
 366                 break;
 367         }
 368
 369         if(size && (void *)data != (void *)bih)
 370         {
 371                 /* We have the fileheader still attached, remove it */
 372                 memmove(data, data+sizeof(BITMAPFILEHEADER), size - sizeof(BITMAPFILEHEADER));
 373                 return sizeof(BITMAPFILEHEADER);
 374         }
 375     return returnSize;
 376 }
 377 #undef FL_SIGBE
 378 #undef FL_SIZEBE
 379 #undef FL_V4
 380
 381 /*
 382  * Cursor and icon splitter functions used when allocating
 383  * cursor- and icon-groups.
 384  */
 385 typedef struct {
 386         language_t      lan;
 387         int             id;
 388 } id_alloc_t;
 389
 390 static int get_new_id(id_alloc_t **list, int *n, language_t *lan)
 391 {
 392         int i;
 393         assert(lan != NULL);
 394         assert(list != NULL);
 395         assert(n != NULL);
 396
 397         if(!*list)
 398         {
 399                 *list = (id_alloc_t *)xmalloc(sizeof(id_alloc_t));
 400                 *n = 1;
 401                 (*list)[0].lan = *lan;
 402                 (*list)[0].id = 1;
 403                 return 1;
 404         }
 405
 406         for(i = 0; i < *n; i++)
 407         {
 408                 if((*list)[i].lan.id == lan->id && (*list)[i].lan.sub == lan->sub)
 409                         return ++((*list)[i].id);
 410         }
 411
 412         *list = (id_alloc_t *)xrealloc(*list, sizeof(id_alloc_t) * (*n+1));
 413         (*list)[*n].lan = *lan;
 414         (*list)[*n].id = 1;
 415         *n += 1;
 416         return 1;
 417 }
 418
 419 static int alloc_icon_id(language_t *lan)
 420 {
 421         static id_alloc_t *idlist = NULL;
 422         static int nid = 0;
 423
 424         return get_new_id(&idlist, &nid, lan);
 425 }
 426
 427 static int alloc_cursor_id(language_t *lan)
 428 {
 429         static id_alloc_t *idlist = NULL;
 430         static int nid = 0;
 431
 432         return get_new_id(&idlist, &nid, lan);
 433 }
 434
 435 static void split_icons(raw_data_t *rd, icon_group_t *icog, int *nico)
 436 {
 437         int cnt;
 438         int i;
 439         icon_t *ico;
 440         icon_t *list = NULL;
 441         icon_header_t *ih = (icon_header_t *)rd->data;
 442         int swap = 0;
 443
 444         if(ih->type == 1)
 445                 swap = 0;
 446         else if(BYTESWAP_WORD(ih->type) == 1)
 447                 swap = 1;
 448         else
 449                 yyerror("Icon resource data has invalid type id %d", ih->type);
 450
 451         cnt = swap ? BYTESWAP_WORD(ih->count) : ih->count;
 452         for(i = 0; i < cnt; i++)
 453         {
 454                 icon_dir_entry_t ide;
 455                 BITMAPINFOHEADER info;
 456                 memcpy(&ide, rd->data + sizeof(icon_header_t)
 457                                       + i*sizeof(icon_dir_entry_t), sizeof(ide));
 458
 459                 ico = new_icon();
 460                 ico->id = alloc_icon_id(icog->lvc.language);
 461                 ico->lvc = icog->lvc;
 462                 if(swap)
 463                 {
 464                         ide.offset = BYTESWAP_DWORD(ide.offset);
 465                         ide.ressize= BYTESWAP_DWORD(ide.ressize);
 466                 }
 467                 if(ide.offset > rd->size
 468                 || ide.offset + ide.ressize > rd->size)
 469                         yyerror("Icon resource data corrupt");
 470                 ico->width = ide.width;
 471                 ico->height = ide.height;
 472                 ico->nclr = ide.nclr;
 473                 ico->planes = swap ? BYTESWAP_WORD(ide.planes) : ide.planes;
 474                 ico->bits = swap ? BYTESWAP_WORD(ide.bits) : ide.bits;
 475                 memcpy(&info, rd->data + ide.offset, sizeof(info));
 476          convert_bitmap((char *) &info, 0);
 477          memcpy(rd->data + ide.offset, &info, sizeof(info));
 478
 479                 if(!ico->planes)
 480                 {
 481                         /* Argh! They did not fill out the resdir structure */
 482                         /* The bitmap is in destination byteorder. We want native for our structures */
 483                         switch(byteorder)
 484                         {
 485 #ifdef WORDS_BIGENDIAN
 486                         case WRC_BO_LITTLE:
 487 #else
 488                         case WRC_BO_BIG:
 489 #endif
 490                                 ico->planes = BYTESWAP_WORD(info.biPlanes);
 491                                 break;
 492                         default:
 493                                 ico->planes = info.biPlanes;
 494                         }
 495                 }
 496                 if(!ico->bits)
 497                 {
 498                         /* Argh! They did not fill out the resdir structure */
 499                         /* The bitmap is in destination byteorder. We want native for our structures */
 500                         switch(byteorder)
 501                         {
 502 #ifdef WORDS_BIGENDIAN
 503                         case WRC_BO_LITTLE:
 504 #else
 505                         case WRC_BO_BIG:
 506 #endif
 507                                 ico->bits = BYTESWAP_WORD(info.biBitCount);
 508                                 break;
 509                         default:
 510                                 ico->bits = info.biBitCount;
 511                         }
 512                 }
 513                 ico->data = new_raw_data();
 514                 copy_raw_data(ico->data, rd, ide.offset, ide.ressize);
 515                 if(!list)
 516                 {
 517                         list = ico;
 518                 }
 519                 else
 520                 {
 521                         ico->next = list;
 522                         list->prev = ico;
 523                         list = ico;
 524                 }
 525         }
 526         icog->iconlist = list;
 527         *nico = cnt;
 528 }
 529
 530 static void split_cursors(raw_data_t *rd, cursor_group_t *curg, int *ncur)
 531 {
 532         int cnt;
 533         int i;
 534         cursor_t *cur;
 535         cursor_t *list = NULL;
 536         cursor_header_t *ch = (cursor_header_t *)rd->data;
 537         int swap = 0;
 538
 539         if(ch->type == 2)
 540                 swap = 0;
 541         else if(BYTESWAP_WORD(ch->type) == 2)
 542                 swap = 1;
 543         else
 544                 yyerror("Cursor resource data has invalid type id %d", ch->type);
 545         cnt = swap ? BYTESWAP_WORD(ch->count) : ch->count;
 546         for(i = 0; i < cnt; i++)
 547         {
 548                 cursor_dir_entry_t cde;
 549                 BITMAPINFOHEADER info;
 550                 memcpy(&cde, rd->data + sizeof(cursor_header_t)
 551                                       + i*sizeof(cursor_dir_entry_t), sizeof(cde));
 552
 553                 cur = new_cursor();
 554                 cur->id = alloc_cursor_id(curg->lvc.language);
 555                 cur->lvc = curg->lvc;
 556                 if(swap)
 557                 {
 558                         cde.offset = BYTESWAP_DWORD(cde.offset);
 559                         cde.ressize= BYTESWAP_DWORD(cde.ressize);
 560                 }
 561                 if(cde.offset > rd->size
 562                 || cde.offset + cde.ressize > rd->size)
 563                         yyerror("Cursor resource data corrupt");
 564                 cur->width = cde.width;
 565                 cur->height = cde.height;
 566                 cur->nclr = cde.nclr;
 567                 memcpy(&info, rd->data + cde.offset, sizeof(info));
 568          convert_bitmap((char *)&info, 0);
 569          memcpy(rd->data + cde.offset, &info, sizeof(info));
 570                 /* The bitmap is in destination byteorder. We want native for our structures */
 571                 switch(byteorder)
 572                 {
 573 #ifdef WORDS_BIGENDIAN
 574                 case WRC_BO_LITTLE:
 575 #else
 576                 case WRC_BO_BIG:
 577 #endif
 578                         cur->planes = BYTESWAP_WORD(info.biPlanes);
 579                         cur->bits = BYTESWAP_WORD(info.biBitCount);
 580                         break;
 581                 default:
 582                         cur->planes = info.biPlanes;
 583                         cur->bits = info.biBitCount;
 584                 }
 585                 if(!win32 && (cur->planes != 1 || cur->bits != 1))
 586                         yywarning("Win16 cursor contains colors");
 587                 cur->xhot = swap ? BYTESWAP_WORD(cde.xhot) : cde.xhot;
 588                 cur->yhot = swap ? BYTESWAP_WORD(cde.yhot) : cde.yhot;
 589                 cur->data = new_raw_data();
 590                 copy_raw_data(cur->data, rd, cde.offset, cde.ressize);
 591                 if(!list)
 592                 {
 593                         list = cur;
 594                 }
 595                 else
 596                 {
 597                         cur->next = list;
 598                         list->prev = cur;
 599                         list = cur;
 600                 }
 601         }
 602         curg->cursorlist = list;
 603         *ncur = cnt;
 604 }
 605
 606
 607 icon_group_t *new_icon_group(raw_data_t *rd, int *memopt)
 608 {
 609         icon_group_t *icog = (icon_group_t *)xmalloc(sizeof(icon_group_t));
 610         if(memopt)
 611         {
 612                 icog->memopt = *memopt;
 613                 free(memopt);
 614         }
 615         else
 616                 icog->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE | WRC_MO_DISCARDABLE;
 617         icog->lvc = rd->lvc;
 618         split_icons(rd, icog, &(icog->nicon));
 619         free(rd->data);
 620         free(rd);
 621         return icog;
 622 }
 623
 624 cursor_group_t *new_cursor_group(raw_data_t *rd, int *memopt)
 625 {
 626         cursor_group_t *curg = (cursor_group_t *)xmalloc(sizeof(cursor_group_t));
 627         if(memopt)
 628         {
 629                 curg->memopt = *memopt;
 630                 free(memopt);
 631         }
 632         else
 633                 curg->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE | WRC_MO_DISCARDABLE;
 634         curg->lvc = rd->lvc;
 635         split_cursors(rd, curg, &(curg->ncursor));
 636         free(rd->data);
 637         free(rd);
 638         return curg;
 639 }
 640
 641 /*
 642  * Animated cursors and icons
 643  *
 644  * The format of animated cursors and icons is yet another example
 645  * of bad design by "The Company". The entire RIFF structure is
 646  * flawed by design because it is inconsistent and single minded:
 647  * - some tags have lengths attached, others don't. The use of these
 648  *   non-length tags is absolutely unclear;
 649  * - the content of "icon" tags can be both icons and cursors;
 650  * - tags lack proper alignment constraints. It seems that everything
 651  *   is 16bit aligned, but I could not find that in any docu. Just be
 652  *   prepared to eat anything;
 653  * - there are no strict constraints on tag-nesting and the organization
 654  *   is highly illogical;
 655  *
 656  * Anyhow, here is the basic structure:
 657  * "RIFF" { dword taglength }
 658  *      "ACON"                                  // What does it do?
 659  *      "LIST" { dword taglength }
 660  *              "INFO"                          // And what does this do?
 661  *              "INAM" { dword taglength }      // Icon/cursor name
 662  *                      {inam data}
 663  *              "IART" { dword taglength }      // The artist
 664  *                      {iart data}
 665  *              "fram"                          // Is followed by "icon"s
 666  *              "icon" { dword taglength }      // First frame
 667  *                      { icon/cursor data }
 668  *              "icon" { dword taglength }      // Second frame
 669  *                      { icon/cursor data }
 670  *                      ...                     // ...
 671  *      "anih" { dword taglength }              // Header structure
 672  *              { aniheader_t structure }
 673  *      "rate" { dword taglength }              // The rate for each frame
 674  *              { `steps' dwords }
 675  *      "seq " { dword taglength }              // The frame blit-order
 676  *              { `steps' dwords }
 677  *
 678  * Tag length are bytelength without the header and length field (i.e. -8).
 679  * The "LIST" tag may occur several times and may encapsulate different
 680  * tags. The `steps' is the number of "icon" tags found (actually the
 681  * number of steps specified in the aniheader_t structure). The "seq "uence
 682  * tag can be omitted, in which case the sequence is equal to the sequence
 683  * of "icon"s found in the file. Also "rate" may be omitted, in which case
 684  * the default from the aniheader_t structure is used.
 685  *
 686  * An animated cursor puts `.cur' formatted files into each "icon" tag,
 687  * whereas animated icons contain `.ico' formatted files.
 688  *
 689  * Note about the code: Yes, it can be shorter/compressed. Some tags can be
 690  * dealt with in the same code. However, this version shows what is going on
 691  * and is better debug-able.
 692  */
 693 static const char riff[4] = "RIFF";
 694 static const char acon[4] = "ACON";
 695 static const char list[4] = "LIST";
 696 static const char info[4] = "INFO";
 697 static const char inam[4] = "INAM";
 698 static const char iart[4] = "IART";
 699 static const char fram[4] = "fram";
 700 static const char icon[4] = "icon";
 701 static const char anih[4] = "anih";
 702 static const char rate[4] = "rate";
 703 static const char seq[4]  = "seq ";
 704
 705 #define SKIP_TAG(p,size)        ((riff_tag_t *)(((char *)p) + (size)))
 706
 707 #define NEXT_TAG(p)     SKIP_TAG(p,(isswapped ? BYTESWAP_DWORD(p->size) : p->size) + sizeof(*p))
 708
 709 static void handle_ani_icon(riff_tag_t *rtp, enum res_e type, int isswapped)
 710 {
 711         cursor_dir_entry_t *cdp;
 712         cursor_header_t *chp;
 713         int count;
 714         int ctype;
 715         int i;
 716         static int once = 0;    /* This will trigger only once per file! */
 717         const char *anistr = type == res_aniico ? "icon" : "cursor";
 718         /* Notes:
 719          * Both cursor and icon directories are similar
 720          * Both cursor and icon headers are similar
 721          */
 722
 723         chp = (cursor_header_t *)(rtp+1);
 724         cdp = (cursor_dir_entry_t *)(chp+1);
 725         count = isswapped ? BYTESWAP_WORD(chp->count) : chp->count;
 726         ctype = isswapped ? BYTESWAP_WORD(chp->type) : chp->type;
 727         chp->reserved   = BYTESWAP_WORD(chp->reserved);
 728         chp->type       = BYTESWAP_WORD(chp->type);
 729         chp->count      = BYTESWAP_WORD(chp->count);
 730
 731         if(type == res_anicur && ctype != 2 && !once)
 732         {
 733                 yywarning("Animated cursor contains invalid \"icon\" tag cursor-file (%d->%s)",
 734                                 ctype,
 735                                 ctype == 1 ? "icontype" : "?");
 736                 once++;
 737         }
 738         else if(type == res_aniico && ctype != 1 && !once)
 739         {
 740                 yywarning("Animated icon contains invalid \"icon\" tag icon-file (%d->%s)",
 741                                 ctype,
 742                                 ctype == 2 ? "cursortype" : "?");
 743                 once++;
 744         }
 745         else if(ctype != 1 && ctype != 2 && !once)
 746         {
 747                 yywarning("Animated %s contains invalid \"icon\" tag file-type (%d; neither icon nor cursor)", anistr, ctype);
 748                 once++;
 749         }
 750
 751         for(i = 0; i < count; i++)
 752         {
 753                 DWORD ofs = isswapped ? BYTESWAP_DWORD(cdp[i].offset) : cdp[i].offset;
 754                 DWORD sze = isswapped ? BYTESWAP_DWORD(cdp[i].ressize) : cdp[i].ressize;
 755                 if(ofs > rtp->size || ofs+sze > rtp->size)
 756                         yyerror("Animated %s's data corrupt", anistr);
 757                 convert_bitmap((char *)chp + ofs, 0);
 758                 cdp[i].xhot     = BYTESWAP_WORD(cdp->xhot);
 759                 cdp[i].yhot     = BYTESWAP_WORD(cdp->yhot);
 760                 cdp[i].ressize  = BYTESWAP_DWORD(cdp->ressize);
 761                 cdp[i].offset   = BYTESWAP_DWORD(cdp->offset);
 762         }
 763 }
 764
 765 static void handle_ani_list(riff_tag_t *lst, enum res_e type, int isswapped)
 766 {
 767         riff_tag_t *rtp = lst+1;        /* Skip the "LIST" tag */
 768
 769         while((char *)rtp < (char *)lst + lst->size + sizeof(*lst))
 770         {
 771                 if(!memcmp(rtp->tag, info, sizeof(info)))
 772                 {
 773                         rtp = SKIP_TAG(rtp,4);
 774                 }
 775                 else if(!memcmp(rtp->tag, inam, sizeof(inam)))
 776                 {
 777                         /* Ignore the icon/cursor name; its a string */
 778                         rtp = NEXT_TAG(rtp);
 779                 }
 780                 else if(!memcmp(rtp->tag, iart, sizeof(iart)))
 781                 {
 782                         /* Ignore the author's name; its a string */
 783                         rtp = NEXT_TAG(rtp);
 784                 }
 785                 else if(!memcmp(rtp->tag, fram, sizeof(fram)))
 786                 {
 787                         /* This should be followed by "icon"s, but we
 788                          * simply ignore this because it is pure
 789                          * non-information.
 790                          */
 791                         rtp = SKIP_TAG(rtp,4);
 792                 }
 793                 else if(!memcmp(rtp->tag, icon, sizeof(icon)))
 794                 {
 795                         handle_ani_icon(rtp, type, isswapped);
 796                         rtp = NEXT_TAG(rtp);
 797                 }
 798                 else
 799                         internal_error(__FILE__, __LINE__, "Unknown tag \"%c%c%c%c\" in RIFF file",
 800                                        isprint(rtp->tag[0]) ? rtp->tag[0] : '.',
 801                                        isprint(rtp->tag[1]) ? rtp->tag[1] : '.',
 802                                        isprint(rtp->tag[2]) ? rtp->tag[2] : '.',
 803                                        isprint(rtp->tag[3]) ? rtp->tag[3] : '.');
 804
 805                 /* FIXME: This relies in sizeof(DWORD) == sizeof(pointer_type) */
 806                 if((DWORD)rtp & 1)
 807                         rtp = SKIP_TAG(rtp,1);
 808         }
 809 }
 810
 811 ani_curico_t *new_ani_curico(enum res_e type, raw_data_t *rd, int *memopt)
 812 {
 813         ani_curico_t *ani = (ani_curico_t *)xmalloc(sizeof(ani_curico_t));
 814         riff_tag_t *rtp;
 815         int isswapped = 0;
 816         int doswap;
 817         const char *anistr = type == res_aniico ? "icon" : "cursor";
 818
 819         assert(!memcmp(rd->data, riff, sizeof(riff)));
 820         assert(type == res_anicur || type == res_aniico);
 821
 822         rtp = (riff_tag_t *)rd->data;
 823
 824         if(BYTESWAP_DWORD(rtp->size) + 2*sizeof(DWORD) == rd->size)
 825                 isswapped = 1;
 826         else if(rtp->size + 2*sizeof(DWORD) == rd->size)
 827                 isswapped = 0;
 828         else
 829                 yyerror("Animated %s has an invalid RIFF length", anistr);
 830
 831         switch(byteorder)
 832         {
 833 #ifdef WORDS_BIGENDIAN
 834         case WRC_BO_LITTLE:
 835 #else
 836         case WRC_BO_BIG:
 837 #endif
 838                 doswap = !isswapped;
 839                 break;
 840         default:
 841                 doswap = isswapped;
 842         }
 843
 844         /*
 845          * When to swap what:
 846          * isswapped | doswap |
 847          * ----------+--------+---------------------------------
 848          *     0     |    0   | read native; don't convert
 849          *     1     |    0   | read swapped size; don't convert
 850          *     0     |    1   | read native; convert
 851          *     1     |    1   | read swapped size; convert
 852          * Reading swapped size if necessary to calculate in native
 853          * format. E.g. a little-endian source on a big-endian
 854          * processor.
 855          */
 856         if(doswap)
 857         {
 858                 /* We only go through the RIFF file if we need to swap
 859                  * bytes in words/dwords. Else we couldn't care less
 860                  * what the file contains. This is consistent with
 861                  * MS' rc.exe, which doesn't complain at all, eventhough
 862                  * the fileformat might not be entirely correct.
 863                  */
 864                 rtp++;  /* Skip the "RIFF" tag */
 865
 866                 while((char *)rtp < (char *)rd->data + rd->size)
 867                 {
 868                         if(!memcmp(rtp->tag, acon, sizeof(acon)))
 869                         {
 870                                 rtp = SKIP_TAG(rtp,4);
 871                         }
 872                         else if(!memcmp(rtp->tag, list, sizeof(list)))
 873                         {
 874                                 handle_ani_list(rtp, type, isswapped);
 875                                 rtp = NEXT_TAG(rtp);
 876                         }
 877                         else if(!memcmp(rtp->tag, anih, sizeof(anih)))
 878                         {
 879                                 aniheader_t *ahp = (aniheader_t *)((char *)(rtp+1));
 880                                 ahp->structsize = BYTESWAP_DWORD(ahp->structsize);
 881                                 ahp->frames     = BYTESWAP_DWORD(ahp->frames);
 882                                 ahp->steps      = BYTESWAP_DWORD(ahp->steps);
 883                                 ahp->cx         = BYTESWAP_DWORD(ahp->cx);
 884                                 ahp->cy         = BYTESWAP_DWORD(ahp->cy);
 885                                 ahp->bitcount   = BYTESWAP_DWORD(ahp->bitcount);
 886                                 ahp->planes     = BYTESWAP_DWORD(ahp->planes);
 887                                 ahp->rate       = BYTESWAP_DWORD(ahp->rate);
 888                                 ahp->flags      = BYTESWAP_DWORD(ahp->flags);
 889                                 rtp = NEXT_TAG(rtp);
 890                         }
 891                         else if(!memcmp(rtp->tag, rate, sizeof(rate)))
 892                         {
 893                                 int cnt = rtp->size / sizeof(DWORD);
 894                                 DWORD *dwp = (DWORD *)(rtp+1);
 895                                 int i;
 896                                 for(i = 0; i < cnt; i++)
 897                                         dwp[i] = BYTESWAP_DWORD(dwp[i]);
 898                                 rtp = NEXT_TAG(rtp);
 899                         }
 900                         else if(!memcmp(rtp->tag, seq, sizeof(seq)))
 901                         {
 902                                 int cnt = rtp->size / sizeof(DWORD);
 903                                 DWORD *dwp = (DWORD *)(rtp+1);
 904                                 int i;
 905                                 for(i = 0; i < cnt; i++)
 906                                         dwp[i] = BYTESWAP_DWORD(dwp[i]);
 907                                 rtp = NEXT_TAG(rtp);
 908                         }
 909                         else
 910                                 internal_error(__FILE__, __LINE__, "Unknown tag \"%c%c%c%c\" in RIFF file",
 911                                        isprint(rtp->tag[0]) ? rtp->tag[0] : '.',
 912                                        isprint(rtp->tag[1]) ? rtp->tag[1] : '.',
 913                                        isprint(rtp->tag[2]) ? rtp->tag[2] : '.',
 914                                        isprint(rtp->tag[3]) ? rtp->tag[3] : '.');
 915
 916                         /* FIXME: This relies in sizeof(DWORD) == sizeof(pointer_type) */
 917                         if((DWORD)rtp & 1)
 918                                 rtp = SKIP_TAG(rtp,1);
 919                 }
 920
 921                 /* We must end correctly here */
 922                 if((char *)rtp != (char *)rd->data + rd->size)
 923                         yyerror("Animated %s contains invalid field size(s)", anistr);
 924         }
 925
 926         ani->data = rd;
 927         if(memopt)
 928         {
 929                 ani->memopt = *memopt;
 930                 free(memopt);
 931         }
 932         else
 933                 ani->memopt = WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE;
 934         return ani;
 935 }
 936 #undef NEXT_TAG
 937
 938 /* Bitmaps */
 939 bitmap_t *new_bitmap(raw_data_t *rd, int *memopt)
 940 {
 941         bitmap_t *bmp = (bitmap_t *)xmalloc(sizeof(bitmap_t));
 942
 943         bmp->data = rd;
 944         if(memopt)
 945         {
 946                 bmp->memopt = *memopt;
 947                 free(memopt);
 948         }
 949         else
 950                 bmp->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
 951         rd->size -= convert_bitmap(rd->data, rd->size);
 952         return bmp;
 953 }
 954
 955 ver_words_t *new_ver_words(int i)
 956 {
 957         ver_words_t *w = (ver_words_t *)xmalloc(sizeof(ver_words_t));
 958         w->words = (WORD *)xmalloc(sizeof(WORD));
 959         w->words[0] = (WORD)i;
 960         w->nwords = 1;
 961         return w;
 962 }
 963
 964 ver_words_t *add_ver_words(ver_words_t *w, int i)
 965 {
 966         w->words = (WORD *)xrealloc(w->words, (w->nwords+1) * sizeof(WORD));
 967         w->words[w->nwords] = (WORD)i;
 968         w->nwords++;
 969         return w;
 970 }
 971
 972 #define MSGTAB_BAD_PTR(p, b, l, r)      (((l) - ((char *)(p) - (char *)(b))) > (r))
 973 messagetable_t *new_messagetable(raw_data_t *rd, int *memopt)
 974 {
 975         messagetable_t *msg = (messagetable_t *)xmalloc(sizeof(messagetable_t));
 976         msgtab_block_t *mbp;
 977         DWORD nblk;
 978         DWORD i;
 979         WORD lo;
 980         WORD hi;
 981
 982         msg->data = rd;
 983         if(memopt)
 984         {
 985                 msg->memopt = *memopt;
 986                 free(memopt);
 987         }
 988         else
 989                 msg->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
 990
 991         if(rd->size < sizeof(DWORD))
 992                 yyerror("Invalid messagetable, size too small");
 993
 994         nblk = *(DWORD *)rd->data;
 995         lo = WRC_LOWORD(nblk);
 996         hi = WRC_HIWORD(nblk);
 997
 998         /* FIXME:
 999          * This test will fail for all n*2^16 blocks in the messagetable.
1000          * However, no sane person would want to have so many blocks
1001          * and have a table of megabytes attached.
1002          * So, I will assume that we have less than 2^16 blocks in the table
1003          * and all will just work out fine. Otherwise, we would need to test
1004          * the ID, offset and length (and flag) fields to be very sure.
1005          */
1006         if(hi && lo)
1007                 internal_error(__FILE__, __LINE__, "Messagetable contains more than 65535 blocks; cannot determine endian");
1008         if(!hi && !lo)
1009                 yyerror("Invalid messagetable block count 0");
1010
1011         if(!hi && lo)  /* Messagetable byteorder == native byteorder */
1012         {
1013 #ifdef WORDS_BIGENDIAN
1014                 if(byteorder != WRC_BO_LITTLE) goto out;
1015 #else
1016                 if(byteorder != WRC_BO_BIG) goto out;
1017 #endif
1018                 /* Resource byteorder != native byteorder */
1019
1020                 mbp = (msgtab_block_t *)&(((DWORD *)rd->data)[1]);
1021                 if(MSGTAB_BAD_PTR(mbp, rd->data, rd->size, nblk * sizeof(*mbp)))
1022                         yyerror("Messagetable's blocks are outside of defined data");
1023                 for(i = 0; i < nblk; i++)
1024                 {
1025                         msgtab_entry_t *mep, *next_mep;
1026                         DWORD id;
1027
1028                         mep = (msgtab_entry_t *)(((char *)rd->data) + mbp[i].offset);
1029
1030                         for(id = mbp[i].idlo; id <= mbp[i].idhi; id++)
1031                         {
1032                                 if(MSGTAB_BAD_PTR(mep, rd->data, rd->size, mep->length))
1033                                         yyerror("Messagetable's data for block %d, ID 0x%08lx is outside of defined data", (int)i, id);
1034                                 if(mep->flags == 1)     /* Docu says 'flags == 0x0001' for unicode */
1035                                 {
1036                                         WORD *wp = (WORD *)&mep[1];
1037                                         int l = mep->length/2 - 2; /* Length included header */
1038                                         int n;
1039
1040                                         if(mep->length & 1)
1041                                                 yyerror("Message 0x%08lx is unicode (block %d), but has odd length (%d)", id, (int)i, mep->length);
1042                                         for(n = 0; n < l; n++)
1043                                                 wp[n] = BYTESWAP_WORD(wp[n]);
1044
1045                                 }
1046                                 next_mep = (msgtab_entry_t *)(((char *)mep) + mep->length);
1047                                 mep->length = BYTESWAP_WORD(mep->length);
1048                                 mep->flags  = BYTESWAP_WORD(mep->flags);
1049                                 mep = next_mep;
1050                         }
1051
1052                         mbp[i].idlo   = BYTESWAP_DWORD(mbp[i].idlo);
1053                         mbp[i].idhi   = BYTESWAP_DWORD(mbp[i].idhi);
1054                         mbp[i].offset = BYTESWAP_DWORD(mbp[i].offset);
1055                 }
1056         }
1057         if(hi && !lo)  /* Messagetable byteorder != native byteorder */
1058         {
1059 #ifdef WORDS_BIGENDIAN
1060                 if(byteorder == WRC_BO_LITTLE) goto out;
1061 #else
1062                 if(byteorder == WRC_BO_BIG) goto out;
1063 #endif
1064                 /* Resource byteorder == native byteorder */
1065
1066                 mbp = (msgtab_block_t *)&(((DWORD *)rd->data)[1]);
1067                 nblk = BYTESWAP_DWORD(nblk);
1068                 if(MSGTAB_BAD_PTR(mbp, rd->data, rd->size, nblk * sizeof(*mbp)))
1069                         yyerror("Messagetable's blocks are outside of defined data");
1070                 for(i = 0; i < nblk; i++)
1071                 {
1072                         msgtab_entry_t *mep;
1073                         DWORD id;
1074
1075                         mbp[i].idlo   = BYTESWAP_DWORD(mbp[i].idlo);
1076                         mbp[i].idhi   = BYTESWAP_DWORD(mbp[i].idhi);
1077                         mbp[i].offset = BYTESWAP_DWORD(mbp[i].offset);
1078                         mep = (msgtab_entry_t *)(((char *)rd->data) + mbp[i].offset);
1079
1080                         for(id = mbp[i].idlo; id <= mbp[i].idhi; id++)
1081                         {
1082                                 mep->length = BYTESWAP_WORD(mep->length);
1083                                 mep->flags  = BYTESWAP_WORD(mep->flags);
1084
1085                                 if(MSGTAB_BAD_PTR(mep, rd->data, rd->size, mep->length))
1086                                         yyerror("Messagetable's data for block %d, ID 0x%08lx is outside of defined data", (int)i, id);
1087                                 if(mep->flags == 1)     /* Docu says 'flags == 0x0001' for unicode */
1088                                 {
1089                                         WORD *wp = (WORD *)&mep[1];
1090                                         int l = mep->length/2 - 2; /* Length included header */
1091                                         int n;
1092
1093                                         if(mep->length & 1)
1094                                                 yyerror("Message 0x%08lx is unicode (block %d), but has odd length (%d)", id, (int)i, mep->length);
1095                                         for(n = 0; n < l; n++)
1096                                                 wp[n] = BYTESWAP_WORD(wp[n]);
1097
1098                                 }
1099                                 mep = (msgtab_entry_t *)(((char *)mep) + mep->length);
1100                         }
1101                 }
1102         }
1103
1104  out:
1105         return msg;
1106 }
1107 #undef MSGTAB_BAD_PTR
1108
1109 void copy_raw_data(raw_data_t *dst, raw_data_t *src, unsigned int offs, int len)
1110 {
1111         assert(offs <= src->size);
1112         assert(offs + len <= src->size);
1113         if(!dst->data)
1114         {
1115                 dst->data = (char *)xmalloc(len);
1116                 dst->size = 0;
1117         }
1118         else
1119                 dst->data = (char *)xrealloc(dst->data, dst->size + len);
1120         /* dst->size holds the offset to copy to */
1121         memcpy(dst->data + dst->size, src->data + offs, len);
1122         dst->size += len;
1123 }
1124
1125 int *new_int(int i)
1126 {
1127         int *ip = (int *)xmalloc(sizeof(int));
1128         *ip = i;
1129         return ip;
1130 }
1131
1132 stringtable_t *new_stringtable(lvc_t *lvc)
1133 {
1134         stringtable_t *stt = (stringtable_t *)xmalloc(sizeof(stringtable_t));
1135
1136         if(lvc)
1137                 stt->lvc = *lvc;
1138
1139         return stt;
1140 }
1141
1142 toolbar_t *new_toolbar(int button_width, int button_height, toolbar_item_t *items, int nitems)
1143 {
1144         toolbar_t *tb = (toolbar_t *)xmalloc(sizeof(toolbar_t));
1145         tb->button_width = button_width;
1146         tb->button_height = button_height;
1147         tb->nitems = nitems;
1148         tb->items = items;
1149         return tb;
1150 }
1151
1152 dlginit_t *new_dlginit(raw_data_t *rd, int *memopt)
1153 {
1154         dlginit_t *di = (dlginit_t *)xmalloc(sizeof(dlginit_t));
1155         di->data = rd;
1156         if(memopt)
1157         {
1158                 di->memopt = *memopt;
1159                 free(memopt);
1160         }
1161         else
1162                 di->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE | WRC_MO_DISCARDABLE;
1163
1164         return di;
1165 }
1166
1167 style_pair_t *new_style_pair(style_t *style, style_t *exstyle)
1168 {
1169         style_pair_t *sp = (style_pair_t *)xmalloc(sizeof(style_pair_t));
1170         sp->style = style;
1171         sp->exstyle = exstyle;
1172         return sp;
1173 }
1174
1175 style_t *new_style(DWORD or_mask, DWORD and_mask)
1176 {
1177         style_t *st = (style_t *)xmalloc(sizeof(style_t));
1178         st->or_mask = or_mask;
1179         st->and_mask = and_mask;
1180         return st;
1181 }