tools/wrc/readres.c

   1 /*
   2  * Read a .res file and create 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
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <assert.h>
  28
  29 #include "wrc.h"
  30 #include "readres.h"
  31 #include "newstruc.h"
  32 #include "utils.h"
  33 #include "genres.h"
  34
  35 static const struct resheader32 {
  36         DWORD   ressize;        /* 0 */
  37         DWORD   hdrsize;        /* 0x20 */
  38         WORD    restype1;       /* 0xffff */
  39         WORD    restype2;       /* 0 */
  40         WORD    resname1;       /* 0xffff */
  41         WORD    resname2;       /* 0 */
  42         DWORD   dversion;       /* 0 */
  43         WORD    memopt;         /* 0 */
  44         WORD    language;       /* 0 */
  45         DWORD   version;        /* 0 */
  46         DWORD   characts;       /* 0 */
  47 } emptyheader           = {0, 0x20, 0xffff, 0, 0xffff, 0, 0, 0, 0, 0, 0},
  48   emptyheaderSWAPPED    = {0, BYTESWAP_DWORD(0x20), 0xffff, 0, 0xffff, 0, 0, 0, 0, 0, 0};
  49
  50 /*
  51  *****************************************************************************
  52  * Function     :
  53  * Syntax       :
  54  * Input        :
  55  * Output       :
  56  * Description  :
  57  * Remarks      :
  58  *****************************************************************************
  59 */
  60 /*
  61  *****************************************************************************
  62  * Function     :
  63  * Syntax       :
  64  * Input        :
  65  * Output       :
  66  * Description  :
  67  * Remarks      :
  68  *****************************************************************************
  69 */
  70 /*
  71  *****************************************************************************
  72  * Function     :
  73  * Syntax       :
  74  * Input        :
  75  * Output       :
  76  * Description  :
  77  * Remarks      :
  78  *****************************************************************************
  79 */
  80 static int read_data(FILE *fp, size_t size, void *buf)
  81 {
  82         unsigned int r;
  83         int pos = ftell(fp);
  84         r = fread(buf, 1, size, fp);
  85         if(r == size)
  86                 return 0;
  87         if(r == 0 && ftell(fp) - pos > 0)
  88                 return 1;
  89         else
  90                 return -1;
  91 }
  92
  93 /*
  94  *****************************************************************************
  95  * Function     :
  96  * Syntax       :
  97  * Input        :
  98  * Output       :
  99  * Description  :
 100  * Remarks      :
 101  *****************************************************************************
 102 */
 103 static enum res_e res_type_from_id(const name_id_t *nid)
 104 {
 105         if(nid->type == name_str)
 106                 return res_usr;
 107
 108         if(nid->type != name_ord)
 109                 internal_error(__FILE__, __LINE__, "Invalid name_id descriptor %d\n", nid->type);
 110
 111         switch(nid->name.i_name)
 112         {
 113         case WRC_RT_CURSOR:             return res_cur;
 114         case WRC_RT_BITMAP:             return res_bmp;
 115         case WRC_RT_ICON:               return res_ico;
 116         case WRC_RT_MENU:               return res_men;
 117         case WRC_RT_DIALOG:             return res_dlg;
 118         case WRC_RT_STRING:             return res_stt;
 119         case WRC_RT_FONTDIR:            return res_fntdir;
 120         case WRC_RT_FONT:               return res_fnt;
 121         case WRC_RT_ACCELERATOR:        return res_acc;
 122         case WRC_RT_RCDATA:             return res_rdt;
 123         case WRC_RT_MESSAGETABLE:       return res_msg;
 124         case WRC_RT_GROUP_CURSOR:       return res_curg;
 125         case WRC_RT_GROUP_ICON:         return res_icog;
 126         case WRC_RT_VERSION:            return res_ver;
 127         case WRC_RT_TOOLBAR:            return res_toolbar;
 128
 129         default:
 130         case WRC_RT_DLGINCLUDE:
 131         case WRC_RT_PLUGPLAY:
 132         case WRC_RT_VXD:
 133         case WRC_RT_ANICURSOR:
 134         case WRC_RT_ANIICON:
 135                 warning("Cannot be sure of resource type, using usertype settings\n");
 136                 return res_usr;
 137         }
 138 }
 139
 140 /*
 141  *****************************************************************************
 142  * Function     :
 143  * Syntax       :
 144  * Input        :
 145  * Output       :
 146  * Description  :
 147  * Remarks      :
 148  *****************************************************************************
 149 */
 150 #define get_word(idx)   (*((WORD *)(&res->data[idx])))
 151 #define get_dword(idx)  (*((DWORD *)(&res->data[idx])))
 152
 153 static resource_t *read_res32(FILE *fp)
 154 {
 155         static const char wrong_format[] = "Wrong resfile format (32bit)";
 156         DWORD ressize;
 157         DWORD hdrsize;
 158         DWORD totsize;
 159         WORD memopt;
 160         WORD language;
 161         int err;
 162         res_t *res;
 163         resource_t *rsc;
 164         resource_t *tail = NULL;
 165         resource_t *list = NULL;
 166         name_id_t *type = NULL;
 167         name_id_t *name = NULL;
 168         int idx;
 169         enum res_e res_type;
 170         user_t *usrres;
 171
 172         while(1)
 173         {
 174                 /* Get headersize and resource size */
 175                 err = read_data(fp, sizeof(ressize), &ressize);
 176                 if(err < 0)
 177                         break;
 178                 else if(err > 0)
 179                         error(wrong_format);
 180                 err = read_data(fp, sizeof(hdrsize), &hdrsize);
 181                 if(err)
 182                         error(wrong_format);
 183
 184                 /* Align sizes and compute total size */
 185                 totsize = hdrsize;
 186                 if(hdrsize & 3)
 187                 {
 188                         warning("Hu? .res header needed alignment (anything can happen now)\n");
 189                         totsize += 4 - (hdrsize & 3);
 190                 }
 191                 totsize += ressize;
 192                 if(ressize & 3)
 193                         totsize += 4 - (ressize & 3);
 194
 195                 /* Read in entire data-block */
 196                 fseek(fp, -8, SEEK_CUR);
 197                 res = new_res();
 198                 if(res->allocsize < totsize)
 199                         grow_res(res, totsize - res->allocsize + 8);
 200                 err = read_data(fp, totsize, res->data);
 201                 if(err)
 202                         error(wrong_format);
 203
 204                 res->dataidx = hdrsize;
 205                 res->size = hdrsize + ressize;
 206
 207                 /* Analyse the content of the header */
 208                 idx = 8;
 209                 /* Get restype */
 210                 if(get_word(idx) == 0xffff)
 211                 {
 212                         idx += sizeof(WORD);
 213                         type = new_name_id();
 214                         type->type = name_ord;
 215                         type->name.i_name = get_word(idx);
 216                         idx += sizeof(WORD);
 217                 }
 218                 else if(get_word(idx) == 0)
 219                 {
 220                         error("ResType name has zero length (32 bit)\n");
 221                 }
 222                 else
 223                 {
 224                         int tag = idx;
 225                         string_t *str;
 226                         while(1)
 227                         {
 228                                 idx += sizeof(WORD);
 229                                 if(!get_word(idx))
 230                                         break;
 231                         }
 232                         idx += sizeof(WORD);
 233                         str = new_string();
 234                         str->type = str_unicode;
 235                         str->size = (idx - tag) / 2;
 236                         str->str.wstr = xmalloc(idx-tag+2);
 237                         memcpy(str->str.wstr, &res->data[tag], idx-tag);
 238                         str->str.wstr[str->size] = 0;
 239                         type = new_name_id();
 240                         type->type = name_str;
 241                         type->name.s_name = str;
 242                 }
 243                 /* Get resname */
 244                 if(get_word(idx) == 0xffff)
 245                 {
 246                         idx += sizeof(WORD);
 247                         name = new_name_id();
 248                         name->type = name_ord;
 249                         name->name.i_name = get_word(idx);
 250                         idx += sizeof(WORD);
 251                 }
 252                 else if(get_word(idx) == 0)
 253                 {
 254                         error("ResName name has zero length (32 bit)\n");
 255                 }
 256                 else
 257                 {
 258                         int tag = idx;
 259                         string_t *str;
 260                         while(1)
 261                         {
 262                                 idx += sizeof(WORD);
 263                                 if(!get_word(idx))
 264                                         break;
 265                         }
 266                         idx += sizeof(WORD);
 267                         str = new_string();
 268                         str->type = str_unicode;
 269                         str->size = (idx - tag) / 2;
 270                         str->str.wstr = xmalloc(idx-tag+2);
 271                         memcpy(str->str.wstr, &res->data[tag], idx-tag);
 272                         str->str.wstr[str->size] = 0;
 273                         name = new_name_id();
 274                         name->type = name_str;
 275                         name->name.s_name = str;
 276                 }
 277
 278                 /* align */
 279                 if(idx & 0x3)
 280                         idx += 4 - (idx & 3);
 281
 282                 idx += sizeof(DWORD);   /* Skip DataVersion */
 283                 memopt = get_word(idx);
 284                 idx += sizeof(WORD);
 285                 language = get_word(idx);
 286
 287                 /* Build a resource_t list */
 288                 res_type = res_type_from_id(type);
 289                 if(res_type == res_usr)
 290                 {
 291                         /* User-type has custom ResType for .[s|h] generation */
 292                         usrres = new_user(type, NULL, new_int(memopt));
 293                 }
 294                 else
 295                 {
 296                         free (type);
 297                         usrres = NULL;
 298                 }
 299                 rsc = new_resource(res_type,
 300                                    usrres,
 301                                    memopt,
 302                                    new_language(PRIMARYLANGID(language),
 303                                                 SUBLANGID(language)));
 304                 rsc->binres = res;
 305                 rsc->name = name;
 306                 rsc->c_name = make_c_name(get_c_typename(res_type), name, rsc->lan);
 307                 if(!list)
 308                 {
 309                         list = rsc;
 310                         tail = rsc;
 311                 }
 312                 else
 313                 {
 314                         rsc->prev = tail;
 315                         tail->next = rsc;
 316                         tail = rsc;
 317                 }
 318         }
 319         return list;
 320 }
 321
 322 /*
 323  *****************************************************************************
 324  * Function     :
 325  * Syntax       :
 326  * Input        :
 327  * Output       :
 328  * Description  :
 329  * Remarks      :
 330  *****************************************************************************
 331 */
 332 static resource_t *read_res16(FILE *fp)
 333 {
 334         internal_error(__FILE__, __LINE__, "Can't yet read 16 bit .res files\n");
 335         return NULL;
 336 }
 337
 338 /*
 339  *****************************************************************************
 340  * Function     : read_resfile
 341  * Syntax       : resource_t *read_resfile(char *inname)
 342  * Input        :
 343  * Output       :
 344  * Description  :
 345  * Remarks      :
 346  *****************************************************************************
 347 */
 348 resource_t *read_resfile(char *inname)
 349 {
 350         FILE *fp;
 351         struct resheader32 rh;
 352         int is32bit = 1;
 353         resource_t *top;
 354
 355         fp = fopen(inname, "rb");
 356         if(!fp)
 357             fatal_perror("Could not open %s", inname);
 358
 359         /* Determine 16 or 32 bit .res file */
 360         if(fread(&rh, 1, sizeof(rh), fp) != sizeof(rh))
 361                 is32bit = 0;
 362         else
 363         {
 364                 if(!memcmp(&emptyheader, &rh, sizeof(rh)))
 365                         is32bit = 1;
 366                 else if(!memcmp(&emptyheaderSWAPPED, &rh, sizeof(rh)))
 367                         error("Binary .res-file has its byteorder swapped\n");
 368                 else
 369                         is32bit = 0;
 370         }
 371
 372         if(is32bit && !win32)
 373                 error("Cannot convert 32-bit .res-file into 16-bit resources (and will, hopefully never, implement it)\n");
 374
 375         if(!is32bit && win32)
 376                 error("Cannot (yet) convert 16-bit .res-file into 32-bit resources\n");
 377
 378         if(!is32bit)
 379         {
 380                 fseek(fp, 0, SEEK_SET);
 381                 top = read_res16(fp);
 382         }
 383         else
 384         {
 385                 top = read_res32(fp);
 386         }
 387
 388         fclose(fp);
 389
 390         return top;
 391 }