]> git.saurik.com Git - wxWidgets.git/blob - src/xpm/parse.c
Re-added corrupt binary files; small change to filefn.cpp for Cygwin.
[wxWidgets.git] / src / xpm / parse.c
1 /*
2 * Copyright (C) 1989-94 GROUPE BULL
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to
6 * deal in the Software without restriction, including without limitation the
7 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
8 * sell copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20 *
21 * Except as contained in this notice, the name of GROUPE BULL shall not be
22 * used in advertising or otherwise to promote the sale, use or other dealings
23 * in this Software without prior written authorization from GROUPE BULL.
24 */
25
26 /*****************************************************************************\
27 * parse.c: *
28 * *
29 * XPM library *
30 * Parse an XPM file or array and store the found informations *
31 * in the given XpmImage structure. *
32 * *
33 * Developed by Arnaud Le Hors *
34 \*****************************************************************************/
35
36 /*
37 * The code related to FOR_MSW has been added by
38 * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
39 */
40
41 #include "xpm34p.h"
42 #ifdef VMS
43 #include "sys$library:ctype.h"
44 #else
45 #include <ctype.h>
46 #endif
47
48 #ifdef sun
49 #ifdef SVR4
50 #include <X11/Xfuncs.h> /* bzero, bcopy */
51 #endif
52 #endif
53
54 #include <string.h>
55 #ifdef __sgi
56 #include <bstring.h>
57 #endif
58
59 LFUNC(ParseValues, int, (xpmData *data, unsigned int *width,
60 unsigned int *height, unsigned int *ncolors,
61 unsigned int *cpp, unsigned int *x_hotspot,
62 unsigned int *y_hotspot, unsigned int *hotspot,
63 unsigned int *extensions));
64
65 LFUNC(ParseColors, int, (xpmData *data, unsigned int ncolors, unsigned int cpp,
66 XpmColor **colorTablePtr, xpmHashTable *hashtable));
67
68 LFUNC(ParsePixels, int, (xpmData *data, unsigned int width,
69 unsigned int height, unsigned int ncolors,
70 unsigned int cpp, XpmColor *colorTable,
71 xpmHashTable *hashtable, unsigned int **pixels));
72
73 LFUNC(ParseExtensions, int, (xpmData *data, XpmExtension **extensions,
74 unsigned int *nextensions));
75
76 char *xpmColorKeys[] = {
77 "s", /* key #1: symbol */
78 "m", /* key #2: mono visual */
79 "g4", /* key #3: 4 grays visual */
80 "g", /* key #4: gray visual */
81 "c", /* key #5: color visual */
82 };
83
84
85 /* function call in case of error, frees only locally allocated variables */
86 #undef RETURN
87 #define RETURN(status) \
88 { \
89 if (colorTable) xpmFreeColorTable(colorTable, ncolors); \
90 if (pixelindex) XpmFree(pixelindex); \
91 if (hints_cmt) XpmFree(hints_cmt); \
92 if (colors_cmt) XpmFree(colors_cmt); \
93 if (pixels_cmt) XpmFree(pixels_cmt); \
94 return(status); \
95 }
96
97 /*
98 * This function parses an Xpm file or data and store the found informations
99 * in an an XpmImage structure which is returned.
100 */
101 int
102 xpmParseData(xpmData *data, XpmImage *image, XpmInfo *info)
103 {
104 /* variables to return */
105 unsigned int width, height, ncolors, cpp;
106 unsigned int x_hotspot, y_hotspot, hotspot = 0, extensions = 0;
107 XpmColor *colorTable = NULL;
108 unsigned int *pixelindex = NULL;
109 char *hints_cmt = NULL;
110 char *colors_cmt = NULL;
111 char *pixels_cmt = NULL;
112
113 unsigned int cmts;
114 int ErrorStatus;
115 xpmHashTable hashtable;
116
117 cmts = info && (info->valuemask & XpmReturnComments);
118
119 /*
120 * parse the header
121 */
122 ErrorStatus = xpmParseHeader(data);
123 if (ErrorStatus != XpmSuccess)
124 return (ErrorStatus);
125
126 /*
127 * read values
128 */
129 ErrorStatus = ParseValues(data, &width, &height, &ncolors, &cpp,
130 &x_hotspot, &y_hotspot, &hotspot, &extensions);
131 if (ErrorStatus != XpmSuccess)
132 return (ErrorStatus);
133
134 /*
135 * store the hints comment line
136 */
137 if (cmts)
138 xpmGetCmt(data, &hints_cmt);
139
140 /*
141 * init the hastable
142 */
143 if (USE_HASHTABLE) {
144 ErrorStatus = xpmHashTableInit(&hashtable);
145 if (ErrorStatus != XpmSuccess)
146 return (ErrorStatus);
147 }
148
149 /*
150 * read colors
151 */
152 ErrorStatus = ParseColors(data, ncolors, cpp, &colorTable, &hashtable);
153 if (ErrorStatus != XpmSuccess)
154 RETURN(ErrorStatus);
155
156 /*
157 * store the colors comment line
158 */
159 if (cmts)
160 xpmGetCmt(data, &colors_cmt);
161
162 /*
163 * read pixels and index them on color number
164 */
165 ErrorStatus = ParsePixels(data, width, height, ncolors, cpp, colorTable,
166 &hashtable, &pixelindex);
167
168 /*
169 * free the hastable
170 */
171 if (USE_HASHTABLE)
172 xpmHashTableFree(&hashtable);
173
174 if (ErrorStatus != XpmSuccess)
175 RETURN(ErrorStatus);
176
177 /*
178 * store the pixels comment line
179 */
180 if (cmts)
181 xpmGetCmt(data, &pixels_cmt);
182
183 /*
184 * parse extensions
185 */
186 if (info && (info->valuemask & XpmReturnExtensions))
187 if (extensions) {
188 ErrorStatus = ParseExtensions(data, &info->extensions,
189 &info->nextensions);
190 if (ErrorStatus != XpmSuccess)
191 RETURN(ErrorStatus);
192 } else {
193 info->extensions = NULL;
194 info->nextensions = 0;
195 }
196
197 /*
198 * store found informations in the XpmImage structure
199 */
200 image->width = width;
201 image->height = height;
202 image->cpp = cpp;
203 image->ncolors = ncolors;
204 image->colorTable = colorTable;
205 image->data = pixelindex;
206
207 if (info) {
208 if (cmts) {
209 info->hints_cmt = hints_cmt;
210 info->colors_cmt = colors_cmt;
211 info->pixels_cmt = pixels_cmt;
212 }
213 if (hotspot) {
214 info->x_hotspot = x_hotspot;
215 info->y_hotspot = y_hotspot;
216 info->valuemask |= XpmHotspot;
217 }
218 }
219 return (XpmSuccess);
220 }
221
222 static int
223 ParseValues(xpmData *data, unsigned int *width, unsigned int *height, unsigned int *ncolors, unsigned int *cpp,
224 unsigned int *x_hotspot, unsigned int *y_hotspot, unsigned int *hotspot, unsigned int *extensions)
225 {
226 unsigned int l;
227 char buf[BUFSIZ];
228
229 if (!data->format) { /* XPM 2 or 3 */
230
231 /*
232 * read values: width, height, ncolors, chars_per_pixel
233 */
234 if (!(xpmNextUI(data, width) && xpmNextUI(data, height)
235 && xpmNextUI(data, ncolors) && xpmNextUI(data, cpp)))
236 return (XpmFileInvalid);
237
238 /*
239 * read optional information (hotspot and/or XPMEXT) if any
240 */
241 l = xpmNextWord(data, buf, BUFSIZ);
242 if (l) {
243 *extensions = (l == 6 && !strncmp("XPMEXT", buf, 6));
244 if (*extensions)
245 *hotspot = (xpmNextUI(data, x_hotspot)
246 && xpmNextUI(data, y_hotspot));
247 else {
248 *hotspot = (atoui(buf, l, x_hotspot)
249 && xpmNextUI(data, y_hotspot));
250 l = xpmNextWord(data, buf, BUFSIZ);
251 *extensions = (l == 6 && !strncmp("XPMEXT", buf, 6));
252 }
253 }
254 } else {
255
256 /*
257 * XPM 1 file read values: width, height, ncolors, chars_per_pixel
258 */
259 int i;
260 char *ptr;
261
262 for (i = 0; i < 4; i++) {
263 l = xpmNextWord(data, buf, BUFSIZ);
264 if (l != 7 || strncmp("#define", buf, 7))
265 return (XpmFileInvalid);
266 l = xpmNextWord(data, buf, BUFSIZ);
267 if (!l)
268 return (XpmFileInvalid);
269 ptr = strchr(buf, '_');
270 if (!ptr)
271 return (XpmFileInvalid);
272 switch (l - (ptr - buf)) {
273 case 6:
274 if (!strncmp("_width", ptr, 6) && !xpmNextUI(data, width))
275 return (XpmFileInvalid);
276 break;
277 case 7:
278 if (!strncmp("_height", ptr, 7) && !xpmNextUI(data, height))
279 return (XpmFileInvalid);
280 break;
281 case 8:
282 if (!strncmp("_ncolors", ptr, 8) && !xpmNextUI(data, ncolors))
283 return (XpmFileInvalid);
284 break;
285 case 16:
286 if (!strncmp("_chars_per_pixel", ptr, 16)
287 && !xpmNextUI(data, cpp))
288 return (XpmFileInvalid);
289 break;
290 default:
291 return (XpmFileInvalid);
292 }
293 /* skip the end of line */
294 xpmNextString(data);
295 }
296 *hotspot = 0;
297 *extensions = 0;
298 }
299 return (XpmSuccess);
300 }
301
302 static int
303 ParseColors(xpmData *data, unsigned int ncolors, unsigned int cpp, XpmColor **colorTablePtr, xpmHashTable *hashtable)
304 {
305 unsigned int key, l, a, b;
306 unsigned int curkey; /* current color key */
307 unsigned int lastwaskey; /* key read */
308 char buf[BUFSIZ];
309 char curbuf[BUFSIZ]; /* current buffer */
310 char **sptr, *s;
311 XpmColor *color;
312 XpmColor *colorTable;
313 char **defaults;
314 int ErrorStatus;
315
316 colorTable = (XpmColor *) XpmCalloc(ncolors, sizeof(XpmColor));
317 if (!colorTable)
318 return (XpmNoMemory);
319
320 if (!data->format) { /* XPM 2 or 3 */
321 for (a = 0, color = colorTable; a < ncolors; a++, color++) {
322 xpmNextString(data); /* skip the line */
323
324 /*
325 * read pixel value
326 */
327 color->string = (char *) XpmMalloc(cpp + 1);
328 if (!color->string) {
329 xpmFreeColorTable(colorTable, ncolors);
330 return (XpmNoMemory);
331 }
332 for (b = 0, s = color->string; b < cpp; b++, s++)
333 *s = xpmGetC(data);
334 *s = '\0';
335
336 /*
337 * store the string in the hashtable with its color index number
338 */
339 if (USE_HASHTABLE) {
340 ErrorStatus =
341 xpmHashIntern(hashtable, color->string, HashAtomData(a));
342 if (ErrorStatus != XpmSuccess) {
343 xpmFreeColorTable(colorTable, ncolors);
344 return (ErrorStatus);
345 }
346 }
347
348 /*
349 * read color keys and values
350 */
351 defaults = (char **) color;
352 curkey = 0;
353 lastwaskey = 0;
354 *curbuf = '\0'; /* init curbuf */
355 while (l = xpmNextWord(data, buf, BUFSIZ)) {
356 if (!lastwaskey) {
357 for (key = 0, sptr = xpmColorKeys; key < NKEYS; key++,
358 sptr++)
359 if ((strlen(*sptr) == l) && (!strncmp(*sptr, buf, l)))
360 break;
361 }
362 if (!lastwaskey && key < NKEYS) { /* open new key */
363 if (curkey) { /* flush string */
364 s = (char *) XpmMalloc(strlen(curbuf) + 1);
365 if (!s) {
366 xpmFreeColorTable(colorTable, ncolors);
367 return (XpmNoMemory);
368 }
369 defaults[curkey] = s;
370 strcpy(s, curbuf);
371 }
372 curkey = key + 1; /* set new key */
373 *curbuf = '\0'; /* reset curbuf */
374 lastwaskey = 1;
375 } else {
376 if (!curkey) { /* key without value */
377 xpmFreeColorTable(colorTable, ncolors);
378 return (XpmFileInvalid);
379 }
380 if (!lastwaskey)
381 strcat(curbuf, " "); /* append space */
382 buf[l] = '\0';
383 strcat(curbuf, buf);/* append buf */
384 lastwaskey = 0;
385 }
386 }
387 if (!curkey) { /* key without value */
388 xpmFreeColorTable(colorTable, ncolors);
389 return (XpmFileInvalid);
390 }
391 s = defaults[curkey] = (char *) XpmMalloc(strlen(curbuf) + 1);
392 if (!s) {
393 xpmFreeColorTable(colorTable, ncolors);
394 return (XpmNoMemory);
395 }
396 strcpy(s, curbuf);
397 }
398 } else { /* XPM 1 */
399 /* get to the beginning of the first string */
400 data->Bos = '"';
401 data->Eos = '\0';
402 xpmNextString(data);
403 data->Eos = '"';
404 for (a = 0, color = colorTable; a < ncolors; a++, color++) {
405
406 /*
407 * read pixel value
408 */
409 color->string = (char *) XpmMalloc(cpp + 1);
410 if (!color->string) {
411 xpmFreeColorTable(colorTable, ncolors);
412 return (XpmNoMemory);
413 }
414 for (b = 0, s = color->string; b < cpp; b++, s++)
415 *s = xpmGetC(data);
416 *s = '\0';
417
418 /*
419 * store the string in the hashtable with its color index number
420 */
421 if (USE_HASHTABLE) {
422 ErrorStatus =
423 xpmHashIntern(hashtable, color->string, HashAtomData(a));
424 if (ErrorStatus != XpmSuccess) {
425 xpmFreeColorTable(colorTable, ncolors);
426 return (ErrorStatus);
427 }
428 }
429
430 /*
431 * read color values
432 */
433 xpmNextString(data); /* get to the next string */
434 *curbuf = '\0'; /* init curbuf */
435 while (l = xpmNextWord(data, buf, BUFSIZ)) {
436 if (*curbuf != '\0')
437 strcat(curbuf, " ");/* append space */
438 buf[l] = '\0';
439 strcat(curbuf, buf); /* append buf */
440 }
441 s = (char *) XpmMalloc(strlen(curbuf) + 1);
442 if (!s) {
443 xpmFreeColorTable(colorTable, ncolors);
444 return (XpmNoMemory);
445 }
446 strcpy(s, curbuf);
447 color->c_color = s;
448 *curbuf = '\0'; /* reset curbuf */
449 if (a < ncolors - 1)
450 xpmNextString(data); /* get to the next string */
451 }
452 }
453 *colorTablePtr = colorTable;
454 return (XpmSuccess);
455 }
456
457 static int
458 ParsePixels(xpmData *data, unsigned int width, unsigned int height, unsigned int ncolors,
459 unsigned int cpp, XpmColor *colorTable, xpmHashTable *hashtable, unsigned int **pixels)
460 {
461 unsigned int *iptr, *iptr2;
462 unsigned int a, x, y;
463
464 #ifndef FOR_MSW
465 iptr2 = (unsigned int *) XpmMalloc(sizeof(unsigned int) * width * height);
466 #else
467
468 /*
469 * special treatment to trick DOS malloc(size_t) where size_t is 16 bit!!
470 * XpmMalloc is defined to longMalloc(long) and checks the 16 bit boundary
471 */
472 iptr2 = (unsigned int *)
473 XpmMalloc((long) sizeof(unsigned int) * (long) width * (long) height);
474 #endif
475 if (!iptr2)
476 return (XpmNoMemory);
477
478 iptr = iptr2;
479
480 switch (cpp) {
481
482 case (1): /* Optimize for single character
483 * colors */
484 {
485 unsigned short colidx[256];
486
487 bzero((char *)colidx, 256 * sizeof(short));
488 for (a = 0; a < ncolors; a++)
489 colidx[colorTable[a].string[0]] = a + 1;
490
491 for (y = 0; y < height; y++) {
492 xpmNextString(data);
493 for (x = 0; x < width; x++, iptr++) {
494 int idx = colidx[xpmGetC(data)];
495
496 if (idx != 0)
497 *iptr = idx - 1;
498 else {
499 XpmFree(iptr2);
500 return (XpmFileInvalid);
501 }
502 }
503 }
504 }
505 break;
506
507 case (2): /* Optimize for double character
508 * colors */
509 {
510
511 /* free all allocated pointers at all exits */
512 #define FREE_CIDX {int f; for (f = 0; f < 256; f++) \
513 if (cidx[f]) XpmFree(cidx[f]);}
514
515 /* array of pointers malloced by need */
516 unsigned short *cidx[256];
517 int char1;
518
519 bzero((char *)cidx, 256 * sizeof(unsigned short *)); /* init */
520 for (a = 0; a < ncolors; a++) {
521 char1 = colorTable[a].string[0];
522 if (cidx[char1] == NULL) { /* get new memory */
523 cidx[char1] = (unsigned short *)
524 XpmCalloc(256, sizeof(unsigned short));
525 if (cidx[char1] == NULL) { /* new block failed */
526 FREE_CIDX;
527 XpmFree(iptr2);
528 return (XpmNoMemory);
529 }
530 }
531 cidx[char1][colorTable[a].string[1]] = a + 1;
532 }
533
534 for (y = 0; y < height; y++) {
535 xpmNextString(data);
536 for (x = 0; x < width; x++, iptr++) {
537 int cc1 = xpmGetC(data);
538 int idx = cidx[cc1][xpmGetC(data)];
539
540 if (idx != 0)
541 *iptr = idx - 1;
542 else {
543 FREE_CIDX;
544 XpmFree(iptr2);
545 return (XpmFileInvalid);
546 }
547 }
548 }
549 FREE_CIDX;
550 }
551 break;
552
553 default: /* Non-optimized case of long color
554 * names */
555 {
556 char *s;
557 char buf[BUFSIZ];
558
559 buf[cpp] = '\0';
560 if (USE_HASHTABLE) {
561 xpmHashAtom *slot;
562
563 for (y = 0; y < height; y++) {
564 xpmNextString(data);
565 for (x = 0; x < width; x++, iptr++) {
566 for (a = 0, s = buf; a < cpp; a++, s++)
567 *s = xpmGetC(data);
568 slot = xpmHashSlot(hashtable, buf);
569 if (!*slot) { /* no color matches */
570 XpmFree(iptr2);
571 return (XpmFileInvalid);
572 }
573 *iptr = HashColorIndex(slot);
574 }
575 }
576 } else {
577 for (y = 0; y < height; y++) {
578 xpmNextString(data);
579 for (x = 0; x < width; x++, iptr++) {
580 for (a = 0, s = buf; a < cpp; a++, s++)
581 *s = xpmGetC(data);
582 for (a = 0; a < ncolors; a++)
583 if (!strcmp(colorTable[a].string, buf))
584 break;
585 if (a == ncolors) { /* no color matches */
586 XpmFree(iptr2);
587 return (XpmFileInvalid);
588 }
589 *iptr = a;
590 }
591 }
592 }
593 }
594 break;
595 }
596 *pixels = iptr2;
597 return (XpmSuccess);
598 }
599
600 static int
601 ParseExtensions(xpmData *data, XpmExtension **extensions, unsigned int *nextensions)
602 {
603 XpmExtension *exts = NULL, *ext;
604 unsigned int num = 0;
605 unsigned int nlines, a, l, notstart, notend = 0;
606 int status;
607 char *string, *s, *s2, **sp;
608
609 xpmNextString(data);
610 exts = (XpmExtension *) XpmMalloc(sizeof(XpmExtension));
611 /* get the whole string */
612 status = xpmGetString(data, &string, &l);
613 if (status != XpmSuccess) {
614 XpmFree(exts);
615 return (status);
616 }
617 /* look for the key word XPMEXT, skip lines before this */
618 while ((notstart = strncmp("XPMEXT", string, 6))
619 && (notend = strncmp("XPMENDEXT", string, 9))) {
620 XpmFree(string);
621 xpmNextString(data);
622 status = xpmGetString(data, &string, &l);
623 if (status != XpmSuccess) {
624 XpmFree(exts);
625 return (status);
626 }
627 }
628 if (!notstart)
629 notend = strncmp("XPMENDEXT", string, 9);
630 while (!notstart && notend) {
631 /* there starts an extension */
632 ext = (XpmExtension *)
633 XpmRealloc(exts, (num + 1) * sizeof(XpmExtension));
634 if (!ext) {
635 XpmFree(string);
636 XpmFreeExtensions(exts, num);
637 return (XpmNoMemory);
638 }
639 exts = ext;
640 ext += num;
641 /* skip whitespace and store its name */
642 s2 = s = string + 6;
643 while (isspace(*s2))
644 s2++;
645 a = s2 - s;
646 ext->name = (char *) XpmMalloc(l - a - 6);
647 if (!ext->name) {
648 XpmFree(string);
649 ext->lines = NULL;
650 ext->nlines = 0;
651 XpmFreeExtensions(exts, num + 1);
652 return (XpmNoMemory);
653 }
654 strncpy(ext->name, s + a, l - a - 6);
655 XpmFree(string);
656 /* now store the related lines */
657 xpmNextString(data);
658 status = xpmGetString(data, &string, &l);
659 if (status != XpmSuccess) {
660 ext->lines = NULL;
661 ext->nlines = 0;
662 XpmFreeExtensions(exts, num + 1);
663 return (status);
664 }
665 ext->lines = (char **) XpmMalloc(sizeof(char *));
666 nlines = 0;
667 while ((notstart = strncmp("XPMEXT", string, 6))
668 && (notend = strncmp("XPMENDEXT", string, 9))) {
669 sp = (char **)
670 XpmRealloc(ext->lines, (nlines + 1) * sizeof(char *));
671 if (!sp) {
672 XpmFree(string);
673 ext->nlines = nlines;
674 XpmFreeExtensions(exts, num + 1);
675 return (XpmNoMemory);
676 }
677 ext->lines = sp;
678 ext->lines[nlines] = string;
679 nlines++;
680 xpmNextString(data);
681 status = xpmGetString(data, &string, &l);
682 if (status != XpmSuccess) {
683 ext->nlines = nlines;
684 XpmFreeExtensions(exts, num + 1);
685 return (status);
686 }
687 }
688 if (!nlines) {
689 XpmFree(ext->lines);
690 ext->lines = NULL;
691 }
692 ext->nlines = nlines;
693 num++;
694 }
695 if (!num) {
696 XpmFree(string);
697 XpmFree(exts);
698 exts = NULL;
699 } else if (!notend)
700 XpmFree(string);
701 *nextensions = num;
702 *extensions = exts;
703 return (XpmSuccess);
704 }