source: branches/gcc-kmk/tools/wrc/newstruc.c@ 21836

Last change on this file since 21836 was 21745, checked in by dmik, 14 years ago

Build Wine RC tool.

It is necesasry for .orc files which are Windows resource files.
File size: 33.6 KB
Line 
1/*
2 * Create dynamic new structures of various types
3 * and some utils in that trend.
4 *
5 * Copyright 1998 Bertho A. Stultiens
6 *
7 */
8
9#include "config.h"
10
11#include <stdio.h>
12#include <stdlib.h>
13#include <string.h>
14#include <assert.h>
15#include <ctype.h>
16
17#include "wrc.h"
18#include "newstruc.h"
19#include "utils.h"
20#include "parser.h"
21
22#include "wingdi.h" /* for BITMAPINFOHEADER */
23
24/* Generate new_* functions that have no parameters (NOTE: no ';') */
25__NEW_STRUCT_FUNC(dialog)
26__NEW_STRUCT_FUNC(dialogex)
27__NEW_STRUCT_FUNC(name_id)
28__NEW_STRUCT_FUNC(menu)
29__NEW_STRUCT_FUNC(menuex)
30__NEW_STRUCT_FUNC(menu_item)
31__NEW_STRUCT_FUNC(menuex_item)
32__NEW_STRUCT_FUNC(control)
33__NEW_STRUCT_FUNC(icon)
34__NEW_STRUCT_FUNC(cursor)
35__NEW_STRUCT_FUNC(versioninfo)
36__NEW_STRUCT_FUNC(ver_value)
37__NEW_STRUCT_FUNC(ver_block)
38__NEW_STRUCT_FUNC(stt_entry)
39__NEW_STRUCT_FUNC(accelerator)
40__NEW_STRUCT_FUNC(event)
41__NEW_STRUCT_FUNC(raw_data)
42__NEW_STRUCT_FUNC(lvc)
43__NEW_STRUCT_FUNC(res_count)
44__NEW_STRUCT_FUNC(string)
45__NEW_STRUCT_FUNC(toolbar_item)
46__NEW_STRUCT_FUNC(ani_any)
47
48/* New instances for all types of structures */
49/* Very inefficient (in size), but very functional :-]
50 * Especially for type-checking.
51 */
52resource_t *new_resource(enum res_e t, void *res, int memopt, language_t *lan)
53{
54 resource_t *r = (resource_t *)xmalloc(sizeof(resource_t));
55 r->type = t;
56 r->res.overlay = res;
57 r->memopt = memopt;
58 r->lan = lan;
59 return r;
60}
61
62version_t *new_version(DWORD v)
63{
64 version_t *vp = (version_t *)xmalloc(sizeof(version_t));
65 *vp = v;
66 return vp;
67}
68
69characts_t *new_characts(DWORD c)
70{
71 characts_t *cp = (characts_t *)xmalloc(sizeof(characts_t));
72 *cp = c;
73 return cp;
74}
75
76language_t *new_language(int id, int sub)
77{
78 language_t *lan = (language_t *)xmalloc(sizeof(language_t));
79 lan->id = id;
80 lan->sub = sub;
81 return lan;
82}
83
84language_t *dup_language(language_t *l)
85{
86 if(!l) return NULL;
87 return new_language(l->id, l->sub);
88}
89
90version_t *dup_version(version_t *v)
91{
92 if(!v) return NULL;
93 return new_version(*v);
94}
95
96characts_t *dup_characts(characts_t *c)
97{
98 if(!c) return NULL;
99 return new_characts(*c);
100}
101
102rcdata_t *new_rcdata(raw_data_t *rd, int *memopt)
103{
104 rcdata_t *rc = (rcdata_t *)xmalloc(sizeof(rcdata_t));
105 rc->data = rd;
106 if(memopt)
107 {
108 rc->memopt = *memopt;
109 free(memopt);
110 }
111 else
112 rc->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
113 return rc;
114}
115
116font_id_t *new_font_id(int size, string_t *face, int weight, int italic)
117{
118 font_id_t *fid = (font_id_t *)xmalloc(sizeof(font_id_t));
119 fid->name = face;
120 fid->size = size;
121 fid->weight = weight;
122 fid->italic = italic;
123 return fid;
124}
125
126user_t *new_user(name_id_t *type, raw_data_t *rd, int *memopt)
127{
128 user_t *usr = (user_t *)xmalloc(sizeof(user_t));
129 usr->data = rd;
130 if(memopt)
131 {
132 usr->memopt = *memopt;
133 free(memopt);
134 }
135 else
136 usr->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
137 usr->type = type;
138 return usr;
139}
140
141font_t *new_font(raw_data_t *rd, int *memopt)
142{
143 font_t *fnt = (font_t *)xmalloc(sizeof(font_t));
144 fnt->data = rd;
145 if(memopt)
146 {
147 fnt->memopt = *memopt;
148 free(memopt);
149 }
150 else
151 fnt->memopt = WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE;
152 return fnt;
153}
154
155fontdir_t *new_fontdir(raw_data_t *rd, int *memopt)
156{
157 fontdir_t *fnd = (fontdir_t *)xmalloc(sizeof(fontdir_t));
158 fnd->data = rd;
159 if(memopt)
160 {
161 fnd->memopt = *memopt;
162 free(memopt);
163 }
164 else
165 fnd->memopt = WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE;
166 return fnd;
167}
168
169
170/*
171 * Convert bitmaps to proper endian
172 */
173static void convert_bitmap_swap_v3(BITMAPINFOHEADER *bih)
174{
175 bih->biSize = BYTESWAP_DWORD(bih->biSize);
176 bih->biWidth = BYTESWAP_DWORD(bih->biWidth);
177 bih->biHeight = BYTESWAP_DWORD(bih->biHeight);
178 bih->biPlanes = BYTESWAP_WORD(bih->biPlanes);
179 bih->biBitCount = BYTESWAP_WORD(bih->biBitCount);
180 bih->biCompression = BYTESWAP_DWORD(bih->biCompression);
181 bih->biSizeImage = BYTESWAP_DWORD(bih->biSizeImage);
182 bih->biXPelsPerMeter = BYTESWAP_DWORD(bih->biXPelsPerMeter);
183 bih->biYPelsPerMeter = BYTESWAP_DWORD(bih->biYPelsPerMeter);
184 bih->biClrUsed = BYTESWAP_DWORD(bih->biClrUsed);
185 bih->biClrImportant = BYTESWAP_DWORD(bih->biClrImportant);
186}
187
188static void convert_bitmap_swap_v4(BITMAPV4HEADER *b4h)
189{
190 convert_bitmap_swap_v3((BITMAPINFOHEADER *)b4h);
191 b4h->bV4RedMask = BYTESWAP_DWORD(b4h->bV4RedMask);
192 b4h->bV4GreenMask = BYTESWAP_DWORD(b4h->bV4GreenMask);
193 b4h->bV4BlueMask = BYTESWAP_DWORD(b4h->bV4BlueMask);
194 b4h->bV4AlphaMask = BYTESWAP_DWORD(b4h->bV4AlphaMask);
195 b4h->bV4CSType = BYTESWAP_DWORD(b4h->bV4CSType);
196 b4h->bV4Endpoints.ciexyzRed.ciexyzX = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzRed.ciexyzX);
197 b4h->bV4Endpoints.ciexyzRed.ciexyzY = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzRed.ciexyzY);
198 b4h->bV4Endpoints.ciexyzRed.ciexyzZ = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzRed.ciexyzZ);
199 b4h->bV4Endpoints.ciexyzGreen.ciexyzX = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzGreen.ciexyzX);
200 b4h->bV4Endpoints.ciexyzGreen.ciexyzY = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzGreen.ciexyzY);
201 b4h->bV4Endpoints.ciexyzGreen.ciexyzZ = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzGreen.ciexyzZ);
202 b4h->bV4Endpoints.ciexyzBlue.ciexyzX = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzBlue.ciexyzX);
203 b4h->bV4Endpoints.ciexyzBlue.ciexyzY = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzBlue.ciexyzY);
204 b4h->bV4Endpoints.ciexyzBlue.ciexyzZ = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzBlue.ciexyzZ);
205 b4h->bV4GammaRed = BYTESWAP_DWORD(b4h->bV4GammaRed);
206 b4h->bV4GammaGreen = BYTESWAP_DWORD(b4h->bV4GammaGreen);
207 b4h->bV4GammaBlue = BYTESWAP_DWORD(b4h->bV4GammaBlue);
208}
209
210#define FL_SIGBE 0x01
211#define FL_SIZEBE 0x02
212#define FL_V4 0x04
213static int convert_bitmap(char *data, int size)
214{
215 BITMAPINFOHEADER *bih = (BITMAPINFOHEADER *)data;
216 BITMAPV4HEADER *b4h = (BITMAPV4HEADER *)data;
217 int type = 0;
218#ifdef WORDS_BIGENDIAN
219 DWORD bisizel = BYTESWAP_DWORD(sizeof(BITMAPINFOHEADER));
220 DWORD b4sizel = BYTESWAP_DWORD(sizeof(BITMAPV4HEADER));
221 DWORD bisizeb = sizeof(BITMAPINFOHEADER);
222 DWORD b4sizeb = sizeof(BITMAPV4HEADER);
223#else
224 DWORD bisizel = sizeof(BITMAPINFOHEADER);
225 DWORD b4sizel = sizeof(BITMAPV4HEADER);
226 DWORD bisizeb = BYTESWAP_DWORD(sizeof(BITMAPINFOHEADER));
227 DWORD b4sizeb = BYTESWAP_DWORD(sizeof(BITMAPV4HEADER));
228#endif
229
230 if(data[0] == 'B' && data[1] == 'M')
231 {
232 /* Little endian signature */
233 bih = (BITMAPINFOHEADER *)(data + sizeof(BITMAPFILEHEADER));
234 b4h = (BITMAPV4HEADER *)(data + sizeof(BITMAPFILEHEADER));
235 }
236 else if(data[0] == 'M' && data[1] == 'B')
237 {
238 type |= FL_SIGBE; /* Big endian signature */
239 bih = (BITMAPINFOHEADER *)(data + sizeof(BITMAPFILEHEADER));
240 b4h = (BITMAPV4HEADER *)(data + sizeof(BITMAPFILEHEADER));
241 }
242
243 if(bih->biSize == bisizel)
244 {
245 /* Little endian */
246 }
247 else if(bih->biSize == b4sizel)
248 {
249 type |= FL_V4;
250 }
251 else if(bih->biSize == bisizeb)
252 {
253 type |= FL_SIZEBE;
254 }
255 else if(bih->biSize == b4sizeb)
256 {
257 type |= FL_SIZEBE | FL_V4;
258 }
259#if defined(__WIN32OS2__)
260 else if(bih->biSize == sizeof(BITMAPCOREHEADER))
261 {
262 /* Little endian */
263 }
264#endif
265 else
266 type = -1;
267
268 switch(type)
269 {
270 default:
271 break;
272 case FL_SIZEBE:
273 case FL_SIZEBE | FL_V4:
274 yywarning("Bitmap v%c signature little-endian, but size big-endian", type & FL_V4 ? '4' : '3');
275 break;
276 case FL_SIGBE:
277 case FL_SIGBE | FL_V4:
278 yywarning("Bitmap v%c signature big-endian, but size little-endian", type & FL_V4 ? '4' : '3');
279 break;
280 case -1:
281 yyerror("Invalid bitmap format");
282 break;
283 }
284
285 switch(byteorder)
286 {
287#ifdef WORDS_BIGENDIAN
288 default:
289#endif
290 case WRC_BO_BIG:
291 if(!(type & FL_SIZEBE))
292 {
293 if(type & FL_V4)
294 convert_bitmap_swap_v4(b4h);
295 else
296 convert_bitmap_swap_v3(bih);
297 }
298 break;
299#ifndef WORDS_BIGENDIAN
300 default:
301#endif
302 case WRC_BO_LITTLE:
303 if(type & FL_SIZEBE)
304 {
305 if(type & FL_V4)
306 convert_bitmap_swap_v4(b4h);
307 else
308 convert_bitmap_swap_v3(bih);
309 }
310 break;
311 }
312
313 if(size && (void *)data != (void *)bih)
314 {
315 /* We have the fileheader still attached, remove it */
316 memmove(data, data+sizeof(BITMAPFILEHEADER), size - sizeof(BITMAPFILEHEADER));
317 return sizeof(BITMAPFILEHEADER);
318 }
319 return 0;
320}
321#undef FL_SIGBE
322#undef FL_SIZEBE
323#undef FL_V4
324
325/*
326 * Cursor and icon splitter functions used when allocating
327 * cursor- and icon-groups.
328 */
329typedef struct {
330 language_t lan;
331 int id;
332} id_alloc_t;
333
334static int get_new_id(id_alloc_t **list, int *n, language_t *lan)
335{
336 int i;
337 assert(lan != NULL);
338 assert(list != NULL);
339 assert(n != NULL);
340
341 if(!*list)
342 {
343 *list = (id_alloc_t *)xmalloc(sizeof(id_alloc_t));
344 *n = 1;
345 (*list)[0].lan = *lan;
346 (*list)[0].id = 1;
347 return 1;
348 }
349
350 for(i = 0; i < *n; i++)
351 {
352 if((*list)[i].lan.id == lan->id && (*list)[i].lan.sub == lan->sub)
353 return ++((*list)[i].id);
354 }
355
356 *list = (id_alloc_t *)xrealloc(*list, sizeof(id_alloc_t) * (*n+1));
357 (*list)[*n].lan = *lan;
358 (*list)[*n].id = 1;
359 *n += 1;
360 return 1;
361}
362
363static int alloc_icon_id(language_t *lan)
364{
365 static id_alloc_t *idlist = NULL;
366 static int nid = 0;
367
368 return get_new_id(&idlist, &nid, lan);
369}
370
371static int alloc_cursor_id(language_t *lan)
372{
373 static id_alloc_t *idlist = NULL;
374 static int nid = 0;
375
376 return get_new_id(&idlist, &nid, lan);
377}
378
379static void split_icons(raw_data_t *rd, icon_group_t *icog, int *nico)
380{
381 int cnt;
382 int i;
383 icon_t *ico;
384 icon_t *list = NULL;
385 icon_header_t *ih = (icon_header_t *)rd->data;
386 int swap = 0;
387
388 if(ih->type == 1)
389 swap = 0;
390 else if(BYTESWAP_WORD(ih->type) == 1)
391 swap = 1;
392 else
393 yyerror("Icon resource data has invalid type id %d", ih->type);
394
395 cnt = swap ? BYTESWAP_WORD(ih->count) : ih->count;
396 for(i = 0; i < cnt; i++)
397 {
398 icon_dir_entry_t ide;
399 BITMAPINFOHEADER info;
400 memcpy(&ide, rd->data + sizeof(icon_header_t)
401 + i*sizeof(icon_dir_entry_t), sizeof(ide));
402
403 ico = new_icon();
404 ico->id = alloc_icon_id(icog->lvc.language);
405 ico->lvc = icog->lvc;
406 if(swap)
407 {
408 ide.offset = BYTESWAP_DWORD(ide.offset);
409 ide.ressize= BYTESWAP_DWORD(ide.ressize);
410 }
411 if(ide.offset > rd->size
412 || ide.offset + ide.ressize > rd->size)
413 yyerror("Icon resource data corrupt");
414 ico->width = ide.width;
415 ico->height = ide.height;
416 ico->nclr = ide.nclr;
417 ico->planes = swap ? BYTESWAP_WORD(ide.planes) : ide.planes;
418 ico->bits = swap ? BYTESWAP_WORD(ide.bits) : ide.bits;
419 convert_bitmap((char *)rd->data + ide.offset, 0);
420 memcpy(&info, rd->data + ide.offset, sizeof(info));
421 if(!ico->planes)
422 {
423 /* Argh! They did not fill out the resdir structure */
424 /* The bitmap is in destination byteorder. We want native for our structures */
425 switch(byteorder)
426 {
427#ifdef WORDS_BIGENDIAN
428 case WRC_BO_LITTLE:
429#else
430 case WRC_BO_BIG:
431#endif
432 ico->planes = BYTESWAP_WORD(info.biPlanes);
433 break;
434 default:
435 ico->planes = info.biPlanes;
436 }
437 }
438 if(!ico->bits)
439 {
440 /* Argh! They did not fill out the resdir structure */
441 /* The bitmap is in destination byteorder. We want native for our structures */
442 switch(byteorder)
443 {
444#ifdef WORDS_BIGENDIAN
445 case WRC_BO_LITTLE:
446#else
447 case WRC_BO_BIG:
448#endif
449 ico->bits = BYTESWAP_WORD(info.biBitCount);
450 break;
451 default:
452 ico->bits = info.biBitCount;
453 }
454 }
455 ico->data = new_raw_data();
456 copy_raw_data(ico->data, rd, ide.offset, ide.ressize);
457 if(!list)
458 {
459 list = ico;
460 }
461 else
462 {
463 ico->next = list;
464 list->prev = ico;
465 list = ico;
466 }
467 }
468 icog->iconlist = list;
469 *nico = cnt;
470}
471
472static void split_cursors(raw_data_t *rd, cursor_group_t *curg, int *ncur)
473{
474 int cnt;
475 int i;
476 cursor_t *cur;
477 cursor_t *list = NULL;
478 cursor_header_t *ch = (cursor_header_t *)rd->data;
479 int swap = 0;
480
481 if(ch->type == 2)
482 swap = 0;
483 else if(BYTESWAP_WORD(ch->type) == 2)
484 swap = 1;
485 else
486 yyerror("Cursor resource data has invalid type id %d", ch->type);
487 cnt = swap ? BYTESWAP_WORD(ch->count) : ch->count;
488 for(i = 0; i < cnt; i++)
489 {
490 cursor_dir_entry_t cde;
491 BITMAPINFOHEADER info;
492 memcpy(&cde, rd->data + sizeof(cursor_header_t)
493 + i*sizeof(cursor_dir_entry_t), sizeof(cde));
494
495 cur = new_cursor();
496 cur->id = alloc_cursor_id(curg->lvc.language);
497 cur->lvc = curg->lvc;
498 if(swap)
499 {
500 cde.offset = BYTESWAP_DWORD(cde.offset);
501 cde.ressize= BYTESWAP_DWORD(cde.ressize);
502 }
503 if(cde.offset > rd->size
504 || cde.offset + cde.ressize > rd->size)
505 yyerror("Cursor resource data corrupt");
506 cur->width = cde.width;
507 cur->height = cde.height;
508 cur->nclr = cde.nclr;
509 convert_bitmap((char *)rd->data + cde.offset, 0);
510 memcpy(&info, rd->data + cde.offset, sizeof(info));
511 /* The bitmap is in destination byteorder. We want native for our structures */
512 switch(byteorder)
513 {
514#ifdef WORDS_BIGENDIAN
515 case WRC_BO_LITTLE:
516#else
517 case WRC_BO_BIG:
518#endif
519 cur->planes = BYTESWAP_WORD(info.biPlanes);
520 cur->bits = BYTESWAP_WORD(info.biBitCount);
521 break;
522 default:
523 cur->planes = info.biPlanes;
524 cur->bits = info.biBitCount;
525 }
526 if(!win32 && (cur->planes != 1 || cur->bits != 1))
527 yywarning("Win16 cursor contains colors");
528 cur->xhot = swap ? BYTESWAP_WORD(cde.xhot) : cde.xhot;
529 cur->yhot = swap ? BYTESWAP_WORD(cde.yhot) : cde.yhot;
530 cur->data = new_raw_data();
531 copy_raw_data(cur->data, rd, cde.offset, cde.ressize);
532 if(!list)
533 {
534 list = cur;
535 }
536 else
537 {
538 cur->next = list;
539 list->prev = cur;
540 list = cur;
541 }
542 }
543 curg->cursorlist = list;
544 *ncur = cnt;
545}
546
547
548icon_group_t *new_icon_group(raw_data_t *rd, int *memopt)
549{
550 icon_group_t *icog = (icon_group_t *)xmalloc(sizeof(icon_group_t));
551 if(memopt)
552 {
553 icog->memopt = *memopt;
554 free(memopt);
555 }
556 else
557 icog->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE | WRC_MO_DISCARDABLE;
558 icog->lvc = rd->lvc;
559 split_icons(rd, icog, &(icog->nicon));
560 free(rd->data);
561 free(rd);
562 return icog;
563}
564
565cursor_group_t *new_cursor_group(raw_data_t *rd, int *memopt)
566{
567 cursor_group_t *curg = (cursor_group_t *)xmalloc(sizeof(cursor_group_t));
568 if(memopt)
569 {
570 curg->memopt = *memopt;
571 free(memopt);
572 }
573 else
574 curg->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE | WRC_MO_DISCARDABLE;
575 curg->lvc = rd->lvc;
576 split_cursors(rd, curg, &(curg->ncursor));
577 free(rd->data);
578 free(rd);
579 return curg;
580}
581
582/*
583 * Animated cursors and icons
584 *
585 * The format of animated cursors and icons is yet another example
586 * of bad design by "The Company". The entire RIFF structure is
587 * flawed by design because it is inconsistent and single minded:
588 * - some tags have lengths attached, others don't. The use of these
589 * non-length tags is absolutely unclear;
590 * - the content of "icon" tags can be both icons and cursors;
591 * - tags lack proper alignment constraints. It seems that everything
592 * is 16bit aligned, but I could not find that in any docu. Just be
593 * prepared to eat anything;
594 * - there are no strict constraints on tag-nesting and the organization
595 * is highly illogical;
596 *
597 * Anyhow, here is the basic structure:
598 * "RIFF" { dword taglength }
599 * "ACON" // What does it do?
600 * "LIST" { dword taglength }
601 * "INFO" // And what does this do?
602 * "INAM" { dword taglength } // Icon/cursor name
603 * {inam data}
604 * "IART" { dword taglength } // The artist
605 * {iart data}
606 * "fram" // Is followed by "icon"s
607 * "icon" { dword taglength } // First frame
608 * { icon/cursor data }
609 * "icon" { dword taglength } // Second frame
610 * { icon/cursor data }
611 * ... // ...
612 * "anih" { dword taglength } // Header structure
613 * { aniheader_t structure }
614 * "rate" { dword taglength } // The rate for each frame
615 * { `steps' dwords }
616 * "seq " { dword taglength } // The frame blit-order
617 * { `steps' dwords }
618 *
619 * Tag length are bytelength without the header and length field (i.e. -8).
620 * The "LIST" tag may occur several times and may encapsulate different
621 * tags. The `steps' is the number of "icon" tags found (actually the
622 * number of steps specified in the aniheader_t structure). The "seq "uence
623 * tag can be ommitted, in which case the sequence is equal to the sequence
624 * of "icon"s found in the file. Also "rate" may be ommitted, in which case
625 * the default from the aniheader_t structure is used.
626 *
627 * An animated cursor puts `.cur' formatted files into each "icon" tag,
628 * whereas animated icons contain `.ico' formatted files.
629 *
630 * Note about the code: Yes, it can be shorter/compressed. Some tags can be
631 * dealt with in the same code. However, this version shows what is going on
632 * and is better debug-able.
633 */
634static const char riff[4] = "RIFF";
635static const char acon[4] = "ACON";
636static const char list[4] = "LIST";
637static const char info[4] = "INFO";
638static const char inam[4] = "INAM";
639static const char iart[4] = "IART";
640static const char fram[4] = "fram";
641static const char icon[4] = "icon";
642static const char anih[4] = "anih";
643static const char rate[4] = "rate";
644static const char seq[4] = "seq ";
645
646#define NEXT_TAG(p) ((riff_tag_t *)(((char *)p) + (isswapped ? BYTESWAP_DWORD(p->size) : p->size) + sizeof(*p)))
647
648static void handle_ani_icon(riff_tag_t *rtp, enum res_e type, int isswapped)
649{
650 cursor_dir_entry_t *cdp;
651 cursor_header_t *chp;
652 int count;
653 int ctype;
654 int i;
655 static int once = 0; /* This will trigger only once per file! */
656 const char *anistr = type == res_aniico ? "icon" : "cursor";
657 /* Notes:
658 * Both cursor and icon directories are similar
659 * Both cursor and icon headers are similar
660 */
661
662 chp = (cursor_header_t *)(rtp+1);
663 cdp = (cursor_dir_entry_t *)(chp+1);
664 count = isswapped ? BYTESWAP_WORD(chp->count) : chp->count;
665 ctype = isswapped ? BYTESWAP_WORD(chp->type) : chp->type;
666 chp->reserved = BYTESWAP_WORD(chp->reserved);
667 chp->type = BYTESWAP_WORD(chp->type);
668 chp->count = BYTESWAP_WORD(chp->count);
669
670 if(type == res_anicur && ctype != 2 && !once)
671 {
672 yywarning("Animated cursor contains invalid \"icon\" tag cursor-file (%d->%s)",
673 ctype,
674 ctype == 1 ? "icontype" : "?");
675 once++;
676 }
677 else if(type == res_aniico && ctype != 1 && !once)
678 {
679 yywarning("Animated icon contains invalid \"icon\" tag icon-file (%d->%s)",
680 ctype,
681 ctype == 2 ? "cursortype" : "?");
682 once++;
683 }
684 else if(ctype != 1 && ctype != 2 && !once)
685 {
686 yywarning("Animated %s contains invalid \"icon\" tag file-type (%d; neither icon nor cursor)", anistr, ctype);
687 once++;
688 }
689
690 for(i = 0; i < count; i++)
691 {
692 DWORD ofs = isswapped ? BYTESWAP_DWORD(cdp[i].offset) : cdp[i].offset;
693 DWORD sze = isswapped ? BYTESWAP_DWORD(cdp[i].ressize) : cdp[i].ressize;
694 if(ofs > rtp->size || ofs+sze > rtp->size)
695 yyerror("Animated %s's data corrupt", anistr);
696 convert_bitmap((char *)chp + ofs, 0);
697 cdp[i].xhot = BYTESWAP_WORD(cdp->xhot);
698 cdp[i].yhot = BYTESWAP_WORD(cdp->yhot);
699 cdp[i].ressize = BYTESWAP_DWORD(cdp->ressize);
700 cdp[i].offset = BYTESWAP_DWORD(cdp->offset);
701 }
702}
703
704static void handle_ani_list(riff_tag_t *lst, enum res_e type, int isswapped)
705{
706 riff_tag_t *rtp = lst+1; /* Skip the "LIST" tag */
707
708 while((char *)rtp < (char *)lst + lst->size + sizeof(*lst))
709 {
710 if(!memcmp(rtp->tag, info, sizeof(info)))
711 {
712 rtp = (riff_tag_t *)(((char *)rtp) + 4);
713 }
714 else if(!memcmp(rtp->tag, inam, sizeof(inam)))
715 {
716 /* Ignore the icon/cursor name; its a string */
717 rtp = NEXT_TAG(rtp);
718 }
719 else if(!memcmp(rtp->tag, iart, sizeof(iart)))
720 {
721 /* Ignore the author's name; its a string */
722 rtp = NEXT_TAG(rtp);
723 }
724 else if(!memcmp(rtp->tag, fram, sizeof(fram)))
725 {
726 /* This should be followed by "icon"s, but we
727 * simply ignore this because it is pure
728 * non-information.
729 */
730 rtp = (riff_tag_t *)(((char *)rtp) + 4);
731 }
732 else if(!memcmp(rtp->tag, icon, sizeof(icon)))
733 {
734 handle_ani_icon(rtp, type, isswapped);
735 rtp = NEXT_TAG(rtp);
736 }
737 else
738 internal_error(__FILE__, __LINE__, "Unknown tag \"%c%c%c%c\" in RIFF file",
739 isprint(rtp->tag[0]) ? rtp->tag[0] : '.',
740 isprint(rtp->tag[1]) ? rtp->tag[1] : '.',
741 isprint(rtp->tag[2]) ? rtp->tag[2] : '.',
742 isprint(rtp->tag[3]) ? rtp->tag[3] : '.');
743
744 /* FIXME: This relies in sizeof(DWORD) == sizeof(pointer_type) */
745 if((DWORD)rtp & 1)
746 rtp = (riff_tag_t*)((char*)rtp + 1);
747 }
748}
749
750ani_curico_t *new_ani_curico(enum res_e type, raw_data_t *rd, int *memopt)
751{
752 ani_curico_t *ani = (ani_curico_t *)xmalloc(sizeof(ani_curico_t));
753 riff_tag_t *rtp;
754 int isswapped = 0;
755 int doswap;
756 const char *anistr = type == res_aniico ? "icon" : "cursor";
757
758 assert(!memcmp(rd->data, riff, sizeof(riff)));
759 assert(type == res_anicur || type == res_aniico);
760
761 rtp = (riff_tag_t *)rd->data;
762
763 if(BYTESWAP_DWORD(rtp->size) + 2*sizeof(DWORD) == rd->size)
764 isswapped = 1;
765 else if(rtp->size + 2*sizeof(DWORD) == rd->size)
766 isswapped = 0;
767 else
768 yyerror("Animated %s has an invalid RIFF length", anistr);
769
770 switch(byteorder)
771 {
772#ifdef WORDS_BIGENDIAN
773 case WRC_BO_LITTLE:
774#else
775 case WRC_BO_BIG:
776#endif
777 doswap = !isswapped;
778 break;
779 default:
780 doswap = isswapped;
781 }
782
783 /*
784 * When to swap what:
785 * isswapped | doswap |
786 * ----------+--------+---------------------------------
787 * 0 | 0 | read native; don't convert
788 * 1 | 0 | read swapped size; don't convert
789 * 0 | 1 | read native; convert
790 * 1 | 1 | read swapped size; convert
791 * Reading swapped size if necessary to calculate in native
792 * format. E.g. a little-endian source on a big-endian
793 * processor.
794 */
795 if(doswap)
796 {
797 /* We only go through the RIFF file if we need to swap
798 * bytes in words/dwords. Else we couldn't care less
799 * what the file contains. This is consistent with
800 * MS' rc.exe, which doesn't complain at all, eventhough
801 * the fileformat might not be entirely correct.
802 */
803 rtp++; /* Skip the "RIFF" tag */
804
805 while((char *)rtp < (char *)rd->data + rd->size)
806 {
807 if(!memcmp(rtp->tag, acon, sizeof(acon)))
808 {
809 rtp = (riff_tag_t *)(((char *)rtp) + 4);
810 }
811 else if(!memcmp(rtp->tag, list, sizeof(list)))
812 {
813 handle_ani_list(rtp, type, isswapped);
814 rtp = NEXT_TAG(rtp);
815 }
816 else if(!memcmp(rtp->tag, anih, sizeof(anih)))
817 {
818 aniheader_t *ahp = (aniheader_t *)((char *)(rtp+1));
819 ahp->structsize = BYTESWAP_DWORD(ahp->structsize);
820 ahp->frames = BYTESWAP_DWORD(ahp->frames);
821 ahp->steps = BYTESWAP_DWORD(ahp->steps);
822 ahp->cx = BYTESWAP_DWORD(ahp->cx);
823 ahp->cy = BYTESWAP_DWORD(ahp->cy);
824 ahp->bitcount = BYTESWAP_DWORD(ahp->bitcount);
825 ahp->planes = BYTESWAP_DWORD(ahp->planes);
826 ahp->rate = BYTESWAP_DWORD(ahp->rate);
827 ahp->flags = BYTESWAP_DWORD(ahp->flags);
828 rtp = NEXT_TAG(rtp);
829 }
830 else if(!memcmp(rtp->tag, rate, sizeof(rate)))
831 {
832 int cnt = rtp->size / sizeof(DWORD);
833 DWORD *dwp = (DWORD *)(rtp+1);
834 int i;
835 for(i = 0; i < cnt; i++)
836 dwp[i] = BYTESWAP_DWORD(dwp[i]);
837 rtp = NEXT_TAG(rtp);
838 }
839 else if(!memcmp(rtp->tag, seq, sizeof(seq)))
840 {
841 int cnt = rtp->size / sizeof(DWORD);
842 DWORD *dwp = (DWORD *)(rtp+1);
843 int i;
844 for(i = 0; i < cnt; i++)
845 dwp[i] = BYTESWAP_DWORD(dwp[i]);
846 rtp = NEXT_TAG(rtp);
847 }
848 else
849 internal_error(__FILE__, __LINE__, "Unknown tag \"%c%c%c%c\" in RIFF file",
850 isprint(rtp->tag[0]) ? rtp->tag[0] : '.',
851 isprint(rtp->tag[1]) ? rtp->tag[1] : '.',
852 isprint(rtp->tag[2]) ? rtp->tag[2] : '.',
853 isprint(rtp->tag[3]) ? rtp->tag[3] : '.');
854
855 /* FIXME: This relies in sizeof(DWORD) == sizeof(pointer_type) */
856 if((DWORD)rtp & 1)
857 rtp = (riff_tag_t*)((char*)rtp + 1);
858 }
859
860 /* We must end correctly here */
861 if((char *)rtp != (char *)rd->data + rd->size)
862 yyerror("Animated %s contains invalid field size(s)", anistr);
863 }
864
865 ani->data = rd;
866 if(memopt)
867 {
868 ani->memopt = *memopt;
869 free(memopt);
870 }
871 else
872 ani->memopt = WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE;
873 return ani;
874}
875#undef NEXT_TAG
876
877/* Bitmaps */
878bitmap_t *new_bitmap(raw_data_t *rd, int *memopt)
879{
880 bitmap_t *bmp = (bitmap_t *)xmalloc(sizeof(bitmap_t));
881
882 bmp->data = rd;
883 if(memopt)
884 {
885 bmp->memopt = *memopt;
886 free(memopt);
887 }
888 else
889 bmp->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
890 rd->size -= convert_bitmap(rd->data, rd->size);
891 return bmp;
892}
893
894ver_words_t *new_ver_words(int i)
895{
896 ver_words_t *w = (ver_words_t *)xmalloc(sizeof(ver_words_t));
897 w->words = (WORD *)xmalloc(sizeof(WORD));
898 w->words[0] = (WORD)i;
899 w->nwords = 1;
900 return w;
901}
902
903ver_words_t *add_ver_words(ver_words_t *w, int i)
904{
905 w->words = (WORD *)xrealloc(w->words, (w->nwords+1) * sizeof(WORD));
906 w->words[w->nwords] = (WORD)i;
907 w->nwords++;
908 return w;
909}
910
911#define MSGTAB_BAD_PTR(p, b, l, r) (((l) - ((char *)(p) - (char *)(b))) > (r))
912messagetable_t *new_messagetable(raw_data_t *rd, int *memopt)
913{
914 messagetable_t *msg = (messagetable_t *)xmalloc(sizeof(messagetable_t));
915 msgtab_block_t *mbp;
916 DWORD nblk;
917 DWORD i;
918 WORD lo;
919 WORD hi;
920
921 msg->data = rd;
922 if(memopt)
923 {
924 msg->memopt = *memopt;
925 free(memopt);
926 }
927 else
928 msg->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
929
930 if(rd->size < sizeof(DWORD))
931 yyerror("Invalid messagetable, size too small");
932
933 nblk = *(DWORD *)rd->data;
934 lo = WRC_LOWORD(nblk);
935 hi = WRC_HIWORD(nblk);
936
937 /* FIXME:
938 * This test will fail for all n*2^16 blocks in the messagetable.
939 * However, no sane person would want to have so many blocks
940 * and have a table of megabytes attached.
941 * So, I will assume that we have less than 2^16 blocks in the table
942 * and all will just work out fine. Otherwise, we would need to test
943 * the ID, offset and length (and flag) fields to be very sure.
944 */
945 if(hi && lo)
946 internal_error(__FILE__, __LINE__, "Messagetable contains more than 65535 blocks; cannot determine endian");
947 if(!hi && !lo)
948 yyerror("Invalid messagetable block count 0");
949
950 if(!hi && lo) /* Messagetable byteorder == native byteorder */
951 {
952#ifdef WORDS_BIGENDIAN
953 if(byteorder != WRC_BO_LITTLE) goto out;
954#else
955 if(byteorder != WRC_BO_BIG) goto out;
956#endif
957 /* Resource byteorder != native byteorder */
958
959 mbp = (msgtab_block_t *)&(((DWORD *)rd->data)[1]);
960 if(MSGTAB_BAD_PTR(mbp, rd->data, rd->size, nblk * sizeof(*mbp)))
961 yyerror("Messagetable's blocks are outside of defined data");
962 for(i = 0; i < nblk; i++)
963 {
964 msgtab_entry_t *mep, *next_mep;
965 DWORD id;
966
967 mep = (msgtab_entry_t *)(((char *)rd->data) + mbp[i].offset);
968
969 for(id = mbp[i].idlo; id <= mbp[i].idhi; id++)
970 {
971 if(MSGTAB_BAD_PTR(mep, rd->data, rd->size, mep->length))
972 yyerror("Messagetable's data for block %d, ID 0x%08lx is outside of defined data", (int)i, id);
973 if(mep->flags == 1) /* Docu says 'flags == 0x0001' for unicode */
974 {
975 WORD *wp = (WORD *)&mep[1];
976 int l = mep->length/2 - 2; /* Length included header */
977 int n;
978
979 if(mep->length & 1)
980 yyerror("Message 0x%08lx is unicode (block %d), but has odd length (%d)", id, (int)i, mep->length);
981 for(n = 0; n < l; n++)
982 wp[n] = BYTESWAP_WORD(wp[n]);
983
984 }
985 next_mep = (msgtab_entry_t *)(((char *)mep) + mep->length);
986 mep->length = BYTESWAP_WORD(mep->length);
987 mep->flags = BYTESWAP_WORD(mep->flags);
988 mep = next_mep;
989 }
990
991 mbp[i].idlo = BYTESWAP_DWORD(mbp[i].idlo);
992 mbp[i].idhi = BYTESWAP_DWORD(mbp[i].idhi);
993 mbp[i].offset = BYTESWAP_DWORD(mbp[i].offset);
994 }
995 }
996 if(hi && !lo) /* Messagetable byteorder != native byteorder */
997 {
998#ifdef WORDS_BIGENDIAN
999 if(byteorder == WRC_BO_LITTLE) goto out;
1000#else
1001 if(byteorder == WRC_BO_BIG) goto out;
1002#endif
1003 /* Resource byteorder == native byteorder */
1004
1005 mbp = (msgtab_block_t *)&(((DWORD *)rd->data)[1]);
1006 nblk = BYTESWAP_DWORD(nblk);
1007 if(MSGTAB_BAD_PTR(mbp, rd->data, rd->size, nblk * sizeof(*mbp)))
1008 yyerror("Messagetable's blocks are outside of defined data");
1009 for(i = 0; i < nblk; i++)
1010 {
1011 msgtab_entry_t *mep;
1012 DWORD id;
1013
1014 mbp[i].idlo = BYTESWAP_DWORD(mbp[i].idlo);
1015 mbp[i].idhi = BYTESWAP_DWORD(mbp[i].idhi);
1016 mbp[i].offset = BYTESWAP_DWORD(mbp[i].offset);
1017 mep = (msgtab_entry_t *)(((char *)rd->data) + mbp[i].offset);
1018
1019 for(id = mbp[i].idlo; id <= mbp[i].idhi; id++)
1020 {
1021 mep->length = BYTESWAP_WORD(mep->length);
1022 mep->flags = BYTESWAP_WORD(mep->flags);
1023
1024 if(MSGTAB_BAD_PTR(mep, rd->data, rd->size, mep->length))
1025 yyerror("Messagetable's data for block %d, ID 0x%08lx is outside of defined data", (int)i, id);
1026 if(mep->flags == 1) /* Docu says 'flags == 0x0001' for unicode */
1027 {
1028 WORD *wp = (WORD *)&mep[1];
1029 int l = mep->length/2 - 2; /* Length included header */
1030 int n;
1031
1032 if(mep->length & 1)
1033 yyerror("Message 0x%08lx is unicode (block %d), but has odd length (%d)", id, (int)i, mep->length);
1034 for(n = 0; n < l; n++)
1035 wp[n] = BYTESWAP_WORD(wp[n]);
1036
1037 }
1038 mep = (msgtab_entry_t *)(((char *)mep) + mep->length);
1039 }
1040 }
1041 }
1042
1043 out:
1044 return msg;
1045}
1046#undef MSGTAB_BAD_PTR
1047
1048void copy_raw_data(raw_data_t *dst, raw_data_t *src, unsigned int offs, int len)
1049{
1050 assert(offs <= src->size);
1051 assert(offs + len <= src->size);
1052 if(!dst->data)
1053 {
1054 dst->data = (char *)xmalloc(len);
1055 dst->size = 0;
1056 }
1057 else
1058 dst->data = (char *)xrealloc(dst->data, dst->size + len);
1059 /* dst->size holds the offset to copy to */
1060 memcpy(dst->data + dst->size, src->data + offs, len);
1061 dst->size += len;
1062}
1063
1064int *new_int(int i)
1065{
1066 int *ip = (int *)xmalloc(sizeof(int));
1067 *ip = i;
1068 return ip;
1069}
1070
1071stringtable_t *new_stringtable(lvc_t *lvc)
1072{
1073 stringtable_t *stt = (stringtable_t *)xmalloc(sizeof(stringtable_t));
1074
1075 if(lvc)
1076 stt->lvc = *lvc;
1077
1078 return stt;
1079}
1080
1081toolbar_t *new_toolbar(int button_width, int button_height, toolbar_item_t *items, int nitems)
1082{
1083 toolbar_t *tb = (toolbar_t *)xmalloc(sizeof(toolbar_t));
1084 tb->button_width = button_width;
1085 tb->button_height = button_height;
1086 tb->nitems = nitems;
1087 tb->items = items;
1088 return tb;
1089}
1090
1091dlginit_t *new_dlginit(raw_data_t *rd, int *memopt)
1092{
1093 dlginit_t *di = (dlginit_t *)xmalloc(sizeof(dlginit_t));
1094 di->data = rd;
1095 if(memopt)
1096 {
1097 di->memopt = *memopt;
1098 free(memopt);
1099 }
1100 else
1101 di->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE | WRC_MO_DISCARDABLE;
1102
1103 return di;
1104}
1105
1106style_pair_t *new_style_pair(style_t *style, style_t *exstyle)
1107{
1108 style_pair_t *sp = (style_pair_t *)xmalloc(sizeof(style_pair_t));
1109 sp->style = style;
1110 sp->exstyle = exstyle;
1111 return sp;
1112}
1113
1114style_t *new_style(DWORD or_mask, DWORD and_mask)
1115{
1116 style_t *st = (style_t *)xmalloc(sizeof(style_t));
1117 st->or_mask = or_mask;
1118 st->and_mask = and_mask;
1119 return st;
1120}
1121
Note: See TracBrowser for help on using the repository browser.