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