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