2 * Create dynamic new structures of various types
3 * and some utils in that trend.
5 * Copyright 1998 Bertho A. Stultiens
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
35 #include "wingdi.h" /* for BITMAPINFOHEADER */
48 /* Generate new_* functions that have no parameters (NOTE: no ';') */
49 __NEW_STRUCT_FUNC(dialog
)
50 __NEW_STRUCT_FUNC(dialogex
)
51 __NEW_STRUCT_FUNC(name_id
)
52 __NEW_STRUCT_FUNC(menu
)
53 __NEW_STRUCT_FUNC(menuex
)
54 __NEW_STRUCT_FUNC(menu_item
)
55 __NEW_STRUCT_FUNC(menuex_item
)
56 __NEW_STRUCT_FUNC(control
)
57 __NEW_STRUCT_FUNC(icon
)
58 __NEW_STRUCT_FUNC(cursor
)
59 __NEW_STRUCT_FUNC(versioninfo
)
60 __NEW_STRUCT_FUNC(ver_value
)
61 __NEW_STRUCT_FUNC(ver_block
)
62 __NEW_STRUCT_FUNC(stt_entry
)
63 __NEW_STRUCT_FUNC(accelerator
)
64 __NEW_STRUCT_FUNC(event
)
65 __NEW_STRUCT_FUNC(raw_data
)
66 __NEW_STRUCT_FUNC(lvc
)
67 __NEW_STRUCT_FUNC(res_count
)
68 __NEW_STRUCT_FUNC(string
)
69 __NEW_STRUCT_FUNC(toolbar_item
)
70 __NEW_STRUCT_FUNC(ani_any
)
72 /* New instances for all types of structures */
73 /* Very inefficient (in size), but very functional :-]
74 * Especially for type-checking.
76 resource_t
*new_resource(enum res_e t
, void *res
, int memopt
, language_t
*lan
)
78 resource_t
*r
= (resource_t
*)xmalloc(sizeof(resource_t
));
86 version_t
*new_version(DWORD v
)
88 version_t
*vp
= (version_t
*)xmalloc(sizeof(version_t
));
93 characts_t
*new_characts(DWORD c
)
95 characts_t
*cp
= (characts_t
*)xmalloc(sizeof(characts_t
));
100 language_t
*new_language(int id
, int sub
)
102 language_t
*lan
= (language_t
*)xmalloc(sizeof(language_t
));
108 language_t
*dup_language(language_t
*l
)
111 return new_language(l
->id
, l
->sub
);
114 version_t
*dup_version(version_t
*v
)
117 return new_version(*v
);
120 characts_t
*dup_characts(characts_t
*c
)
123 return new_characts(*c
);
126 html_t
*new_html(raw_data_t
*rd
, int *memopt
)
128 html_t
*html
= xmalloc(sizeof(html_t
));
132 html
->memopt
= *memopt
;
136 html
->memopt
= WRC_MO_MOVEABLE
| WRC_MO_PURE
;
140 rcdata_t
*new_rcdata(raw_data_t
*rd
, int *memopt
)
142 rcdata_t
*rc
= (rcdata_t
*)xmalloc(sizeof(rcdata_t
));
146 rc
->memopt
= *memopt
;
150 rc
->memopt
= WRC_MO_MOVEABLE
| WRC_MO_PURE
;
154 font_id_t
*new_font_id(int size
, string_t
*face
, int weight
, int italic
)
156 font_id_t
*fid
= (font_id_t
*)xmalloc(sizeof(font_id_t
));
159 fid
->weight
= weight
;
160 fid
->italic
= italic
;
164 user_t
*new_user(name_id_t
*type
, raw_data_t
*rd
, int *memopt
)
166 user_t
*usr
= (user_t
*)xmalloc(sizeof(user_t
));
170 usr
->memopt
= *memopt
;
174 usr
->memopt
= WRC_MO_MOVEABLE
| WRC_MO_PURE
;
179 font_t
*new_font(raw_data_t
*rd
, int *memopt
)
181 font_t
*fnt
= (font_t
*)xmalloc(sizeof(font_t
));
185 fnt
->memopt
= *memopt
;
189 fnt
->memopt
= WRC_MO_MOVEABLE
| WRC_MO_DISCARDABLE
;
193 fontdir_t
*new_fontdir(raw_data_t
*rd
, int *memopt
)
195 fontdir_t
*fnd
= (fontdir_t
*)xmalloc(sizeof(fontdir_t
));
199 fnd
->memopt
= *memopt
;
203 fnd
->memopt
= WRC_MO_MOVEABLE
| WRC_MO_DISCARDABLE
;
209 * Convert bitmaps to proper endian
211 static void convert_bitmap_swap_v3(BITMAPINFOHEADER
*bih
)
213 bih
->biSize
= BYTESWAP_DWORD(bih
->biSize
);
214 bih
->biWidth
= BYTESWAP_DWORD(bih
->biWidth
);
215 bih
->biHeight
= BYTESWAP_DWORD(bih
->biHeight
);
216 bih
->biPlanes
= BYTESWAP_WORD(bih
->biPlanes
);
217 bih
->biBitCount
= BYTESWAP_WORD(bih
->biBitCount
);
218 bih
->biCompression
= BYTESWAP_DWORD(bih
->biCompression
);
219 bih
->biSizeImage
= BYTESWAP_DWORD(bih
->biSizeImage
);
220 bih
->biXPelsPerMeter
= BYTESWAP_DWORD(bih
->biXPelsPerMeter
);
221 bih
->biYPelsPerMeter
= BYTESWAP_DWORD(bih
->biYPelsPerMeter
);
222 bih
->biClrUsed
= BYTESWAP_DWORD(bih
->biClrUsed
);
223 bih
->biClrImportant
= BYTESWAP_DWORD(bih
->biClrImportant
);
226 static void convert_bitmap_swap_v4(BITMAPV4HEADER
*b4h
)
228 convert_bitmap_swap_v3((BITMAPINFOHEADER
*)b4h
);
229 b4h
->bV4RedMask
= BYTESWAP_DWORD(b4h
->bV4RedMask
);
230 b4h
->bV4GreenMask
= BYTESWAP_DWORD(b4h
->bV4GreenMask
);
231 b4h
->bV4BlueMask
= BYTESWAP_DWORD(b4h
->bV4BlueMask
);
232 b4h
->bV4AlphaMask
= BYTESWAP_DWORD(b4h
->bV4AlphaMask
);
233 b4h
->bV4CSType
= BYTESWAP_DWORD(b4h
->bV4CSType
);
234 b4h
->bV4Endpoints
.ciexyzRed
.ciexyzX
= BYTESWAP_DWORD(b4h
->bV4Endpoints
.ciexyzRed
.ciexyzX
);
235 b4h
->bV4Endpoints
.ciexyzRed
.ciexyzY
= BYTESWAP_DWORD(b4h
->bV4Endpoints
.ciexyzRed
.ciexyzY
);
236 b4h
->bV4Endpoints
.ciexyzRed
.ciexyzZ
= BYTESWAP_DWORD(b4h
->bV4Endpoints
.ciexyzRed
.ciexyzZ
);
237 b4h
->bV4Endpoints
.ciexyzGreen
.ciexyzX
= BYTESWAP_DWORD(b4h
->bV4Endpoints
.ciexyzGreen
.ciexyzX
);
238 b4h
->bV4Endpoints
.ciexyzGreen
.ciexyzY
= BYTESWAP_DWORD(b4h
->bV4Endpoints
.ciexyzGreen
.ciexyzY
);
239 b4h
->bV4Endpoints
.ciexyzGreen
.ciexyzZ
= BYTESWAP_DWORD(b4h
->bV4Endpoints
.ciexyzGreen
.ciexyzZ
);
240 b4h
->bV4Endpoints
.ciexyzBlue
.ciexyzX
= BYTESWAP_DWORD(b4h
->bV4Endpoints
.ciexyzBlue
.ciexyzX
);
241 b4h
->bV4Endpoints
.ciexyzBlue
.ciexyzY
= BYTESWAP_DWORD(b4h
->bV4Endpoints
.ciexyzBlue
.ciexyzY
);
242 b4h
->bV4Endpoints
.ciexyzBlue
.ciexyzZ
= BYTESWAP_DWORD(b4h
->bV4Endpoints
.ciexyzBlue
.ciexyzZ
);
243 b4h
->bV4GammaRed
= BYTESWAP_DWORD(b4h
->bV4GammaRed
);
244 b4h
->bV4GammaGreen
= BYTESWAP_DWORD(b4h
->bV4GammaGreen
);
245 b4h
->bV4GammaBlue
= BYTESWAP_DWORD(b4h
->bV4GammaBlue
);
248 static void convert_bitmap_swap_os2(BITMAPOS2HEADER
*boh
)
250 boh
->biSize
= BYTESWAP_DWORD(boh
->biSize
);
251 boh
->biWidth
= BYTESWAP_WORD(boh
->biWidth
);
252 boh
->biHeight
= BYTESWAP_WORD(boh
->biHeight
);
253 boh
->biPlanes
= BYTESWAP_WORD(boh
->biPlanes
);
254 boh
->biBitCount
= BYTESWAP_WORD(boh
->biBitCount
);
257 #define FL_SIGBE 0x01
258 #define FL_SIZEBE 0x02
261 static int convert_bitmap(char *data
, int size
)
263 BITMAPINFOHEADER
*bih
= (BITMAPINFOHEADER
*)data
;
264 BITMAPV4HEADER
*b4h
= (BITMAPV4HEADER
*)data
;
265 BITMAPOS2HEADER
*boh
= (BITMAPOS2HEADER
*)data
;
267 int returnSize
= 0; /* size to be returned */
268 #ifdef WORDS_BIGENDIAN
269 DWORD bisizel
= BYTESWAP_DWORD(sizeof(BITMAPINFOHEADER
));
270 DWORD b4sizel
= BYTESWAP_DWORD(sizeof(BITMAPV4HEADER
));
271 DWORD bosizel
= BYTESWAP_DWORD(sizeof(BITMAPOS2HEADER
));
272 DWORD bisizeb
= sizeof(BITMAPINFOHEADER
);
273 DWORD b4sizeb
= sizeof(BITMAPV4HEADER
);
274 DWORD bosizeb
= sizeof(BITMAPOS2HEADER
);
276 DWORD bisizel
= sizeof(BITMAPINFOHEADER
);
277 DWORD b4sizel
= sizeof(BITMAPV4HEADER
);
278 DWORD bosizel
= sizeof(BITMAPOS2HEADER
);
279 DWORD bisizeb
= BYTESWAP_DWORD(sizeof(BITMAPINFOHEADER
));
280 DWORD b4sizeb
= BYTESWAP_DWORD(sizeof(BITMAPV4HEADER
));
281 DWORD bosizeb
= BYTESWAP_DWORD(sizeof(BITMAPOS2HEADER
));
286 * Originally the bih and b4h pointers were simply incremented here,
287 * and memmoved at the end of the function. This causes alignment
288 * issues on solaris, so we do the memmove here rather than at the end.
290 if(data
[0] == 'B' && data
[1] == 'M')
292 /* Little endian signature */
293 memmove(data
, data
+sizeof(BITMAPFILEHEADER
), size
- sizeof(BITMAPFILEHEADER
));
294 returnSize
= sizeof(BITMAPFILEHEADER
);
296 else if(data
[0] == 'M' && data
[1] == 'B')
298 type
|= FL_SIGBE
; /* Big endian signature */
299 memmove(data
, data
+sizeof(BITMAPFILEHEADER
), size
- sizeof(BITMAPFILEHEADER
));
300 returnSize
= sizeof(BITMAPFILEHEADER
);
304 if(bih
->biSize
== bisizel
)
308 else if(bih
->biSize
== bisizeb
)
312 else if(bih
->biSize
== b4sizel
)
316 else if(bih
->biSize
== b4sizeb
)
318 type
|= FL_SIZEBE
| FL_V4
;
320 else if(!bih
->biSize
|| bih
->biSize
== bosizel
)
324 else if(bih
->biSize
== bosizeb
)
326 type
|= FL_SIZEBE
| FL_OS2
;
330 fprintf(stderr
, "bisizel %d bosizel %d b4sizel %d\n", bisizel
, bosizel
, b4sizel
);
331 yyerror("Invalid bitmap format, bih->biSize = %ld", bih
->biSize
);
339 case FL_SIZEBE
| FL_V4
:
340 case FL_SIZEBE
| FL_OS2
:
341 yywarning("Bitmap v%c signature little-endian, but size big-endian", type
& FL_V4
? '4' : '3');
344 case FL_SIGBE
| FL_V4
:
345 case FL_SIGBE
| FL_OS2
:
346 yywarning("Bitmap v%c signature big-endian, but size little-endian", type
& FL_V4
? '4' : '3');
352 #ifdef WORDS_BIGENDIAN
356 if(!(type
& FL_SIZEBE
))
359 convert_bitmap_swap_v4(b4h
);
360 else if(type
& FL_OS2
)
362 convert_bitmap_swap_os2(boh
);
365 convert_bitmap_swap_v3(bih
);
368 #ifndef WORDS_BIGENDIAN
375 convert_bitmap_swap_v4(b4h
);
376 else if(type
& FL_OS2
)
378 convert_bitmap_swap_os2(boh
);
381 convert_bitmap_swap_v3(bih
);
386 if(size
&& (void *)data
!= (void *)bih
)
388 /* We have the fileheader still attached, remove it */
389 memmove(data
, data
+sizeof(BITMAPFILEHEADER
), size
- sizeof(BITMAPFILEHEADER
));
390 return sizeof(BITMAPFILEHEADER
);
399 * Cursor and icon splitter functions used when allocating
400 * cursor- and icon-groups.
407 static int get_new_id(id_alloc_t
**list
, int *n
, language_t
*lan
)
411 assert(list
!= NULL
);
416 *list
= (id_alloc_t
*)xmalloc(sizeof(id_alloc_t
));
418 (*list
)[0].lan
= *lan
;
423 for(i
= 0; i
< *n
; i
++)
425 if((*list
)[i
].lan
.id
== lan
->id
&& (*list
)[i
].lan
.sub
== lan
->sub
)
426 return ++((*list
)[i
].id
);
429 *list
= (id_alloc_t
*)xrealloc(*list
, sizeof(id_alloc_t
) * (*n
+1));
430 (*list
)[*n
].lan
= *lan
;
436 static int alloc_icon_id(language_t
*lan
)
438 static id_alloc_t
*idlist
= NULL
;
441 return get_new_id(&idlist
, &nid
, lan
);
444 static int alloc_cursor_id(language_t
*lan
)
446 static id_alloc_t
*idlist
= NULL
;
449 return get_new_id(&idlist
, &nid
, lan
);
452 static void split_icons(raw_data_t
*rd
, icon_group_t
*icog
, int *nico
)
458 icon_header_t
*ih
= (icon_header_t
*)rd
->data
;
463 else if(BYTESWAP_WORD(ih
->type
) == 1)
466 yyerror("Icon resource data has invalid type id %d", ih
->type
);
468 cnt
= swap
? BYTESWAP_WORD(ih
->count
) : ih
->count
;
469 for(i
= 0; i
< cnt
; i
++)
471 icon_dir_entry_t ide
;
472 BITMAPINFOHEADER info
;
473 memcpy(&ide
, rd
->data
+ sizeof(icon_header_t
)
474 + i
*sizeof(icon_dir_entry_t
), sizeof(ide
));
477 ico
->id
= alloc_icon_id(icog
->lvc
.language
);
478 ico
->lvc
= icog
->lvc
;
481 ide
.offset
= BYTESWAP_DWORD(ide
.offset
);
482 ide
.ressize
= BYTESWAP_DWORD(ide
.ressize
);
484 if(ide
.offset
> rd
->size
485 || ide
.offset
+ ide
.ressize
> rd
->size
)
486 yyerror("Icon resource data corrupt");
487 ico
->width
= ide
.width
;
488 ico
->height
= ide
.height
;
489 ico
->nclr
= ide
.nclr
;
490 ico
->planes
= swap
? BYTESWAP_WORD(ide
.planes
) : ide
.planes
;
491 ico
->bits
= swap
? BYTESWAP_WORD(ide
.bits
) : ide
.bits
;
492 memcpy(&info
, rd
->data
+ ide
.offset
, sizeof(info
));
493 convert_bitmap((char *) &info
, 0);
494 memcpy(rd
->data
+ ide
.offset
, &info
, sizeof(info
));
498 /* Argh! They did not fill out the resdir structure */
499 /* The bitmap is in destination byteorder. We want native for our structures */
502 #ifdef WORDS_BIGENDIAN
507 ico
->planes
= BYTESWAP_WORD(info
.biPlanes
);
510 ico
->planes
= info
.biPlanes
;
515 /* Argh! They did not fill out the resdir structure */
516 /* The bitmap is in destination byteorder. We want native for our structures */
519 #ifdef WORDS_BIGENDIAN
524 ico
->bits
= BYTESWAP_WORD(info
.biBitCount
);
527 ico
->bits
= info
.biBitCount
;
530 ico
->data
= new_raw_data();
531 copy_raw_data(ico
->data
, rd
, ide
.offset
, ide
.ressize
);
543 icog
->iconlist
= list
;
547 static void split_cursors(raw_data_t
*rd
, cursor_group_t
*curg
, int *ncur
)
552 cursor_t
*list
= NULL
;
553 cursor_header_t
*ch
= (cursor_header_t
*)rd
->data
;
558 else if(BYTESWAP_WORD(ch
->type
) == 2)
561 yyerror("Cursor resource data has invalid type id %d", ch
->type
);
562 cnt
= swap
? BYTESWAP_WORD(ch
->count
) : ch
->count
;
563 for(i
= 0; i
< cnt
; i
++)
565 cursor_dir_entry_t cde
;
566 BITMAPINFOHEADER info
;
567 memcpy(&cde
, rd
->data
+ sizeof(cursor_header_t
)
568 + i
*sizeof(cursor_dir_entry_t
), sizeof(cde
));
571 cur
->id
= alloc_cursor_id(curg
->lvc
.language
);
572 cur
->lvc
= curg
->lvc
;
575 cde
.offset
= BYTESWAP_DWORD(cde
.offset
);
576 cde
.ressize
= BYTESWAP_DWORD(cde
.ressize
);
578 if(cde
.offset
> rd
->size
579 || cde
.offset
+ cde
.ressize
> rd
->size
)
580 yyerror("Cursor resource data corrupt");
581 cur
->width
= cde
.width
;
582 cur
->height
= cde
.height
;
583 cur
->nclr
= cde
.nclr
;
584 memcpy(&info
, rd
->data
+ cde
.offset
, sizeof(info
));
585 convert_bitmap((char *)&info
, 0);
586 memcpy(rd
->data
+ cde
.offset
, &info
, sizeof(info
));
587 /* The bitmap is in destination byteorder. We want native for our structures */
590 #ifdef WORDS_BIGENDIAN
595 cur
->planes
= BYTESWAP_WORD(info
.biPlanes
);
596 cur
->bits
= BYTESWAP_WORD(info
.biBitCount
);
599 cur
->planes
= info
.biPlanes
;
600 cur
->bits
= info
.biBitCount
;
602 if(!win32
&& (cur
->planes
!= 1 || cur
->bits
!= 1))
603 yywarning("Win16 cursor contains colors");
604 cur
->xhot
= swap
? BYTESWAP_WORD(cde
.xhot
) : cde
.xhot
;
605 cur
->yhot
= swap
? BYTESWAP_WORD(cde
.yhot
) : cde
.yhot
;
606 cur
->data
= new_raw_data();
607 copy_raw_data(cur
->data
, rd
, cde
.offset
, cde
.ressize
);
619 curg
->cursorlist
= list
;
624 icon_group_t
*new_icon_group(raw_data_t
*rd
, int *memopt
)
626 icon_group_t
*icog
= (icon_group_t
*)xmalloc(sizeof(icon_group_t
));
629 icog
->memopt
= *memopt
;
633 icog
->memopt
= WRC_MO_MOVEABLE
| WRC_MO_PURE
| WRC_MO_DISCARDABLE
;
635 split_icons(rd
, icog
, &(icog
->nicon
));
641 cursor_group_t
*new_cursor_group(raw_data_t
*rd
, int *memopt
)
643 cursor_group_t
*curg
= (cursor_group_t
*)xmalloc(sizeof(cursor_group_t
));
646 curg
->memopt
= *memopt
;
650 curg
->memopt
= WRC_MO_MOVEABLE
| WRC_MO_PURE
| WRC_MO_DISCARDABLE
;
652 split_cursors(rd
, curg
, &(curg
->ncursor
));
659 * Animated cursors and icons
661 * The format of animated cursors and icons is yet another example
662 * of bad design by "The Company". The entire RIFF structure is
663 * flawed by design because it is inconsistent and single minded:
664 * - some tags have lengths attached, others don't. The use of these
665 * non-length tags is absolutely unclear;
666 * - the content of "icon" tags can be both icons and cursors;
667 * - tags lack proper alignment constraints. It seems that everything
668 * is 16bit aligned, but I could not find that in any docu. Just be
669 * prepared to eat anything;
670 * - there are no strict constraints on tag-nesting and the organization
671 * is highly illogical;
673 * Anyhow, here is the basic structure:
674 * "RIFF" { dword taglength }
675 * "ACON" // What does it do?
676 * "LIST" { dword taglength }
677 * "INFO" // And what does this do?
678 * "INAM" { dword taglength } // Icon/cursor name
680 * "IART" { dword taglength } // The artist
682 * "fram" // Is followed by "icon"s
683 * "icon" { dword taglength } // First frame
684 * { icon/cursor data }
685 * "icon" { dword taglength } // Second frame
686 * { icon/cursor data }
688 * "anih" { dword taglength } // Header structure
689 * { aniheader_t structure }
690 * "rate" { dword taglength } // The rate for each frame
692 * "seq " { dword taglength } // The frame blit-order
695 * Tag length are bytelength without the header and length field (i.e. -8).
696 * The "LIST" tag may occur several times and may encapsulate different
697 * tags. The `steps' is the number of "icon" tags found (actually the
698 * number of steps specified in the aniheader_t structure). The "seq "uence
699 * tag can be omitted, in which case the sequence is equal to the sequence
700 * of "icon"s found in the file. Also "rate" may be omitted, in which case
701 * the default from the aniheader_t structure is used.
703 * An animated cursor puts `.cur' formatted files into each "icon" tag,
704 * whereas animated icons contain `.ico' formatted files.
706 * Note about the code: Yes, it can be shorter/compressed. Some tags can be
707 * dealt with in the same code. However, this version shows what is going on
708 * and is better debug-able.
710 static const char riff
[4] = "RIFF";
711 static const char acon
[4] = "ACON";
712 static const char list
[4] = "LIST";
713 static const char info
[4] = "INFO";
714 static const char inam
[4] = "INAM";
715 static const char iart
[4] = "IART";
716 static const char fram
[4] = "fram";
717 static const char icon
[4] = "icon";
718 static const char anih
[4] = "anih";
719 static const char rate
[4] = "rate";
720 static const char seq
[4] = "seq ";
722 #define SKIP_TAG(p,size) ((riff_tag_t *)(((char *)p) + (size)))
724 #define NEXT_TAG(p) SKIP_TAG(p,(isswapped ? BYTESWAP_DWORD(p->size) : p->size) + sizeof(*p))
726 static void handle_ani_icon(riff_tag_t
*rtp
, enum res_e type
, int isswapped
)
728 cursor_dir_entry_t
*cdp
;
729 cursor_header_t
*chp
;
733 static int once
= 0; /* This will trigger only once per file! */
734 const char *anistr
= type
== res_aniico
? "icon" : "cursor";
736 * Both cursor and icon directories are similar
737 * Both cursor and icon headers are similar
740 chp
= (cursor_header_t
*)(rtp
+1);
741 cdp
= (cursor_dir_entry_t
*)(chp
+1);
742 count
= isswapped
? BYTESWAP_WORD(chp
->count
) : chp
->count
;
743 ctype
= isswapped
? BYTESWAP_WORD(chp
->type
) : chp
->type
;
744 chp
->reserved
= BYTESWAP_WORD(chp
->reserved
);
745 chp
->type
= BYTESWAP_WORD(chp
->type
);
746 chp
->count
= BYTESWAP_WORD(chp
->count
);
748 if(type
== res_anicur
&& ctype
!= 2 && !once
)
750 yywarning("Animated cursor contains invalid \"icon\" tag cursor-file (%d->%s)",
752 ctype
== 1 ? "icontype" : "?");
755 else if(type
== res_aniico
&& ctype
!= 1 && !once
)
757 yywarning("Animated icon contains invalid \"icon\" tag icon-file (%d->%s)",
759 ctype
== 2 ? "cursortype" : "?");
762 else if(ctype
!= 1 && ctype
!= 2 && !once
)
764 yywarning("Animated %s contains invalid \"icon\" tag file-type (%d; neither icon nor cursor)", anistr
, ctype
);
768 for(i
= 0; i
< count
; i
++)
770 DWORD ofs
= isswapped
? BYTESWAP_DWORD(cdp
[i
].offset
) : cdp
[i
].offset
;
771 DWORD sze
= isswapped
? BYTESWAP_DWORD(cdp
[i
].ressize
) : cdp
[i
].ressize
;
772 if(ofs
> rtp
->size
|| ofs
+sze
> rtp
->size
)
773 yyerror("Animated %s's data corrupt", anistr
);
774 convert_bitmap((char *)chp
+ ofs
, 0);
775 cdp
[i
].xhot
= BYTESWAP_WORD(cdp
->xhot
);
776 cdp
[i
].yhot
= BYTESWAP_WORD(cdp
->yhot
);
777 cdp
[i
].ressize
= BYTESWAP_DWORD(cdp
->ressize
);
778 cdp
[i
].offset
= BYTESWAP_DWORD(cdp
->offset
);
782 static void handle_ani_list(riff_tag_t
*lst
, enum res_e type
, int isswapped
)
784 riff_tag_t
*rtp
= lst
+1; /* Skip the "LIST" tag */
786 while((char *)rtp
< (char *)lst
+ lst
->size
+ sizeof(*lst
))
788 if(!memcmp(rtp
->tag
, info
, sizeof(info
)))
790 rtp
= SKIP_TAG(rtp
,4);
792 else if(!memcmp(rtp
->tag
, inam
, sizeof(inam
)))
794 /* Ignore the icon/cursor name; its a string */
797 else if(!memcmp(rtp
->tag
, iart
, sizeof(iart
)))
799 /* Ignore the author's name; its a string */
802 else if(!memcmp(rtp
->tag
, fram
, sizeof(fram
)))
804 /* This should be followed by "icon"s, but we
805 * simply ignore this because it is pure
808 rtp
= SKIP_TAG(rtp
,4);
810 else if(!memcmp(rtp
->tag
, icon
, sizeof(icon
)))
812 handle_ani_icon(rtp
, type
, isswapped
);
816 internal_error(__FILE__
, __LINE__
, "Unknown tag \"%c%c%c%c\" in RIFF file",
817 isprint(rtp
->tag
[0]) ? rtp
->tag
[0] : '.',
818 isprint(rtp
->tag
[1]) ? rtp
->tag
[1] : '.',
819 isprint(rtp
->tag
[2]) ? rtp
->tag
[2] : '.',
820 isprint(rtp
->tag
[3]) ? rtp
->tag
[3] : '.');
822 if((UINT_PTR
)rtp
& 1)
823 rtp
= SKIP_TAG(rtp
,1);
827 ani_curico_t
*new_ani_curico(enum res_e type
, raw_data_t
*rd
, int *memopt
)
829 ani_curico_t
*ani
= (ani_curico_t
*)xmalloc(sizeof(ani_curico_t
));
833 const char *anistr
= type
== res_aniico
? "icon" : "cursor";
835 assert(!memcmp(rd
->data
, riff
, sizeof(riff
)));
836 assert(type
== res_anicur
|| type
== res_aniico
);
838 rtp
= (riff_tag_t
*)rd
->data
;
840 if(BYTESWAP_DWORD(rtp
->size
) + 2*sizeof(DWORD
) == rd
->size
)
842 else if(rtp
->size
+ 2*sizeof(DWORD
) == rd
->size
)
845 yyerror("Animated %s has an invalid RIFF length", anistr
);
849 #ifdef WORDS_BIGENDIAN
862 * isswapped | doswap |
863 * ----------+--------+---------------------------------
864 * 0 | 0 | read native; don't convert
865 * 1 | 0 | read swapped size; don't convert
866 * 0 | 1 | read native; convert
867 * 1 | 1 | read swapped size; convert
868 * Reading swapped size if necessary to calculate in native
869 * format. E.g. a little-endian source on a big-endian
874 /* We only go through the RIFF file if we need to swap
875 * bytes in words/dwords. Else we couldn't care less
876 * what the file contains. This is consistent with
877 * MS' rc.exe, which doesn't complain at all, even though
878 * the file format might not be entirely correct.
880 rtp
++; /* Skip the "RIFF" tag */
882 while((char *)rtp
< (char *)rd
->data
+ rd
->size
)
884 if(!memcmp(rtp
->tag
, acon
, sizeof(acon
)))
886 rtp
= SKIP_TAG(rtp
,4);
888 else if(!memcmp(rtp
->tag
, list
, sizeof(list
)))
890 handle_ani_list(rtp
, type
, isswapped
);
893 else if(!memcmp(rtp
->tag
, anih
, sizeof(anih
)))
895 aniheader_t
*ahp
= (aniheader_t
*)((char *)(rtp
+1));
896 ahp
->structsize
= BYTESWAP_DWORD(ahp
->structsize
);
897 ahp
->frames
= BYTESWAP_DWORD(ahp
->frames
);
898 ahp
->steps
= BYTESWAP_DWORD(ahp
->steps
);
899 ahp
->cx
= BYTESWAP_DWORD(ahp
->cx
);
900 ahp
->cy
= BYTESWAP_DWORD(ahp
->cy
);
901 ahp
->bitcount
= BYTESWAP_DWORD(ahp
->bitcount
);
902 ahp
->planes
= BYTESWAP_DWORD(ahp
->planes
);
903 ahp
->rate
= BYTESWAP_DWORD(ahp
->rate
);
904 ahp
->flags
= BYTESWAP_DWORD(ahp
->flags
);
907 else if(!memcmp(rtp
->tag
, rate
, sizeof(rate
)))
909 int cnt
= rtp
->size
/ sizeof(DWORD
);
910 DWORD
*dwp
= (DWORD
*)(rtp
+1);
912 for(i
= 0; i
< cnt
; i
++)
913 dwp
[i
] = BYTESWAP_DWORD(dwp
[i
]);
916 else if(!memcmp(rtp
->tag
, seq
, sizeof(seq
)))
918 int cnt
= rtp
->size
/ sizeof(DWORD
);
919 DWORD
*dwp
= (DWORD
*)(rtp
+1);
921 for(i
= 0; i
< cnt
; i
++)
922 dwp
[i
] = BYTESWAP_DWORD(dwp
[i
]);
926 internal_error(__FILE__
, __LINE__
, "Unknown tag \"%c%c%c%c\" in RIFF file",
927 isprint(rtp
->tag
[0]) ? rtp
->tag
[0] : '.',
928 isprint(rtp
->tag
[1]) ? rtp
->tag
[1] : '.',
929 isprint(rtp
->tag
[2]) ? rtp
->tag
[2] : '.',
930 isprint(rtp
->tag
[3]) ? rtp
->tag
[3] : '.');
932 if((UINT_PTR
)rtp
& 1)
933 rtp
= SKIP_TAG(rtp
,1);
936 /* We must end correctly here */
937 if((char *)rtp
!= (char *)rd
->data
+ rd
->size
)
938 yyerror("Animated %s contains invalid field size(s)", anistr
);
944 ani
->memopt
= *memopt
;
948 ani
->memopt
= WRC_MO_MOVEABLE
| WRC_MO_DISCARDABLE
;
954 bitmap_t
*new_bitmap(raw_data_t
*rd
, int *memopt
)
956 bitmap_t
*bmp
= (bitmap_t
*)xmalloc(sizeof(bitmap_t
));
961 bmp
->memopt
= *memopt
;
965 bmp
->memopt
= WRC_MO_MOVEABLE
| WRC_MO_PURE
;
966 rd
->size
-= convert_bitmap(rd
->data
, rd
->size
);
970 ver_words_t
*new_ver_words(int i
)
972 ver_words_t
*w
= (ver_words_t
*)xmalloc(sizeof(ver_words_t
));
973 w
->words
= (WORD
*)xmalloc(sizeof(WORD
));
974 w
->words
[0] = (WORD
)i
;
979 ver_words_t
*add_ver_words(ver_words_t
*w
, int i
)
981 w
->words
= (WORD
*)xrealloc(w
->words
, (w
->nwords
+1) * sizeof(WORD
));
982 w
->words
[w
->nwords
] = (WORD
)i
;
987 #define MSGTAB_BAD_PTR(p, b, l, r) (((l) - ((char *)(p) - (char *)(b))) > (r))
988 messagetable_t
*new_messagetable(raw_data_t
*rd
, int *memopt
)
990 messagetable_t
*msg
= (messagetable_t
*)xmalloc(sizeof(messagetable_t
));
1000 msg
->memopt
= *memopt
;
1004 msg
->memopt
= WRC_MO_MOVEABLE
| WRC_MO_PURE
;
1006 if(rd
->size
< sizeof(DWORD
))
1007 yyerror("Invalid messagetable, size too small");
1009 nblk
= *(DWORD
*)rd
->data
;
1010 lo
= WRC_LOWORD(nblk
);
1011 hi
= WRC_HIWORD(nblk
);
1014 * This test will fail for all n*2^16 blocks in the messagetable.
1015 * However, no sane person would want to have so many blocks
1016 * and have a table of megabytes attached.
1017 * So, I will assume that we have less than 2^16 blocks in the table
1018 * and all will just work out fine. Otherwise, we would need to test
1019 * the ID, offset and length (and flag) fields to be very sure.
1022 internal_error(__FILE__
, __LINE__
, "Messagetable contains more than 65535 blocks; cannot determine endian");
1024 yyerror("Invalid messagetable block count 0");
1026 if(!hi
&& lo
) /* Messagetable byteorder == native byteorder */
1028 #ifdef WORDS_BIGENDIAN
1029 if(byteorder
!= WRC_BO_LITTLE
) goto out
;
1031 if(byteorder
!= WRC_BO_BIG
) goto out
;
1033 /* Resource byteorder != native byteorder */
1035 mbp
= (msgtab_block_t
*)&(((DWORD
*)rd
->data
)[1]);
1036 if(MSGTAB_BAD_PTR(mbp
, rd
->data
, rd
->size
, nblk
* sizeof(*mbp
)))
1037 yyerror("Messagetable's blocks are outside of defined data");
1038 for(i
= 0; i
< nblk
; i
++)
1040 msgtab_entry_t
*mep
, *next_mep
;
1043 mep
= (msgtab_entry_t
*)(((char *)rd
->data
) + mbp
[i
].offset
);
1045 for(id
= mbp
[i
].idlo
; id
<= mbp
[i
].idhi
; id
++)
1047 if(MSGTAB_BAD_PTR(mep
, rd
->data
, rd
->size
, mep
->length
))
1048 yyerror("Messagetable's data for block %d, ID 0x%08lx is outside of defined data", (int)i
, id
);
1049 if(mep
->flags
== 1) /* Docu says 'flags == 0x0001' for unicode */
1051 WORD
*wp
= (WORD
*)&mep
[1];
1052 int l
= mep
->length
/2 - 2; /* Length included header */
1056 yyerror("Message 0x%08lx is unicode (block %d), but has odd length (%d)", id
, (int)i
, mep
->length
);
1057 for(n
= 0; n
< l
; n
++)
1058 wp
[n
] = BYTESWAP_WORD(wp
[n
]);
1061 next_mep
= (msgtab_entry_t
*)(((char *)mep
) + mep
->length
);
1062 mep
->length
= BYTESWAP_WORD(mep
->length
);
1063 mep
->flags
= BYTESWAP_WORD(mep
->flags
);
1067 mbp
[i
].idlo
= BYTESWAP_DWORD(mbp
[i
].idlo
);
1068 mbp
[i
].idhi
= BYTESWAP_DWORD(mbp
[i
].idhi
);
1069 mbp
[i
].offset
= BYTESWAP_DWORD(mbp
[i
].offset
);
1072 if(hi
&& !lo
) /* Messagetable byteorder != native byteorder */
1074 #ifdef WORDS_BIGENDIAN
1075 if(byteorder
== WRC_BO_LITTLE
) goto out
;
1077 if(byteorder
== WRC_BO_BIG
) goto out
;
1079 /* Resource byteorder == native byteorder */
1081 mbp
= (msgtab_block_t
*)&(((DWORD
*)rd
->data
)[1]);
1082 nblk
= BYTESWAP_DWORD(nblk
);
1083 if(MSGTAB_BAD_PTR(mbp
, rd
->data
, rd
->size
, nblk
* sizeof(*mbp
)))
1084 yyerror("Messagetable's blocks are outside of defined data");
1085 for(i
= 0; i
< nblk
; i
++)
1087 msgtab_entry_t
*mep
;
1090 mbp
[i
].idlo
= BYTESWAP_DWORD(mbp
[i
].idlo
);
1091 mbp
[i
].idhi
= BYTESWAP_DWORD(mbp
[i
].idhi
);
1092 mbp
[i
].offset
= BYTESWAP_DWORD(mbp
[i
].offset
);
1093 mep
= (msgtab_entry_t
*)(((char *)rd
->data
) + mbp
[i
].offset
);
1095 for(id
= mbp
[i
].idlo
; id
<= mbp
[i
].idhi
; id
++)
1097 mep
->length
= BYTESWAP_WORD(mep
->length
);
1098 mep
->flags
= BYTESWAP_WORD(mep
->flags
);
1100 if(MSGTAB_BAD_PTR(mep
, rd
->data
, rd
->size
, mep
->length
))
1101 yyerror("Messagetable's data for block %d, ID 0x%08lx is outside of defined data", (int)i
, id
);
1102 if(mep
->flags
== 1) /* Docu says 'flags == 0x0001' for unicode */
1104 WORD
*wp
= (WORD
*)&mep
[1];
1105 int l
= mep
->length
/2 - 2; /* Length included header */
1109 yyerror("Message 0x%08lx is unicode (block %d), but has odd length (%d)", id
, (int)i
, mep
->length
);
1110 for(n
= 0; n
< l
; n
++)
1111 wp
[n
] = BYTESWAP_WORD(wp
[n
]);
1114 mep
= (msgtab_entry_t
*)(((char *)mep
) + mep
->length
);
1122 #undef MSGTAB_BAD_PTR
1124 void copy_raw_data(raw_data_t
*dst
, raw_data_t
*src
, unsigned int offs
, int len
)
1126 assert(offs
<= src
->size
);
1127 assert(offs
+ len
<= src
->size
);
1130 dst
->data
= (char *)xmalloc(len
);
1134 dst
->data
= (char *)xrealloc(dst
->data
, dst
->size
+ len
);
1135 /* dst->size holds the offset to copy to */
1136 memcpy(dst
->data
+ dst
->size
, src
->data
+ offs
, len
);
1142 int *ip
= (int *)xmalloc(sizeof(int));
1147 stringtable_t
*new_stringtable(lvc_t
*lvc
)
1149 stringtable_t
*stt
= (stringtable_t
*)xmalloc(sizeof(stringtable_t
));
1157 toolbar_t
*new_toolbar(int button_width
, int button_height
, toolbar_item_t
*items
, int nitems
)
1159 toolbar_t
*tb
= (toolbar_t
*)xmalloc(sizeof(toolbar_t
));
1160 tb
->button_width
= button_width
;
1161 tb
->button_height
= button_height
;
1162 tb
->nitems
= nitems
;
1167 dlginit_t
*new_dlginit(raw_data_t
*rd
, int *memopt
)
1169 dlginit_t
*di
= (dlginit_t
*)xmalloc(sizeof(dlginit_t
));
1173 di
->memopt
= *memopt
;
1177 di
->memopt
= WRC_MO_MOVEABLE
| WRC_MO_PURE
| WRC_MO_DISCARDABLE
;
1182 style_pair_t
*new_style_pair(style_t
*style
, style_t
*exstyle
)
1184 style_pair_t
*sp
= (style_pair_t
*)xmalloc(sizeof(style_pair_t
));
1186 sp
->exstyle
= exstyle
;
1190 style_t
*new_style(DWORD or_mask
, DWORD and_mask
)
1192 style_t
*st
= (style_t
*)xmalloc(sizeof(style_t
));
1193 st
->or_mask
= or_mask
;
1194 st
->and_mask
= and_mask
;