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

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