tools/wrc/writeres.c

   1 /*
   2  * Write .res, .s and .h file(s) from a resource-tree
   3  *
   4  * Copyright 1998 Bertho A. Stultiens
   5  *
   6  */
   7
   8 #include "config.h"
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <assert.h>
  14 #include <time.h>
  15
  16 #include "wrc.h"
  17 #include "writeres.h"
  18 #include "genres.h"
  19 #include "newstruc.h"
  20 #include "utils.h"
  21
  22 #ifdef NEED_UNDERSCORE_PREFIX
  23 char Underscore[] = "_";
  24 #else
  25 char Underscore[] = "";
  26 #endif
  27
  28 char s_file_head_str[] =
  29         "/* This file is generated with wrc version " WRC_FULLVERSION ". Do not edit! */\n"
  30         "/* Source : %s */\n"
  31         "/* Cmdline: %s */\n"
  32         "/* Date   : %s */\n"
  33         "\n"
  34         "\t.data\n"
  35         "\n"
  36         ;
  37
  38 char s_file_tail_str[] =
  39         "/* <eof> */\n"
  40         "\n"
  41         ;
  42
  43 char s_file_autoreg_str[] =
  44         "\t.text\n"
  45         ".LAuto_Register:\n"
  46         "\tpushl\t$%s%s\n"
  47 #ifdef NEED_UNDERSCORE_PREFIX
  48         "\tcall\t_LIBRES_RegisterResources\n"
  49 #else
  50         "\tcall\tLIBRES_RegisterResources\n"
  51 #endif
  52         "\taddl\t$4,%%esp\n"
  53         "\tret\n\n"
  54 #ifdef __NetBSD__
  55         ".stabs \"___CTOR_LIST__\",22,0,0,.LAuto_Register\n\n"
  56 #else
  57         "\t.section .ctors,\"aw\"\n"
  58         "\t.long\t.LAuto_Register\n\n"
  59 #endif
  60         ;
  61
  62 char h_file_head_str[] =
  63         "/*\n"
  64         " * This file is generated with wrc version " WRC_FULLVERSION ". Do not edit!\n"
  65         " * Source : %s\n"
  66         " * Cmdline: %s\n"
  67         " * Date   : %s"
  68         " */\n"
  69         "\n"
  70         "#ifndef __%08lx_H\n"   /* This becomes the date of compile */
  71         "#define __%08lx_H\n"
  72         "\n"
  73         "#include <wrc_rsc.h>\n"
  74         "\n"
  75         ;
  76
  77 char h_file_tail_str[] =
  78         "#endif\n"
  79         "/* <eof> */\n\n"
  80         ;
  81
  82 char _NEResTab[] = "_NEResTab";
  83 char _PEResTab[] = "_PEResTab";
  84 char _ResTable[] = "_ResTable";
  85
  86 /* Variables used for resource sorting */
  87 res_count_t *rcarray = NULL;    /* Type-level count array */
  88 int rccount = 0;                /* Nr of entries in the type-level array */
  89 int n_id_entries = 0;           /* win32 only: Nr of unique ids in the type-level array */
  90 int n_name_entries = 0;         /* win32 only: Nr of unique namess in the type-level array */
  91
  92 static int direntries;          /* win32 only: Total number of unique resources */
  93
  94 time_t now;
  95
  96 /*
  97  *****************************************************************************
  98  * Function     : write_resfile
  99  * Syntax       : void write_resfile(char *outname, resource_t *top)
 100  * Input        :
 101  *      outname - Filename to write to
 102  *      top     - The resource-tree to convert
 103  * Output       :
 104  * Description  :
 105  * Remarks      :
 106  *****************************************************************************
 107 */
 108 void write_resfile(char *outname, resource_t *top)
 109 {
 110         FILE *fo;
 111         int ret;
 112         char zeros[3] = {0, 0, 0};
 113
 114         fo = fopen(outname, "wb");
 115         if(!fo)
 116         {
 117                 error("Could not open %s\n", outname);
 118         }
 119
 120         if(win32)
 121         {
 122                 /* Put an empty resource first to signal win32 format */
 123                 res_t *res = new_res();
 124                 put_dword(res, 0);              /* ResSize */
 125                 put_dword(res, 0x00000020);     /* HeaderSize */
 126                 put_word(res, 0xffff);          /* ResType */
 127                 put_word(res, 0);
 128                 put_word(res, 0xffff);          /* ResName */
 129                 put_word(res, 0);
 130                 put_dword(res, 0);              /* DataVersion */
 131                 put_word(res, 0);               /* Memory options */
 132                 put_word(res, 0);               /* Language */
 133                 put_dword(res, 0);              /* Version */
 134                 put_dword(res, 0);              /* Charateristics */
 135                 ret = fwrite(res->data, 1, res->size, fo);
 136                 if(ret != res->size)
 137                 {
 138                         fclose(fo);
 139                         error("Error writing %s", outname);
 140                 }
 141                 free(res);
 142         }
 143
 144         for(; top; top = top->next)
 145         {
 146                 if(!top->binres)
 147                         continue;
 148
 149                 ret = fwrite(top->binres->data, 1, top->binres->size, fo);
 150                 if(ret != top->binres->size)
 151                 {
 152                         fclose(fo);
 153                         error("Error writing %s", outname);
 154                 }
 155                 if(win32 && (top->binres->size & 0x03))
 156                 {
 157                         /* Write padding */
 158                         ret = fwrite(zeros, 1, 4 - (top->binres->size & 0x03), fo);
 159                         if(ret != 4 - (top->binres->size & 0x03))
 160                         {
 161                                 fclose(fo);
 162                                 error("Error writing %s", outname);
 163                         }
 164                 }
 165         }
 166         fclose(fo);
 167 }
 168
 169 /*
 170  *****************************************************************************
 171  * Function     : write_s_res
 172  * Syntax       : void write_s_res(FILE *fp, res_t *res)
 173  * Input        :
 174  * Output       :
 175  * Description  :
 176  * Remarks      :
 177  *****************************************************************************
 178 */
 179 #define BYTESPERLINE    8
 180 void write_s_res(FILE *fp, res_t *res)
 181 {
 182         int idx = res->dataidx;
 183         int end = res->size;
 184         int rest = (end - idx) % BYTESPERLINE;
 185         int lines = (end - idx) / BYTESPERLINE;
 186         int i, j;
 187
 188         for(i = 0 ; i < lines; i++)
 189         {
 190                 fprintf(fp, "\t.byte\t");
 191                 for(j = 0; j < BYTESPERLINE; j++, idx++)
 192                 {
 193                         fprintf(fp, "0x%02x%s", res->data[idx] & 0xff,
 194                                         j == BYTESPERLINE-1 ? "" : ", ");
 195                 }
 196                 fprintf(fp, "\n");
 197         }
 198         if(rest)
 199         {
 200                 fprintf(fp, "\t.byte\t");
 201                 for(j = 0; j < rest; j++, idx++)
 202                 {
 203                         fprintf(fp, "0x%02x%s", res->data[idx] & 0xff,
 204                                         j == rest-1 ? "" : ", ");
 205                 }
 206                 fprintf(fp, "\n");
 207         }
 208 }
 209
 210 /*
 211  *****************************************************************************
 212  * Function     : write_name_str
 213  * Syntax       : void write_name_str(FILE *fp, name_id_t *nid)
 214  * Input        :
 215  * Output       :
 216  * Description  :
 217  * Remarks      : One level self recursive for string type conversion
 218  *****************************************************************************
 219 */
 220 void write_name_str(FILE *fp, name_id_t *nid)
 221 {
 222         res_t res;
 223         assert(nid->type == name_str);
 224
 225         if(!win32 && nid->name.s_name->type == str_char)
 226         {
 227                 res.size = strlen(nid->name.s_name->str.cstr);
 228                 if(res.size > 254)
 229                         error("Can't write strings larger than 254 bytes");
 230                 if(res.size == 0)
 231                         internal_error(__FILE__, __LINE__, "Attempt to write empty string");
 232                 res.dataidx = 0;
 233                 res.data = (char *)xmalloc(res.size + 1);
 234                 res.data[0] = (char)res.size;
 235                 res.size++;     /* We need to write the lenth byte as well */
 236                 strcpy(res.data+1, nid->name.s_name->str.cstr);
 237                 write_s_res(fp, &res);
 238                 free(res.data);
 239         }
 240         else if(!win32 && nid->name.s_name->type == str_unicode)
 241         {
 242                 name_id_t lnid;
 243                 string_t str;
 244
 245                 lnid.type = name_str;
 246                 lnid.name.s_name = &str;
 247                 str.type = str_char;
 248                 str.str.cstr = dupwstr2cstr(nid->name.s_name->str.wstr);
 249                 write_name_str(fp, &lnid);
 250                 free(str.str.cstr);
 251         }
 252         else if(win32 && nid->name.s_name->type == str_char)
 253         {
 254                 name_id_t lnid;
 255                 string_t str;
 256
 257                 lnid.type = name_str;
 258                 lnid.name.s_name = &str;
 259                 str.type = str_unicode;
 260                 str.str.wstr = dupcstr2wstr(nid->name.s_name->str.cstr);
 261                 write_name_str(fp, &lnid);
 262                 free(str.str.wstr);
 263         }
 264         else  if(win32 && nid->name.s_name->type == str_unicode)
 265         {
 266                 res.size = wstrlen(nid->name.s_name->str.wstr);
 267                 if(res.size > 65534)
 268                         error("Can't write strings larger than 65534 bytes");
 269                 if(res.size == 0)
 270                         internal_error(__FILE__, __LINE__, "Attempt to write empty string");
 271                 res.dataidx = 0;
 272                 res.data = (char *)xmalloc((res.size + 1) * 2);
 273                 ((short *)res.data)[0] = (short)res.size;
 274                 wstrcpy((short *)(res.data+2), nid->name.s_name->str.wstr);
 275                 res.size *= 2; /* Function writes bytes, not shorts... */
 276                 res.size += 2; /* We need to write the length word as well */
 277                 write_s_res(fp, &res);
 278                 free(res.data);
 279         }
 280         else
 281         {
 282                 internal_error(__FILE__, __LINE__, "Hmm, requested to write a string of unknown type %d",
 283                                 nid->name.s_name->type);
 284         }
 285 }
 286
 287 /*
 288  *****************************************************************************
 289  * Function     : compare_name_id
 290  * Syntax       : int compare_name_id(name_id_t *n1, name_id_t *n2)
 291  * Input        :
 292  * Output       :
 293  * Description  :
 294  * Remarks      :
 295  *****************************************************************************
 296 */
 297 int compare_name_id(name_id_t *n1, name_id_t *n2)
 298 {
 299         if(n1->type == name_ord && n2->type == name_ord)
 300         {
 301                 return n1->name.i_name - n2->name.i_name;
 302         }
 303         else if(n1->type == name_str && n2->type == name_str)
 304         {
 305                 if(n1->name.s_name->type == str_char
 306                 && n2->name.s_name->type == str_char)
 307                 {
 308                         return strcasecmp(n1->name.s_name->str.cstr, n2->name.s_name->str.cstr);
 309                 }
 310                 else if(n1->name.s_name->type == str_unicode
 311                 && n2->name.s_name->type == str_unicode)
 312                 {
 313                         return wstricmp(n1->name.s_name->str.wstr, n2->name.s_name->str.wstr);
 314                 }
 315                 else
 316                 {
 317                         internal_error(__FILE__, __LINE__, "Can't yet compare strings of mixed type");
 318                 }
 319         }
 320         else if(n1->type == name_ord && n2->type == name_str)
 321                 return 1;
 322         else if(n1->type == name_str && n2->type == name_ord)
 323                 return -1;
 324         else
 325                 internal_error(__FILE__, __LINE__, "Comparing name-ids with unknown types (%d, %d)",
 326                                 n1->type, n2->type);
 327
 328         return 0; /* Keep the compiler happy */
 329 }
 330
 331 /*
 332  *****************************************************************************
 333  * Function     : find_counter
 334  * Syntax       : res_count_t *find_counter(name_id_t *type)
 335  * Input        :
 336  * Output       :
 337  * Description  :
 338  * Remarks      :
 339  *****************************************************************************
 340 */
 341 res_count_t *find_counter(name_id_t *type)
 342 {
 343         int i;
 344         for(i = 0; i < rccount; i++)
 345         {
 346                 if(!compare_name_id(type, &(rcarray[i].type)))
 347                         return &rcarray[i];
 348         }
 349         return NULL;
 350 }
 351
 352 /*
 353  *****************************************************************************
 354  * Function     : count_resources
 355  * Syntax       : res_count_t *count_resources(resource_t *top)
 356  * Input        :
 357  * Output       :
 358  * Description  :
 359  * Remarks      : The whole lot is converted into arrays because they are
 360  *                easy sortable. Makes the lot almost unreadable, but it
 361  *                works (I hope). Basically you have to keep in mind that
 362  *                the lot is a three-dimensional structure for win32 and a
 363  *                two-dimensional structure for win16.
 364  *****************************************************************************
 365 */
 366 #define RCT(v)  (*((resource_t **)(v)))
 367 /* qsort sorting function */
 368 int sort_name_id(const void *e1, const void *e2)
 369 {
 370         return compare_name_id(RCT(e1)->name, RCT(e2)->name);
 371 }
 372
 373 int sort_language(const void *e1, const void *e2)
 374 {
 375         assert((RCT(e1)->lan) != NULL);
 376         assert((RCT(e2)->lan) != NULL);
 377
 378         return MAKELANGID(RCT(e1)->lan->id, RCT(e1)->lan->sub)
 379              - MAKELANGID(RCT(e2)->lan->id, RCT(e2)->lan->sub);
 380 }
 381 #undef RCT
 382 #define RCT(v)  ((res_count_t *)(v))
 383 int sort_type(const void *e1, const void *e2)
 384 {
 385         return compare_name_id(&(RCT(e1)->type), &(RCT(e2)->type));
 386 }
 387 #undef RCT
 388
 389 void count_resources(resource_t *top)
 390 {
 391         resource_t *rsc;
 392         res_count_t *rcp;
 393         name_id_t nid;
 394         int i, j;
 395
 396         for(rsc = top; rsc; rsc = rsc->next)
 397         {
 398                 if(!rsc->binres)
 399                         continue;
 400                 switch(rsc->type)
 401                 {
 402                 case res_dlgex:
 403                         nid.name.i_name = WRC_RT_DIALOG;
 404                         nid.type = name_ord;
 405                         break;
 406                 case res_menex:
 407                         nid.name.i_name = WRC_RT_MENU;
 408                         nid.type = name_ord;
 409                         break;
 410                 case res_usr:
 411                         nid = *(rsc->res.usr->type);
 412                         break;
 413                 default:
 414                         nid.name.i_name = rsc->type;
 415                         nid.type = name_ord;
 416                 }
 417
 418                 if((rcp = find_counter(&nid)) == NULL)
 419                 {
 420                         /* Count the number of uniq ids and names */
 421
 422                         if(nid.type == name_ord)
 423                                 n_id_entries++;
 424                         else
 425                                 n_name_entries++;
 426
 427                         if(!rcarray)
 428                         {
 429                                 rcarray = (res_count_t *)xmalloc(sizeof(res_count_t));
 430                                 rccount = 1;
 431                                 rcarray[0].count = 1;
 432                                 rcarray[0].type = nid;
 433                                 rcarray[0].rscarray = (resource_t **)xmalloc(sizeof(resource_t *));
 434                                 rcarray[0].rscarray[0] = rsc;
 435                         }
 436                         else
 437                         {
 438                                 rccount++;
 439                                 rcarray = (res_count_t *)xrealloc(rcarray, rccount * sizeof(res_count_t));
 440                                 rcarray[rccount-1].count = 1;
 441                                 rcarray[rccount-1].type = nid;
 442                                 rcarray[rccount-1].rscarray = (resource_t **)xmalloc(sizeof(resource_t *));
 443                                 rcarray[rccount-1].rscarray[0] = rsc;
 444                         }
 445                 }
 446                 else
 447                 {
 448                         rcp->count++;
 449                         rcp->rscarray = (resource_t **)xrealloc(rcp->rscarray, rcp->count * sizeof(resource_t *));
 450                         rcp->rscarray[rcp->count-1] = rsc;
 451                 }
 452         }
 453
 454         if(!win32)
 455         {
 456                 /* We're done, win16 requires no special sorting */
 457                 return;
 458         }
 459
 460         /* We now have a unsorted list of types with an array of res_count_t
 461          * in rcarray[0..rccount-1]. And we have names of one type in the
 462          * rcarray[x].rsc[0..rcarray[x].count-1] arrays.
 463          * The list needs to be sorted for win32's top level tree structure.
 464          */
 465
 466         /* Sort the types */
 467         if(rccount > 1)
 468                 qsort(rcarray, rccount, sizeof(rcarray[0]), sort_type);
 469
 470         /* Now sort the name-id arrays */
 471         for(i = 0; i < rccount; i++)
 472         {
 473                 if(rcarray[i].count > 1)
 474                         qsort(rcarray[i].rscarray, rcarray[i].count, sizeof(rcarray[0].rscarray[0]), sort_name_id);
 475         }
 476
 477         /* Now split the name-id arrays into name/language
 478          * subs. Don't look at the awfull expressions...
 479          * We do this by taking the array elements out of rscarray and putting
 480          * together a new array in rsc32array.
 481          */
 482         for(i = 0; i < rccount; i++)
 483         {
 484                 res_count_t *rcap;
 485
 486                 assert(rcarray[i].count >= 1);
 487
 488                 /* rcap points to the current type we are dealing with */
 489                 rcap = &(rcarray[i]);
 490
 491                 /* Insert the first name-id */
 492                 rcap->rsc32array = (res32_count_t *)xmalloc(sizeof(res32_count_t));
 493                 rcap->count32 = 1;
 494                 rcap->rsc32array[0].rsc = (resource_t **)xmalloc(sizeof(resource_t *));
 495                 rcap->rsc32array[0].count = 1;
 496                 rcap->rsc32array[0].rsc[0] = rcap->rscarray[0];
 497                 if(rcap->rscarray[0]->name->type == name_ord)
 498                 {
 499                         rcap->n_id_entries = 1;
 500                         rcap->n_name_entries = 0;
 501                 }
 502                 else
 503                 {
 504                         rcap->n_id_entries = 0;
 505                         rcap->n_name_entries = 1;
 506                 }
 507
 508                 /* Now loop over the resting resources of the current type
 509                  * to find duplicate names (which should have different
 510                  * languages).
 511                  */
 512                 for(j = 1; j < rcap->count; j++)
 513                 {
 514                         res32_count_t *r32cp;
 515
 516                         /* r32cp points to the current res32_count structure
 517                          * that holds the resource name we are processing.
 518                          */
 519                         r32cp = &(rcap->rsc32array[rcap->count32-1]);
 520
 521                         if(!compare_name_id(r32cp->rsc[0]->name, rcarray[i].rscarray[j]->name))
 522                         {
 523                                 /* Names are the same, add to list */
 524                                 r32cp->count++;
 525                                 r32cp->rsc = (resource_t **)xrealloc(r32cp->rsc, r32cp->count * sizeof(resource_t *));
 526                                 r32cp->rsc[r32cp->count-1] = rcap->rscarray[j];
 527                         }
 528                         else
 529                         {
 530                                 /* New name-id, sort the old one by
 531                                  * language and create new list
 532                                  */
 533                                 if(r32cp->count > 1)
 534                                         qsort(r32cp->rsc, r32cp->count, sizeof(r32cp->rsc[0]), sort_language);
 535                                 rcap->count32++;
 536                                 rcap->rsc32array = (res32_count_t*)xrealloc(rcap->rsc32array, rcap->count32 * sizeof(res32_count_t));
 537                                 rcap->rsc32array[rcap->count32-1].rsc = (resource_t **)xmalloc(sizeof(resource_t *));
 538                                 rcap->rsc32array[rcap->count32-1].count = 1;
 539                                 rcap->rsc32array[rcap->count32-1].rsc[0] = rcap->rscarray[j];
 540
 541                                 if(rcap->rscarray[j]->name->type == name_ord)
 542                                         rcap->n_id_entries++;
 543                                 else
 544                                         rcap->n_name_entries++;
 545                         }
 546                 }
 547                 /* Also sort the languages of the last name group */
 548                 if(rcap->rsc32array[rcap->count32-1].count > 1)
 549                         qsort(rcap->rsc32array[rcap->count32-1].rsc,
 550                               rcap->rsc32array[rcap->count32-1].count,
 551                               sizeof(rcap->rsc32array[rcap->count32-1].rsc[0]),
 552                               sort_language);
 553         }
 554 }
 555
 556 /*
 557  *****************************************************************************
 558  * Function     : write_pe_segment
 559  * Syntax       : void write_pe_segment(FILE *fp, resource_t *top)
 560  * Input        :
 561  * Output       :
 562  * Description  :
 563  * Remarks      :
 564  *****************************************************************************
 565 */
 566 void write_pe_segment(FILE *fp, resource_t *top)
 567 {
 568         int i;
 569
 570         fprintf(fp, "\t.align\t4\n");
 571         fprintf(fp, "%s%s:\n", prefix, _PEResTab);
 572         fprintf(fp, "\t.globl\t%s%s\n", prefix, _PEResTab);
 573         /* Flags */
 574         fprintf(fp, "\t.long\t0\n");
 575         /* Time/Date stamp */
 576         fprintf(fp, "\t.long\t0x%08lx\n", (long)now);
 577         /* Version */
 578         fprintf(fp, "\t.long\t0\n");    /* FIXME: must version be filled out? */
 579         /* # of id entries, # of name entries */
 580         fprintf(fp, "\t.word\t%d, %d\n", n_name_entries, n_id_entries);
 581
 582         /* Write the type level of the tree */
 583         for(i = 0; i < rccount; i++)
 584         {
 585                 res_count_t *rcp;
 586                 char *label;
 587
 588                 rcp = &rcarray[i];
 589
 590                 /* TypeId */
 591                 if(rcp->type.type == name_ord)
 592                         fprintf(fp, "\t.long\t%d\n", rcp->type.name.i_name);
 593                 else
 594                 {
 595                         char *name = prep_nid_for_label(&(rcp->type));
 596                         fprintf(fp, "\t.long\t(%s_%s_typename - %s%s) | 0x80000000\n",
 597                                 prefix,
 598                                 name,
 599                                 prefix,
 600                                 _PEResTab);
 601                 }
 602                 /* Offset */
 603                 label = prep_nid_for_label(&(rcp->type));
 604                 fprintf(fp, "\t.long\t(.L%s - %s%s) | 0x80000000\n",
 605                         label,
 606                         prefix,
 607                         _PEResTab);
 608         }
 609
 610         /* Write the name level of the tree */
 611
 612         for(i = 0; i < rccount; i++)
 613         {
 614                 res_count_t *rcp;
 615                 char *typelabel;
 616                 char *namelabel;
 617                 int j;
 618
 619                 rcp = &rcarray[i];
 620
 621                 typelabel = xstrdup(prep_nid_for_label(&(rcp->type)));
 622                 fprintf(fp, ".L%s:\n", typelabel);
 623
 624                 fprintf(fp, "\t.long\t0\n");            /* Flags */
 625                 fprintf(fp, "\t.long\t0x%08lx\n", (long)now);   /* TimeDate */
 626                 fprintf(fp, "\t.long\t0\n");    /* FIXME: must version be filled out? */
 627                 fprintf(fp, "\t.word\t%d, %d\n", rcp->n_name_entries, rcp->n_id_entries);
 628                 for(j = 0; j < rcp->count32; j++)
 629                 {
 630                         resource_t *rsc = rcp->rsc32array[j].rsc[0];
 631                         /* NameId */
 632                         if(rsc->name->type == name_ord)
 633                                 fprintf(fp, "\t.long\t%d\n", rsc->name->name.i_name);
 634                         else
 635                         {
 636                                 fprintf(fp, "\t.long\t(%s%s_name - %s%s) | 0x80000000\n",
 637                                         prefix,
 638                                         rsc->c_name,
 639                                         prefix,
 640                                         _PEResTab);
 641                         }
 642                         /* Maybe FIXME: Unescape the tree (ommit 0x80000000) and
 643                          * put the offset to the resource data entry.
 644                          * ?? Is unescaping worth while ??
 645                          */
 646                         /* Offset */
 647                         namelabel = prep_nid_for_label(rsc->name);
 648                         fprintf(fp, "\t.long\t(.L%s_%s - %s%s) | 0x80000000\n",
 649                                 typelabel,
 650                                 namelabel,
 651                                 prefix,
 652                                 _PEResTab);
 653                 }
 654                 free(typelabel);
 655         }
 656
 657         /* Write the language level of the tree */
 658
 659         for(i = 0; i < rccount; i++)
 660         {
 661                 res_count_t *rcp;
 662                 char *namelabel;
 663                 char *typelabel;
 664                 int j;
 665
 666                 rcp = &rcarray[i];
 667                 typelabel = xstrdup(prep_nid_for_label(&(rcp->type)));
 668
 669                 for(j = 0; j < rcp->count32; j++)
 670                 {
 671                         res32_count_t *r32cp = &(rcp->rsc32array[j]);
 672                         int k;
 673
 674                         namelabel = xstrdup(prep_nid_for_label(r32cp->rsc[0]->name));
 675                         fprintf(fp, ".L%s_%s:\n", typelabel, namelabel);
 676
 677                         fprintf(fp, "\t.long\t0\n");            /* Flags */
 678                         fprintf(fp, "\t.long\t0x%08lx\n", (long)now);   /* TimeDate */
 679                         fprintf(fp, "\t.long\t0\n");    /* FIXME: must version be filled out? */
 680                         fprintf(fp, "\t.word\t0, %d\n", r32cp->count);
 681
 682                         for(k = 0; k < r32cp->count; k++)
 683                         {
 684                                 resource_t *rsc = r32cp->rsc[k];
 685                                 assert(rsc->lan != NULL);
 686                                 /* LanguageId */
 687                                 fprintf(fp, "\t.long\t0x%08x\n", rsc->lan ? MAKELANGID(rsc->lan->id, rsc->lan->sub) : 0);
 688                                 /* Offset */
 689                                 fprintf(fp, "\t.long\t.L%s_%s_%d - %s%s\n",
 690                                         typelabel,
 691                                         namelabel,
 692                                         rsc->lan ? MAKELANGID(rsc->lan->id, rsc->lan->sub) : 0,
 693                                         prefix,
 694                                         _PEResTab);
 695                         }
 696                         free(namelabel);
 697                 }
 698                 free(typelabel);
 699         }
 700
 701         /* Write the resource table itself */
 702         fprintf(fp, "%s_ResourceDirectory:\n", prefix);
 703         fprintf(fp, "\t.globl\t%s_ResourceDirectory\n", prefix);
 704         direntries = 0;
 705
 706         for(i = 0; i < rccount; i++)
 707         {
 708                 res_count_t *rcp;
 709                 char *namelabel;
 710                 char *typelabel;
 711                 int j;
 712
 713                 rcp = &rcarray[i];
 714                 typelabel = xstrdup(prep_nid_for_label(&(rcp->type)));
 715
 716                 for(j = 0; j < rcp->count32; j++)
 717                 {
 718                         res32_count_t *r32cp = &(rcp->rsc32array[j]);
 719                         int k;
 720
 721                         namelabel = xstrdup(prep_nid_for_label(r32cp->rsc[0]->name));
 722
 723                         for(k = 0; k < r32cp->count; k++)
 724                         {
 725                                 resource_t *rsc = r32cp->rsc[k];
 726
 727                                 assert(rsc->lan != NULL);
 728
 729                                 fprintf(fp, ".L%s_%s_%d:\n",
 730                                         typelabel,
 731                                         namelabel,
 732                                         rsc->lan ? MAKELANGID(rsc->lan->id, rsc->lan->sub) : 0);
 733
 734                                 /* Data RVA */
 735                                 fprintf(fp, "\t.long\t%s%s_data - %s%s\n",
 736                                         prefix,
 737                                         rsc->c_name,
 738                                         prefix,
 739                                         _PEResTab);
 740                                 /* Size */
 741                                 fprintf(fp, "\t.long\t%d\n",
 742                                         rsc->binres->size - rsc->binres->dataidx);
 743                                 /* CodePage */
 744                                 fprintf(fp, "\t.long\t%ld\n", codepage);
 745                                 /* Reserved */
 746                                 fprintf(fp, "\t.long\t0\n");
 747
 748                                 direntries++;
 749                         }
 750                         free(namelabel);
 751                 }
 752                 free(typelabel);
 753         }
 754 }
 755
 756 /*
 757  *****************************************************************************
 758  * Function     : write_ne_segment
 759  * Syntax       : void write_ne_segment(FILE *fp, resource_t *top)
 760  * Input        :
 761  * Output       :
 762  * Description  :
 763  * Remarks      :
 764  *****************************************************************************
 765 */
 766 void write_ne_segment(FILE *fp, resource_t *top)
 767 {
 768         int i, j;
 769
 770         fprintf(fp, "\t.align\t4\n");
 771         fprintf(fp, "%s%s:\n", prefix, _NEResTab);
 772         fprintf(fp, "\t.globl\t%s%s\n", prefix, _NEResTab);
 773
 774         /* AlignmentShift */
 775         fprintf(fp, "\t.word\t%d\n", alignment_pwr);
 776
 777         /* TypeInfo */
 778         for(i = 0; i < rccount; i++)
 779         {
 780                 res_count_t *rcp = &rcarray[i];
 781
 782                 /* TypeId */
 783                 if(rcp->type.type == name_ord)
 784                         fprintf(fp, "\t.word\t0x%04x\n", rcp->type.name.i_name | 0x8000);
 785                 else
 786                         fprintf(fp, "\t.word\t%s_%s_typename - %s%s\n",
 787                                 prefix,
 788                                 rcp->type.name.s_name->str.cstr,
 789                                 prefix,
 790                                 _NEResTab);
 791                 /* ResourceCount */
 792                 fprintf(fp, "\t.word\t%d\n", rcp->count);
 793                 /* Reserved */
 794                 fprintf(fp, "\t.long\t0\n");
 795                 /* NameInfo */
 796                 for(j = 0; j < rcp->count; j++)
 797                 {
 798 /*
 799  * VERY IMPORTANT:
 800  * The offset is relative to the beginning of the NE resource segment
 801  * and _NOT_ to the file-beginning. This is because we do not have a
 802  * file based resource, but a simulated NE segment. The offset _is_
 803  * scaled by the AlignShift field.
 804  * All other things are as the MS doc describes (alignment etc.)
 805  */
 806                         /* Offset */
 807                         fprintf(fp, "\t.word\t(%s%s_data - %s%s) >> %d\n",
 808                                 prefix,
 809                                 rcp->rscarray[j]->c_name,
 810                                 prefix,
 811                                 _NEResTab,
 812                                 alignment_pwr);
 813                         /* Length */
 814                         fprintf(fp, "\t.word\t%d\n",
 815                                 rcp->rscarray[j]->binres->size - rcp->rscarray[j]->binres->dataidx);
 816                         /* Flags */
 817                         fprintf(fp, "\t.word\t0x%04x\n", (WORD)rcp->rscarray[j]->memopt);
 818                         /* Id */
 819                         if(rcp->rscarray[j]->name->type == name_ord)
 820                                 fprintf(fp, "\t.word\t0x%04x\n", rcp->rscarray[j]->name->name.i_name | 0x8000);
 821                         else
 822                                 fprintf(fp, "\t.word\t%s%s_name - %s%s\n",
 823                                 prefix,
 824                                 rcp->rscarray[j]->c_name,
 825                                 prefix,
 826                                 _NEResTab);
 827                         /* Handle and Usage */
 828                         fprintf(fp, "\t.word\t0, 0\n");
 829                 }
 830         }
 831         /* EndTypes */
 832         fprintf(fp, "\t.word\t0\n");
 833 }
 834
 835 /*
 836  *****************************************************************************
 837  * Function     : write_rsc_names
 838  * Syntax       : void write_rsc_names(FILE *fp, resource_t *top)
 839  * Input        :
 840  * Output       :
 841  * Description  :
 842  * Remarks      :
 843  *****************************************************************************
 844 */
 845 void write_rsc_names(FILE *fp, resource_t *top)
 846 {
 847         int i, j;
 848
 849         if(win32)
 850         {
 851                 /* Write the names */
 852
 853                 for(i = 0; i < rccount; i++)
 854                 {
 855                         res_count_t *rcp;
 856
 857                         rcp = &rcarray[i];
 858
 859                         if(rcp->type.type == name_str)
 860                         {
 861                                 char *name = prep_nid_for_label(&(rcp->type));
 862                                 fprintf(fp, "%s_%s_typename:\n",
 863                                         prefix,
 864                                         name);
 865                                 write_name_str(fp, &(rcp->type));
 866                         }
 867
 868                         for(j = 0; j < rcp->count32; j++)
 869                         {
 870                                 resource_t *rsc = rcp->rsc32array[j].rsc[0];
 871
 872                                 if(rsc->name->type == name_str)
 873                                 {
 874                                         fprintf(fp, "%s%s_name:\n",
 875                                                 prefix,
 876                                                 rsc->c_name);
 877                                         write_name_str(fp, rsc->name);
 878                                 }
 879                         }
 880                 }
 881         }
 882         else
 883         {
 884                 /* ResourceNames */
 885                 for(i = 0; i < rccount; i++)
 886                 {
 887                         res_count_t *rcp = &rcarray[i];
 888
 889                         for(j = 0; j < rcp->count; j++)
 890                         {
 891                                 if(rcp->type.type == name_str)
 892                                 {
 893                                         fprintf(fp, "%s_%s_typename:\n",
 894                                                 prefix,
 895                                                 rcp->type.name.s_name->str.cstr);
 896                                         write_name_str(fp, &(rcp->type));
 897                                 }
 898                                 if(rcp->rscarray[j]->name->type == name_str)
 899                                 {
 900                                         fprintf(fp, "%s%s_name:\n",
 901                                                 prefix,
 902                                                 rcp->rscarray[j]->c_name);
 903                                         write_name_str(fp, rcp->rscarray[j]->name);
 904                                 }
 905                         }
 906                 }
 907                 /* EndNames */
 908
 909                 /* This is to end the NE resource table */
 910                 if(create_dir)
 911                         fprintf(fp, "\t.byte\t0\n");
 912         }
 913
 914         fprintf(fp, "\n");
 915 }
 916
 917 /*
 918  *****************************************************************************
 919  * Function     : write_s_file
 920  * Syntax       : void write_s_file(char *outname, resource_t *top)
 921  * Input        :
 922  *      outname - Filename to write to
 923  *      top     - The resource-tree to convert
 924  * Output       :
 925  * Description  :
 926  * Remarks      :
 927  *****************************************************************************
 928 */
 929 void write_s_file(char *outname, resource_t *top)
 930 {
 931         FILE *fo;
 932         resource_t *rsc;
 933
 934         fo = fopen(outname, "wt");
 935         if(!fo)
 936         {
 937                 error("Could not open %s\n", outname);
 938                 return;
 939         }
 940
 941         {
 942                 char *s, *p;
 943                 now = time(NULL);
 944                 s = ctime(&now);
 945                 p = strchr(s, '\n');
 946                 if(p) *p = '\0';
 947                 fprintf(fo, s_file_head_str, input_name ? input_name : "stdin",
 948                         cmdline, s);
 949         }
 950
 951         /* Get an idea how many we have and restructure the tables */
 952         count_resources(top);
 953
 954         /* First write the segment tables */
 955         if(create_dir)
 956         {
 957                 if(win32)
 958                         write_pe_segment(fo, top);
 959                 else
 960                         write_ne_segment(fo, top);
 961         }
 962
 963         /* Dump the names */
 964         write_rsc_names(fo, top);
 965
 966         if(create_dir)
 967                 fprintf(fo, ".LResTabEnd:\n");
 968
 969         if(!indirect_only)
 970         {
 971                 /* Write the resource data */
 972                 fprintf(fo, "\n/* Resource binary data */\n\n");
 973                 for(rsc = top; rsc; rsc = rsc->next)
 974                 {
 975                         if(!rsc->binres)
 976                                 continue;
 977
 978                         fprintf(fo, "\t.align\t%d\n", win32 ? 4 : alignment);
 979                         fprintf(fo, "%s%s_data:\n", prefix, rsc->c_name);
 980                         if(global)
 981                                 fprintf(fo, "\t.globl\t%s%s_data\n", prefix, rsc->c_name);
 982
 983                         write_s_res(fo, rsc->binres);
 984
 985                         fprintf(fo, "\n");
 986                 }
 987
 988                 if(create_dir)
 989                 {
 990                         /* Add a resource descriptor for built-in and elf-dlls */
 991                         fprintf(fo, "\t.align\t4\n");
 992                         fprintf(fo, "%s_ResourceDescriptor:\n", prefix);
 993                         fprintf(fo, "\t.globl\t%s_ResourceDescriptor\n", prefix);
 994                         fprintf(fo, "%s_ResourceTable:\n", prefix);
 995                         if(global)
 996                                 fprintf(fo, "\t.globl\t%s_ResourceTable\n", prefix);
 997                         fprintf(fo, "\t.long\t%s%s\n", prefix, win32 ? _PEResTab : _NEResTab);
 998                         fprintf(fo, "%s_NumberOfResources:\n", prefix);
 999                         if(global)
1000                                 fprintf(fo, "\t.globl\t%s_NumberOfResources\n", prefix);
1001                         fprintf(fo, "\t.long\t%d\n", direntries);
1002                         fprintf(fo, "%s_ResourceSectionSize:\n", prefix);
1003                         if(global)
1004                                 fprintf(fo, "\t.globl\t%s_ResourceSectionSize\n", prefix);
1005                         fprintf(fo, "\t.long\t.LResTabEnd - %s%s\n", prefix, win32 ? _PEResTab : _NEResTab);
1006                         if(win32)
1007                         {
1008                                 fprintf(fo, "%s_ResourcesEntries:\n", prefix);
1009                                 if(global)
1010                                         fprintf(fo, "\t.globl\t%s_ResourcesEntries\n", prefix);
1011                                 fprintf(fo, "\t.long\t%s_ResourceDirectory\n", prefix);
1012                         }
1013                 }
1014         }
1015
1016         if(indirect)
1017         {
1018                 /* Write the indirection structures */
1019                 fprintf(fo, "\n/* Resource indirection structures */\n\n");
1020                 fprintf(fo, "\t.align\t4\n");
1021                 for(rsc = top; rsc; rsc = rsc->next)
1022                 {
1023                         int type;
1024                         char *type_name = NULL;
1025
1026                         if(!rsc->binres)
1027                                 continue;
1028
1029                         switch(rsc->type)
1030                         {
1031                         case res_menex:
1032                                 type = WRC_RT_MENU;
1033                                 break;
1034                         case res_dlgex:
1035                                 type = WRC_RT_DIALOG;
1036                                 break;
1037                         case res_usr:
1038                                 assert(rsc->res.usr->type != NULL);
1039                                 type_name = prep_nid_for_label(rsc->res.usr->type);
1040                                 type = 0;
1041                                 break;
1042                         default:
1043                                 type = rsc->type;
1044                         }
1045
1046                         /*
1047                          * This follows a structure like:
1048                          * struct wrc_resource {
1049                          *      INT32   id;
1050                          *      RSCNAME *resname;
1051                          *      INT32   restype;
1052                          *      RSCNAME *typename;
1053                          *      void    *data;
1054                          *      UINT32  datasize;
1055                          * };
1056                          * The 'RSCNAME' is a pascal-style string where the
1057                          * first byte/word denotes the size and the rest the string
1058                          * itself.
1059                          */
1060                         fprintf(fo, "%s%s:\n", prefix, rsc->c_name);
1061                         if(global)
1062                                 fprintf(fo, "\t.globl\t%s%s\n", prefix, rsc->c_name);
1063                         fprintf(fo, "\t.long\t%d, %s%s%s, %d, %s%s%s%s, %s%s_data, %d\n",
1064                                 rsc->name->type == name_ord ? rsc->name->name.i_name : 0,
1065                                 rsc->name->type == name_ord ? "0" : prefix,
1066                                 rsc->name->type == name_ord ? "" : rsc->c_name,
1067                                 rsc->name->type == name_ord ? "" : "_name",
1068                                 type,
1069                                 type ? "0" : prefix,
1070                                 type ? "" : "_",
1071                                 type ? "" : type_name,
1072                                 type ? "" : "_typename",
1073                                 prefix,
1074                                 rsc->c_name,
1075                                 rsc->binres->size - rsc->binres->dataidx);
1076                         fprintf(fo, "\n");
1077                 }
1078                 fprintf(fo, "\n");
1079
1080                 /* Write the indirection table */
1081                 fprintf(fo, "/* Resource indirection table */\n\n");
1082                 fprintf(fo, "\t.align\t4\n");
1083                 fprintf(fo, "%s%s:\n", prefix, _ResTable);
1084                 fprintf(fo, "\t.globl\t%s%s\n", prefix, _ResTable);
1085                 for(rsc = top; rsc; rsc = rsc->next)
1086                 {
1087                         fprintf(fo, "\t.long\t%s%s\n", prefix, rsc->c_name);
1088                 }
1089                 fprintf(fo, "\t.long\t0\n");
1090                 fprintf(fo, "\n");
1091         }
1092
1093         if(auto_register)
1094                 fprintf(fo, s_file_autoreg_str, prefix, _ResTable);
1095
1096         fprintf(fo, s_file_tail_str);
1097         fclose(fo);
1098 }
1099
1100 /*
1101  *****************************************************************************
1102  * Function     : write_h_file
1103  * Syntax       : void write_h_file(char *outname, resource_t *top)
1104  * Input        :
1105  *      outname - Filename to write to
1106  *      top     - The resource-tree to convert
1107  * Output       :
1108  * Description  :
1109  * Remarks      :
1110  *****************************************************************************
1111 */
1112 void write_h_file(char *outname, resource_t *top)
1113 {
1114         FILE *fo;
1115         resource_t *rsc;
1116         char *h_prefix;
1117
1118 #ifdef NEED_UNDERSCORE_PREFIX
1119         h_prefix = prefix + 1;
1120 #else
1121         h_prefix = prefix;
1122 #endif
1123
1124         fo = fopen(outname, "wt");
1125         if(!fo)
1126         {
1127                 error("Could not open %s\n", outname);
1128         }
1129
1130         time(&now);
1131         fprintf(fo, h_file_head_str, input_name ? input_name : "stdin",
1132                 cmdline, ctime(&now), (long)now, (long)now);
1133
1134         /* First write the segment tables reference */
1135         if(create_dir)
1136         {
1137                 fprintf(fo, "extern %schar %s%s[];\n\n",
1138                         constant ? "const " : "",
1139                         h_prefix,
1140                         win32 ? _PEResTab : _NEResTab);
1141         }
1142
1143         /* Write the resource data */
1144         for(rsc = top; global && rsc; rsc = rsc->next)
1145         {
1146                 if(!rsc->binres)
1147                         continue;
1148
1149                 fprintf(fo, "extern %schar %s%s_data[];\n",
1150                         constant ? "const " : "",
1151                         h_prefix,
1152                         rsc->c_name);
1153         }
1154
1155         if(indirect)
1156         {
1157                 if(global)
1158                         fprintf(fo, "\n");
1159
1160                 /* Write the indirection structures */
1161                 for(rsc = top; global && rsc; rsc = rsc->next)
1162                 {
1163                         fprintf(fo, "extern %swrc_resource%d_t %s%s;\n",
1164                                 constant ? "const " : "",
1165                                 win32 ? 32 : 16,
1166                                 h_prefix,
1167                                 rsc->c_name);
1168                 }
1169
1170                 if(global)
1171                         fprintf(fo, "\n");
1172
1173                 /* Write the indirection table */
1174                 fprintf(fo, "extern %swrc_resource%d_t %s%s[];\n\n",
1175                         constant ? "const " : "",
1176                         win32 ? 32 : 16,
1177                         h_prefix,
1178                         _ResTable);
1179         }
1180
1181         fprintf(fo, h_file_tail_str);
1182         fclose(fo);
1183 }
1184
1185