14 files changed, 6728 insertions, 6689 deletions

diff --git a/libXpm/src/CrBufFrI.c b/libXpm/src/CrBufFrI.c
index 113a45c1e..b191037dc 100644
--- a/libXpm/src/CrBufFrI.c
+++ b/libXpm/src/CrBufFrI.c
@@ -1,449 +1,449 @@
-/*
- * Copyright (C) 1989-95 GROUPE BULL
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of GROUPE BULL shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from GROUPE BULL.
- */
-
-/*****************************************************************************\
-*  CrBufFrI.c:                                                                *
-*                                                                             *
-*  XPM library                                                                *
-*  Scan an image and possibly its mask and create an XPM buffer               *
-*                                                                             *
-*  Developed by Arnaud Le Hors                                                *
-\*****************************************************************************/
-
-/* October 2004, source code review by Thomas Biege <thomas@suse.de> */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "XpmI.h"
-
-LFUNC(WriteColors, int, (char **dataptr, unsigned int *data_size,
-			 unsigned int *used_size, XpmColor *colors,
-			 unsigned int ncolors, unsigned int cpp));
-
-LFUNC(WritePixels, void, (char *dataptr, unsigned int data_size,
-			  unsigned int *used_size,
-			  unsigned int width, unsigned int height,
-			  unsigned int cpp, unsigned int *pixels,
-			  XpmColor *colors));
-
-LFUNC(WriteExtensions, void, (char *dataptr, unsigned int data_size,
-			      unsigned int *used_size,
-			      XpmExtension *ext, unsigned int num));
-
-LFUNC(ExtensionsSize, unsigned int, (XpmExtension *ext, unsigned int num));
-LFUNC(CommentsSize, int, (XpmInfo *info));
-
-int
-XpmCreateBufferFromImage(
-    Display		 *display,
-    char		**buffer_return,
-    XImage		 *image,
-    XImage		 *shapeimage,
-    XpmAttributes	 *attributes)
-{
-    XpmImage xpmimage;
-    XpmInfo info;
-    int ErrorStatus;
-
-    /* initialize return value */
-    if (buffer_return)
-	*buffer_return = NULL;
-
-    /* create an XpmImage from the image */
-    ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,
-					     &xpmimage, attributes);
-    if (ErrorStatus != XpmSuccess)
-	return (ErrorStatus);
-
-    /* create the buffer from the XpmImage */
-    if (attributes) {
-	xpmSetInfo(&info, attributes);
-	ErrorStatus =
-	    XpmCreateBufferFromXpmImage(buffer_return, &xpmimage, &info);
-    } else
-	ErrorStatus =
-	    XpmCreateBufferFromXpmImage(buffer_return, &xpmimage, NULL);
-
-    /* free the XpmImage */
-    XpmFreeXpmImage(&xpmimage);
-
-    return (ErrorStatus);
-}
-
-
-#undef RETURN
-#define RETURN(status) \
-do \
-{ \
-      ErrorStatus = status; \
-      goto error; \
-}while(0)
-
-int
-XpmCreateBufferFromXpmImage(
-    char	**buffer_return,
-    XpmImage	 *image,
-    XpmInfo	 *info)
-{
-    /* calculation variables */
-    int ErrorStatus;
-    char buf[BUFSIZ];
-    unsigned int cmts, extensions, ext_size = 0;
-    unsigned int l, cmt_size = 0;
-    char *ptr = NULL, *p;
-    unsigned int ptr_size, used_size, tmp;
-
-    *buffer_return = NULL;
-
-    cmts = info && (info->valuemask & XpmComments);
-    extensions = info && (info->valuemask & XpmExtensions)
-	&& info->nextensions;
-
-    /* compute the extensions and comments size */
-    if (extensions)
-	ext_size = ExtensionsSize(info->extensions, info->nextensions);
-    if (cmts)
-	cmt_size = CommentsSize(info);
-
-    /* write the header line */
-#ifndef VOID_SPRINTF
-    used_size =
-#endif
-    sprintf(buf, "/* XPM */\nstatic char * image_name[] = {\n");
-#ifdef VOID_SPRINTF
-    used_size = strlen(buf);
-#endif
-    ptr_size = used_size + ext_size + cmt_size + 1; /* ptr_size can't be 0 */
-    if(ptr_size <= used_size ||
-       ptr_size <= ext_size  ||
-       ptr_size <= cmt_size)
-    {
-        return XpmNoMemory;
-    }
-    ptr = (char *) XpmMalloc(ptr_size);
-    if (!ptr)
-	return XpmNoMemory;
-    strcpy(ptr, buf);
-
-    /* write the values line */
-    if (cmts && info->hints_cmt) {
-#ifndef VOID_SPRINTF
-	used_size +=
-#endif
-	snprintf(ptr + used_size, ptr_size-used_size, "/*%s*/\n", info->hints_cmt);
-#ifdef VOID_SPRINTF
-	used_size += strlen(info->hints_cmt) + 5;
-#endif
-    }
-#ifndef VOID_SPRINTF
-    l =
-#endif
-    sprintf(buf, "\"%d %d %d %d", image->width, image->height,
-	    image->ncolors, image->cpp);
-#ifdef VOID_SPRINTF
-    l = strlen(buf);
-#endif
-
-    if (info && (info->valuemask & XpmHotspot)) {
-#ifndef VOID_SPRINTF
-	l +=
-#endif
-	snprintf(buf + l, sizeof(buf)-l, " %d %d", info->x_hotspot, info->y_hotspot);
-#ifdef VOID_SPRINTF
-	l = strlen(buf);
-#endif
-    }
-    if (extensions) {
-#ifndef VOID_SPRINTF
-	l +=
-#endif
-	sprintf(buf + l, " XPMEXT");
-#ifdef VOID_SPRINTF
-	l = strlen(buf);
-#endif
-    }
-#ifndef VOID_SPRINTF
-    l +=
-#endif
-    sprintf(buf + l, "\",\n");
-#ifdef VOID_SPRINTF
-    l = strlen(buf);
-#endif
-    ptr_size += l;
-    if(ptr_size <= l)
-        RETURN(XpmNoMemory);
-    p = (char *) XpmRealloc(ptr, ptr_size);
-    if (!p)
-	RETURN(XpmNoMemory);
-    ptr = p;
-    strcpy(ptr + used_size, buf);
-    used_size += l;
-
-    /* write colors */
-    if (cmts && info->colors_cmt) {
-#ifndef VOID_SPRINTF
-	used_size +=
-#endif
-	snprintf(ptr + used_size, ptr_size-used_size, "/*%s*/\n", info->colors_cmt);
-#ifdef VOID_SPRINTF
-	used_size += strlen(info->colors_cmt) + 5;
-#endif
-    }
-    ErrorStatus = WriteColors(&ptr, &ptr_size, &used_size,
-			      image->colorTable, image->ncolors, image->cpp);
- 
-    if (ErrorStatus != XpmSuccess)
-	RETURN(ErrorStatus);
-
-    /*
-     * now we know the exact size we need, realloc the data
-     * 4 = 1 (for '"') + 3 (for '",\n')
-     * 1 = - 2 (because the last line does not end with ',\n') + 3 (for '};\n')
-     */
-     if(image->width  > UINT_MAX / image->cpp ||
-       (tmp = image->width * image->cpp + 4) <= 4 ||
-        image->height > UINT_MAX / tmp ||
-       (tmp = image->height * tmp + 1) <= 1 ||
-       (ptr_size += tmp) <= tmp)
-	RETURN(XpmNoMemory);
-
-    p = (char *) XpmRealloc(ptr, ptr_size);
-    if (!p)
-	RETURN(XpmNoMemory);
-    ptr = p;
-
-    /* print pixels */
-    if (cmts && info->pixels_cmt) {
-#ifndef VOID_SPRINTF
-	used_size +=
-#endif
-	snprintf(ptr + used_size, ptr_size-used_size, "/*%s*/\n", info->pixels_cmt);
-#ifdef VOID_SPRINTF
-	used_size += strlen(info->pixels_cmt) + 5;
-#endif
-    }
-    WritePixels(ptr + used_size, ptr_size - used_size, &used_size, image->width, image->height,
-		image->cpp, image->data, image->colorTable);
-
-    /* print extensions */
-    if (extensions)
-	WriteExtensions(ptr + used_size, ptr_size-used_size, &used_size,
-			info->extensions, info->nextensions);
-
-    /* close the array */
-    strcpy(ptr + used_size, "};\n");
-
-    *buffer_return = ptr;
-
-    return (XpmSuccess);
-
-/* exit point in case of error, free only locally allocated variables */
-error:
-    if (ptr)
-	XpmFree(ptr);
-    return (ErrorStatus);
-}
-
-
-static int
-WriteColors(
-    char		**dataptr,
-    unsigned int	 *data_size,
-    unsigned int	 *used_size,
-    XpmColor		 *colors,
-    unsigned int	  ncolors,
-    unsigned int	  cpp)
-{
-    char buf[BUFSIZ] = {0};
-    unsigned int a, key, l;
-    char *s, *s2;
-    char **defaults;
-
-    *buf = '"';
-    for (a = 0; a < ncolors; a++, colors++) {
-
-	defaults = (char **) colors;
-	s = buf + 1;
-	if(cpp > (sizeof(buf) - (s-buf)))
-		return(XpmNoMemory);
-	strncpy(s, *defaults++, cpp);
-	s += cpp;
-
-	for (key = 1; key <= NKEYS; key++, defaults++) {
-	    if ((s2 = *defaults)) {
-#ifndef VOID_SPRINTF
-		s +=
-#endif
-		/* assume C99 compliance */
-		snprintf(s, sizeof(buf) - (s-buf), "\t%s %s", xpmColorKeys[key - 1], s2);
-#ifdef VOID_SPRINTF
-		s += strlen(s);
-#endif
-		/* now let's check if s points out-of-bounds */
-		if((s-buf) > sizeof(buf))
-			return(XpmNoMemory);
-	    }
-	}
-	if(sizeof(buf) - (s-buf) < 4)
-		return(XpmNoMemory);
-	strcpy(s, "\",\n");
-	l = s + 3 - buf;
-	if( *data_size                   >= UINT_MAX-l ||
-	    *data_size + l               <= *used_size ||
-	   (*data_size + l - *used_size) <= sizeof(buf))
-		return(XpmNoMemory);
-	s = (char *) XpmRealloc(*dataptr, *data_size + l);
-	if (!s)
-	    return (XpmNoMemory);
-	*data_size += l;
-	strcpy(s + *used_size, buf);
-	*used_size += l;
-	*dataptr = s;
-    }
-    return (XpmSuccess);
-}
-
-static void
-WritePixels(
-    char		*dataptr,
-    unsigned int	 data_size,
-    unsigned int	*used_size,
-    unsigned int	 width,
-    unsigned int	 height,
-    unsigned int	 cpp,
-    unsigned int	*pixels,
-    XpmColor		*colors)
-{
-    char *s = dataptr;
-    unsigned int x, y, h;
-
-    if(height <= 1)
-    	return;
-
-    h = height - 1;
-    for (y = 0; y < h; y++) {
-	*s++ = '"';
-	for (x = 0; x < width; x++, pixels++) {
-	    if(cpp >= (data_size - (s-dataptr)))
-		return;
-	    strncpy(s, colors[*pixels].string, cpp); /* how can we trust *pixels? :-\ */
-	    s += cpp;
-	}
-	if((data_size - (s-dataptr)) < 4)
-		return;
-	strcpy(s, "\",\n");
-	s += 3;
-    }
-    /* duplicate some code to avoid a test in the loop */
-    *s++ = '"';
-    for (x = 0; x < width; x++, pixels++) {
-	if(cpp >= (data_size - (s-dataptr)))
-	    return;
-	strncpy(s, colors[*pixels].string, cpp); /* how can we trust *pixels? */
-	s += cpp;
-    }
-    *s++ = '"';
-    *used_size += s - dataptr;
-}
-
-static unsigned int
-ExtensionsSize(
-    XpmExtension	*ext,
-    unsigned int	 num)
-{
-    unsigned int x, y, a, size;
-    char **line;
-
-    size = 0;
-    if(num == 0)
-    	return(0); /* ok? */
-    for (x = 0; x < num; x++, ext++) {
-	/* 11 = 10 (for ',\n"XPMEXT ') + 1 (for '"') */
-	size += strlen(ext->name) + 11;
-	a = ext->nlines; /* how can we trust ext->nlines to be not out-of-bounds? */
-	for (y = 0, line = ext->lines; y < a; y++, line++)
-	    /* 4 = 3 (for ',\n"') + 1 (for '"') */
-	    size += strlen(*line) + 4;
-    }
-    /* 13 is for ',\n"XPMENDEXT"' */
-    if(size > UINT_MAX - 13) /* unlikely */
-    	return(0);
-    return size + 13;
-}
-
-static void
-WriteExtensions(
-    char		*dataptr,
-    unsigned int	 data_size,
-    unsigned int	*used_size,
-    XpmExtension	*ext,
-    unsigned int	 num)
-{
-    unsigned int x, y, a;
-    char **line;
-    char *s = dataptr;
-
-    for (x = 0; x < num; x++, ext++) {
-#ifndef VOID_SPRINTF
-	s +=
-#endif
-	snprintf(s, data_size - (s-dataptr), ",\n\"XPMEXT %s\"", ext->name);
-#ifdef VOID_SPRINTF
-	s += strlen(ext->name) + 11;
-#endif
-	a = ext->nlines;
-	for (y = 0, line = ext->lines; y < a; y++, line++) {
-#ifndef VOID_SPRINTF
-	    s +=
-#endif
-	    snprintf(s, data_size - (s-dataptr), ",\n\"%s\"", *line);
-#ifdef VOID_SPRINTF
-	    s += strlen(*line) + 4;
-#endif
-	}
-    }
-    strncpy(s, ",\n\"XPMENDEXT\"", data_size - (s-dataptr)-1);
-    *used_size += s - dataptr + 13;
-}
-
-static int
-CommentsSize(XpmInfo *info)
-{
-    int size = 0;
-
-    /* 5 = 2 (for "/_*") + 3 (for "*_/\n") */
-    /* wrap possible but *very* unlikely */
-    if (info->hints_cmt)
-	size += 5 + strlen(info->hints_cmt);
-
-    if (info->colors_cmt)
-	size += 5 + strlen(info->colors_cmt);
-
-    if (info->pixels_cmt)
-	size += 5 + strlen(info->pixels_cmt);
-
-    return size;
-}
+/*

+ * Copyright (C) 1989-95 GROUPE BULL

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to

+ * deal in the Software without restriction, including without limitation the

+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

+ * sell copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of GROUPE BULL shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from GROUPE BULL.

+ */

+

+/*****************************************************************************\

+*  CrBufFrI.c:                                                                *

+*                                                                             *

+*  XPM library                                                                *

+*  Scan an image and possibly its mask and create an XPM buffer               *

+*                                                                             *

+*  Developed by Arnaud Le Hors                                                *

+\*****************************************************************************/

+

+/* October 2004, source code review by Thomas Biege <thomas@suse.de> */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include "XpmI.h"

+

+LFUNC(WriteColors, int, (char **dataptr, unsigned int *data_size,

+			 unsigned int *used_size, XpmColor *colors,

+			 unsigned int ncolors, unsigned int cpp));

+

+LFUNC(WritePixels, void, (char *dataptr, unsigned int data_size,

+			  unsigned int *used_size,

+			  unsigned int width, unsigned int height,

+			  unsigned int cpp, unsigned int *pixels,

+			  XpmColor *colors));

+

+LFUNC(WriteExtensions, void, (char *dataptr, unsigned int data_size,

+			      unsigned int *used_size,

+			      XpmExtension *ext, unsigned int num));

+

+LFUNC(ExtensionsSize, unsigned int, (XpmExtension *ext, unsigned int num));

+LFUNC(CommentsSize, int, (XpmInfo *info));

+

+int

+XpmCreateBufferFromImage(

+    Display		 *display,

+    char		**buffer_return,

+    XImage		 *image,

+    XImage		 *shapeimage,

+    XpmAttributes	 *attributes)

+{

+    XpmImage xpmimage;

+    XpmInfo info;

+    int ErrorStatus;

+

+    /* initialize return value */

+    if (buffer_return)

+	*buffer_return = NULL;

+

+    /* create an XpmImage from the image */

+    ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,

+					     &xpmimage, attributes);

+    if (ErrorStatus != XpmSuccess)

+	return (ErrorStatus);

+

+    /* create the buffer from the XpmImage */

+    if (attributes) {

+	xpmSetInfo(&info, attributes);

+	ErrorStatus =

+	    XpmCreateBufferFromXpmImage(buffer_return, &xpmimage, &info);

+    } else

+	ErrorStatus =

+	    XpmCreateBufferFromXpmImage(buffer_return, &xpmimage, NULL);

+

+    /* free the XpmImage */

+    XpmFreeXpmImage(&xpmimage);

+

+    return (ErrorStatus);

+}

+

+

+#undef RETURN

+#define RETURN(status) \

+do \

+{ \

+      ErrorStatus = status; \

+      goto error; \

+}while(0)

+

+int

+XpmCreateBufferFromXpmImage(

+    char	**buffer_return,

+    XpmImage	 *image,

+    XpmInfo	 *info)

+{

+    /* calculation variables */

+    int ErrorStatus;

+    char buf[BUFSIZ];

+    unsigned int cmts, extensions, ext_size = 0;

+    unsigned int l, cmt_size = 0;

+    char *ptr = NULL, *p;

+    unsigned int ptr_size, used_size, tmp;

+

+    *buffer_return = NULL;

+

+    cmts = info && (info->valuemask & XpmComments);

+    extensions = info && (info->valuemask & XpmExtensions)

+	&& info->nextensions;

+

+    /* compute the extensions and comments size */

+    if (extensions)

+	ext_size = ExtensionsSize(info->extensions, info->nextensions);

+    if (cmts)

+	cmt_size = CommentsSize(info);

+

+    /* write the header line */

+#ifndef VOID_SPRINTF

+    used_size =

+#endif

+    sprintf(buf, "/* XPM */\nstatic char * image_name[] = {\n");

+#ifdef VOID_SPRINTF

+    used_size = strlen(buf);

+#endif

+    ptr_size = used_size + ext_size + cmt_size + 1; /* ptr_size can't be 0 */

+    if(ptr_size <= used_size ||

+       ptr_size <= ext_size  ||

+       ptr_size <= cmt_size)

+    {

+        return XpmNoMemory;

+    }

+    ptr = (char *) XpmMalloc(ptr_size);

+    if (!ptr)

+	return XpmNoMemory;

+    strcpy(ptr, buf);

+

+    /* write the values line */

+    if (cmts && info->hints_cmt) {

+#ifndef VOID_SPRINTF

+	used_size +=

+#endif

+	snprintf(ptr + used_size, ptr_size-used_size, "/*%s*/\n", info->hints_cmt);

+#ifdef VOID_SPRINTF

+	used_size += strlen(info->hints_cmt) + 5;

+#endif

+    }

+#ifndef VOID_SPRINTF

+    l =

+#endif

+    sprintf(buf, "\"%d %d %d %d", image->width, image->height,

+	    image->ncolors, image->cpp);

+#ifdef VOID_SPRINTF

+    l = strlen(buf);

+#endif

+

+    if (info && (info->valuemask & XpmHotspot)) {

+#ifndef VOID_SPRINTF

+	l +=

+#endif

+	snprintf(buf + l, sizeof(buf)-l, " %d %d", info->x_hotspot, info->y_hotspot);

+#ifdef VOID_SPRINTF

+	l = strlen(buf);

+#endif

+    }

+    if (extensions) {

+#ifndef VOID_SPRINTF

+	l +=

+#endif

+	sprintf(buf + l, " XPMEXT");

+#ifdef VOID_SPRINTF

+	l = strlen(buf);

+#endif

+    }

+#ifndef VOID_SPRINTF

+    l +=

+#endif

+    sprintf(buf + l, "\",\n");

+#ifdef VOID_SPRINTF

+    l = strlen(buf);

+#endif

+    ptr_size += l;

+    if(ptr_size <= l)

+        RETURN(XpmNoMemory);

+    p = (char *) XpmRealloc(ptr, ptr_size);

+    if (!p)

+	RETURN(XpmNoMemory);

+    ptr = p;

+    strcpy(ptr + used_size, buf);

+    used_size += l;

+

+    /* write colors */

+    if (cmts && info->colors_cmt) {

+#ifndef VOID_SPRINTF

+	used_size +=

+#endif

+	snprintf(ptr + used_size, ptr_size-used_size, "/*%s*/\n", info->colors_cmt);

+#ifdef VOID_SPRINTF

+	used_size += strlen(info->colors_cmt) + 5;

+#endif

+    }

+    ErrorStatus = WriteColors(&ptr, &ptr_size, &used_size,

+			      image->colorTable, image->ncolors, image->cpp);

+ 

+    if (ErrorStatus != XpmSuccess)

+	RETURN(ErrorStatus);

+

+    /*

+     * now we know the exact size we need, realloc the data

+     * 4 = 1 (for '"') + 3 (for '",\n')

+     * 1 = - 2 (because the last line does not end with ',\n') + 3 (for '};\n')

+     */

+     if(image->width  > UINT_MAX / image->cpp ||

+       (tmp = image->width * image->cpp + 4) <= 4 ||

+        image->height > UINT_MAX / tmp ||

+       (tmp = image->height * tmp + 1) <= 1 ||

+       (ptr_size += tmp) <= tmp)

+	RETURN(XpmNoMemory);

+

+    p = (char *) XpmRealloc(ptr, ptr_size);

+    if (!p)

+	RETURN(XpmNoMemory);

+    ptr = p;

+

+    /* print pixels */

+    if (cmts && info->pixels_cmt) {

+#ifndef VOID_SPRINTF

+	used_size +=

+#endif

+	snprintf(ptr + used_size, ptr_size-used_size, "/*%s*/\n", info->pixels_cmt);

+#ifdef VOID_SPRINTF

+	used_size += strlen(info->pixels_cmt) + 5;

+#endif

+    }

+    WritePixels(ptr + used_size, ptr_size - used_size, &used_size, image->width, image->height,

+		image->cpp, image->data, image->colorTable);

+

+    /* print extensions */

+    if (extensions)

+	WriteExtensions(ptr + used_size, ptr_size-used_size, &used_size,

+			info->extensions, info->nextensions);

+

+    /* close the array */

+    strcpy(ptr + used_size, "};\n");

+

+    *buffer_return = ptr;

+

+    return (XpmSuccess);

+

+/* exit point in case of error, free only locally allocated variables */

+error:

+    if (ptr)

+	XpmFree(ptr);

+    return (ErrorStatus);

+}

+

+

+static int

+WriteColors(

+    char		**dataptr,

+    unsigned int	 *data_size,

+    unsigned int	 *used_size,

+    XpmColor		 *colors,

+    unsigned int	  ncolors,

+    unsigned int	  cpp)

+{

+    char buf[BUFSIZ] = {0};

+    unsigned int a, key, l;

+    char *s, *s2;

+    char **defaults;

+

+    *buf = '"';

+    for (a = 0; a < ncolors; a++, colors++) {

+

+	defaults = (char **) colors;

+	s = buf + 1;

+	if(cpp > (sizeof(buf) - (s-buf)))

+		return(XpmNoMemory);

+	strncpy(s, *defaults++, cpp);

+	s += cpp;

+

+	for (key = 1; key <= NKEYS; key++, defaults++) {

+	    if ((s2 = *defaults)) {

+#ifndef VOID_SPRINTF

+		s +=

+#endif

+		/* assume C99 compliance */

+		snprintf(s, sizeof(buf) - (s-buf), "\t%s %s", xpmColorKeys[key - 1], s2);

+#ifdef VOID_SPRINTF

+		s += strlen(s);

+#endif

+		/* now let's check if s points out-of-bounds */

+		if((s-buf) > sizeof(buf))

+			return(XpmNoMemory);

+	    }

+	}

+	if(sizeof(buf) - (s-buf) < 4)

+		return(XpmNoMemory);

+	strcpy(s, "\",\n");

+	l = s + 3 - buf;

+	if( *data_size                   >= UINT_MAX-l ||

+	    *data_size + l               <= *used_size ||

+	   (*data_size + l - *used_size) <= sizeof(buf))

+		return(XpmNoMemory);

+	s = (char *) XpmRealloc(*dataptr, *data_size + l);

+	if (!s)

+	    return (XpmNoMemory);

+	*data_size += l;

+	strcpy(s + *used_size, buf);

+	*used_size += l;

+	*dataptr = s;

+    }

+    return (XpmSuccess);

+}

+

+static void

+WritePixels(

+    char		*dataptr,

+    unsigned int	 data_size,

+    unsigned int	*used_size,

+    unsigned int	 width,

+    unsigned int	 height,

+    unsigned int	 cpp,

+    unsigned int	*pixels,

+    XpmColor		*colors)

+{

+    char *s = dataptr;

+    unsigned int x, y, h;

+

+    if(height <= 1)

+    	return;

+

+    h = height - 1;

+    for (y = 0; y < h; y++) {

+	*s++ = '"';

+	for (x = 0; x < width; x++, pixels++) {

+	    if(cpp >= (data_size - (s-dataptr)))

+		return;

+	    strncpy(s, colors[*pixels].string, cpp); /* how can we trust *pixels? :-\ */

+	    s += cpp;

+	}

+	if((data_size - (s-dataptr)) < 4)

+		return;

+	strcpy(s, "\",\n");

+	s += 3;

+    }

+    /* duplicate some code to avoid a test in the loop */

+    *s++ = '"';

+    for (x = 0; x < width; x++, pixels++) {

+	if(cpp >= (data_size - (s-dataptr)))

+	    return;

+	strncpy(s, colors[*pixels].string, cpp); /* how can we trust *pixels? */

+	s += cpp;

+    }

+    *s++ = '"';

+    *used_size += s - dataptr;

+}

+

+static unsigned int

+ExtensionsSize(

+    XpmExtension	*ext,

+    unsigned int	 num)

+{

+    unsigned int x, y, a, size;

+    char **line;

+

+    size = 0;

+    if(num == 0)

+    	return(0); /* ok? */

+    for (x = 0; x < num; x++, ext++) {

+	/* 11 = 10 (for ',\n"XPMEXT ') + 1 (for '"') */

+	size += strlen(ext->name) + 11;

+	a = ext->nlines; /* how can we trust ext->nlines to be not out-of-bounds? */

+	for (y = 0, line = ext->lines; y < a; y++, line++)

+	    /* 4 = 3 (for ',\n"') + 1 (for '"') */

+	    size += strlen(*line) + 4;

+    }

+    /* 13 is for ',\n"XPMENDEXT"' */

+    if(size > UINT_MAX - 13) /* unlikely */

+    	return(0);

+    return size + 13;

+}

+

+static void

+WriteExtensions(

+    char		*dataptr,

+    unsigned int	 data_size,

+    unsigned int	*used_size,

+    XpmExtension	*ext,

+    unsigned int	 num)

+{

+    unsigned int x, y, a;

+    char **line;

+    char *s = dataptr;

+

+    for (x = 0; x < num; x++, ext++) {

+#ifndef VOID_SPRINTF

+	s +=

+#endif

+	snprintf(s, data_size - (s-dataptr), ",\n\"XPMEXT %s\"", ext->name);

+#ifdef VOID_SPRINTF

+	s += strlen(ext->name) + 11;

+#endif

+	a = ext->nlines;

+	for (y = 0, line = ext->lines; y < a; y++, line++) {

+#ifndef VOID_SPRINTF

+	    s +=

+#endif

+	    snprintf(s, data_size - (s-dataptr), ",\n\"%s\"", *line);

+#ifdef VOID_SPRINTF

+	    s += strlen(*line) + 4;

+#endif

+	}

+    }

+    strncpy(s, ",\n\"XPMENDEXT\"", data_size - (s-dataptr)-1);

+    *used_size += s - dataptr + 13;

+}

+

+static int

+CommentsSize(XpmInfo *info)

+{

+    int size = 0;

+

+    /* 5 = 2 (for "/_*") + 3 (for "*_/\n") */

+    /* wrap possible but *very* unlikely */

+    if (info->hints_cmt)

+	size += 5 + strlen(info->hints_cmt);

+

+    if (info->colors_cmt)

+	size += 5 + strlen(info->colors_cmt);

+

+    if (info->pixels_cmt)

+	size += 5 + strlen(info->pixels_cmt);

+

+    return size;

+}

diff --git a/libXpm/src/CrDatFrI.c b/libXpm/src/CrDatFrI.c
index 0dacf5127..04bb9a046 100644
--- a/libXpm/src/CrDatFrI.c
+++ b/libXpm/src/CrDatFrI.c
@@ -1,403 +1,403 @@
-/*
- * Copyright (C) 1989-95 GROUPE BULL
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of GROUPE BULL shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from GROUPE BULL.
- */
-
-/*****************************************************************************\
-*  CrDataFI.c:                                                                *
-*                                                                             *
-*  XPM library                                                                *
-*  Scan an image and possibly its mask and create an XPM array                *
-*                                                                             *
-*  Developed by Arnaud Le Hors                                                *
-\*****************************************************************************/
-
-/* October 2004, source code review by Thomas Biege <thomas@suse.de> */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "XpmI.h"
-
-LFUNC(CreateColors, int, (char **dataptr, unsigned int *data_size,
-			  XpmColor *colors, unsigned int ncolors,
-			  unsigned int cpp));
-
-LFUNC(CreatePixels, void, (char **dataptr, unsigned int data_size,
-			   unsigned int width,
-			   unsigned int height, unsigned int cpp,
-			   unsigned int *pixels, XpmColor *colors));
-
-LFUNC(CountExtensions, void, (XpmExtension *ext, unsigned int num,
-			      unsigned int *ext_size,
-			      unsigned int *ext_nlines));
-
-LFUNC(CreateExtensions, void, (char **dataptr, unsigned int data_size,
-			       unsigned int offset,
-			       XpmExtension *ext, unsigned int num,
-			       unsigned int ext_nlines));
-
-int
-XpmCreateDataFromImage(
-    Display		  *display,
-    char		***data_return,
-    XImage		  *image,
-    XImage		  *shapeimage,
-    XpmAttributes	  *attributes)
-{
-    XpmImage xpmimage;
-    XpmInfo info;
-    int ErrorStatus;
-
-    /* initialize return value */
-    if (data_return)
-	*data_return = NULL;
-
-    /* create an XpmImage from the image */
-    ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,
-					     &xpmimage, attributes);
-    if (ErrorStatus != XpmSuccess)
-	return (ErrorStatus);
-
-    /* create the data from the XpmImage */
-    if (attributes) {
-	xpmSetInfo(&info, attributes);
-	ErrorStatus = XpmCreateDataFromXpmImage(data_return, &xpmimage, &info);
-    } else
-	ErrorStatus = XpmCreateDataFromXpmImage(data_return, &xpmimage, NULL);
-
-    /* free the XpmImage */
-    XpmFreeXpmImage(&xpmimage);
-
-    return (ErrorStatus);
-}
-
-#undef RETURN
-#define RETURN(status) \
-do \
-{ \
-      ErrorStatus = status; \
-      goto exit; \
-} while(0)
-
-int
-XpmCreateDataFromXpmImage(
-    char	***data_return,
-    XpmImage	  *image,
-    XpmInfo	  *info)
-{
-    /* calculation variables */
-    int ErrorStatus;
-    char buf[BUFSIZ];
-    char **header = NULL, **data, **sptr, **sptr2, *s;
-    unsigned int header_size, header_nlines;
-    unsigned int data_size, data_nlines;
-    unsigned int extensions = 0, ext_size = 0, ext_nlines = 0;
-    unsigned int offset, l, n;
-
-    *data_return = NULL;
-
-    extensions = info && (info->valuemask & XpmExtensions)
-	&& info->nextensions;
-
-    /* compute the number of extensions lines and size */
-    if (extensions)
-	CountExtensions(info->extensions, info->nextensions,
-			&ext_size, &ext_nlines);
-
-    /*
-     * alloc a temporary array of char pointer for the header section which
-     * is the hints line + the color table lines
-     */
-    header_nlines = 1 + image->ncolors; /* this may wrap and/or become 0 */
-
-    /* 2nd check superfluous if we do not need header_nlines any further */
-    if(header_nlines <= image->ncolors ||
-       header_nlines >= UINT_MAX / sizeof(char *))
-    	return(XpmNoMemory);
-
-    header_size = sizeof(char *) * header_nlines;
-    if (header_size >= UINT_MAX / sizeof(char *))
-	return (XpmNoMemory);
-    header = (char **) XpmCalloc(header_size, sizeof(char *)); /* can we trust image->ncolors */
-    if (!header)
-	return (XpmNoMemory);
-
-    /* print the hints line */
-    s = buf;
-#ifndef VOID_SPRINTF
-    s +=
-#endif
-    sprintf(s, "%d %d %d %d", image->width, image->height,
-	    image->ncolors, image->cpp);
-#ifdef VOID_SPRINTF
-    s += strlen(s);
-#endif
-
-    if (info && (info->valuemask & XpmHotspot)) {
-#ifndef VOID_SPRINTF
-	s +=
-#endif
-	sprintf(s, " %d %d", info->x_hotspot, info->y_hotspot);
-#ifdef VOID_SPRINTF
-	s += strlen(s);
-#endif
-    }
-    if (extensions) {
-	strcpy(s, " XPMEXT");
-	s += 7;
-    }
-    l = s - buf + 1;
-    *header = (char *) XpmMalloc(l);
-    if (!*header)
-	RETURN(XpmNoMemory);
-    header_size += l;
-    strcpy(*header, buf);
-
-    /* print colors */
-    ErrorStatus = CreateColors(header + 1, &header_size,
-			       image->colorTable, image->ncolors, image->cpp);
-
-    if (ErrorStatus != XpmSuccess)
-	RETURN(ErrorStatus);
-
-    /* now we know the size needed, alloc the data and copy the header lines */
-    offset = image->width * image->cpp + 1;
-
-    if(offset <= image->width || offset <= image->cpp)
-	RETURN(XpmNoMemory);
-
-    if( (image->height + ext_nlines) >= UINT_MAX / sizeof(char *))
-	RETURN(XpmNoMemory);
-    data_size = (image->height + ext_nlines) * sizeof(char *);
-
-    if (image->height > UINT_MAX / offset ||
-        image->height * offset > UINT_MAX - data_size)
-	RETURN(XpmNoMemory);
-    data_size += image->height * offset;
-
-    if( (header_size + ext_size) >= (UINT_MAX - data_size) )
-	RETURN(XpmNoMemory);
-    data_size += header_size + ext_size;
-
-    data = (char **) XpmMalloc(data_size);
-    if (!data)
-	RETURN(XpmNoMemory);
-
-    data_nlines = header_nlines + image->height + ext_nlines;
-    *data = (char *) (data + data_nlines);
-
-    /* can header have less elements then n suggests? */
-    n = image->ncolors;
-    for (l = 0, sptr = data, sptr2 = header; l <= n && sptr && sptr2; l++, sptr++, sptr2++) {
-	strcpy(*sptr, *sptr2);
-	*(sptr + 1) = *sptr + strlen(*sptr2) + 1;
-    }
-
-    /* print pixels */
-    data[header_nlines] = (char *) data + header_size
-	+ (image->height + ext_nlines) * sizeof(char *);
-
-    CreatePixels(data + header_nlines, data_size-header_nlines, image->width, image->height,
-		 image->cpp, image->data, image->colorTable);
-
-    /* print extensions */
-    if (extensions)
-	CreateExtensions(data + header_nlines + image->height - 1,
-			 data_size - header_nlines - image->height + 1, offset,
-			 info->extensions, info->nextensions,
-			 ext_nlines);
-
-    *data_return = data;
-    ErrorStatus = XpmSuccess;
-
-/* exit point, free only locally allocated variables */
-exit:
-    if (header) {
-	for (l = 0; l < header_nlines; l++)
-	    if (header[l])
-		XpmFree(header[l]);
-		XpmFree(header);
-    }
-    return(ErrorStatus);
-}
-
-static int
-CreateColors(
-    char		**dataptr,
-    unsigned int	 *data_size,
-    XpmColor		 *colors,
-    unsigned int	  ncolors,
-    unsigned int	  cpp)
-{
-    char buf[BUFSIZ];
-    unsigned int a, key, l;
-    char *s, *s2;
-    char **defaults;
-
-    /* can ncolors be trusted here? */
-    for (a = 0; a < ncolors; a++, colors++, dataptr++) {
-
-	defaults = (char **) colors;
-	if(sizeof(buf) <= cpp)
-	    return(XpmNoMemory);
-	strncpy(buf, *defaults++, cpp);
-	s = buf + cpp;
-
-	if(sizeof(buf) <= (s-buf))
-		return XpmNoMemory;
-
-	for (key = 1; key <= NKEYS; key++, defaults++) {
-	    if ((s2 = *defaults)) {
-#ifndef VOID_SPRINTF
-		s +=
-#endif
-		/* assume C99 compliance */
-			snprintf(s, sizeof(buf)-(s-buf), "\t%s %s", xpmColorKeys[key - 1], s2);
-#ifdef VOID_SPRINTF
-		s += strlen(s);
-#endif
-		/* does s point out-of-bounds? */
-		if(sizeof(buf) < (s-buf))
-			return XpmNoMemory;
-	    }
-	}
-	/* what about using strdup()? */
-	l = s - buf + 1;
-	s = (char *) XpmMalloc(l);
-	if (!s)
-	    return (XpmNoMemory);
-	*data_size += l;
-	*dataptr = strcpy(s, buf);
-    }
-    return (XpmSuccess);
-}
-
-static void
-CreatePixels(
-    char		**dataptr,
-    unsigned int	  data_size,
-    unsigned int	  width,
-    unsigned int	  height,
-    unsigned int	  cpp,
-    unsigned int	 *pixels,
-    XpmColor		 *colors)
-{
-    char *s;
-    unsigned int x, y, h, offset;
-
-    if(height <= 1)
-    	return;
-
-    h = height - 1;
-
-    offset = width * cpp + 1;
-
-    if(offset <= width || offset <= cpp)
-    	return;
-
-    /* why trust h? */
-    for (y = 0; y < h; y++, dataptr++) {
-	s = *dataptr;
-	/* why trust width? */
-	for (x = 0; x < width; x++, pixels++) {
-	    if(cpp > (data_size - (s - *dataptr)))
-	    	return;
-	    strncpy(s, colors[*pixels].string, cpp); /* why trust pixel? */
-	    s += cpp;
-	}
-	*s = '\0';
-	if(offset > data_size)
-		return;
-	*(dataptr + 1) = *dataptr + offset;
-    }
-    /* duplicate some code to avoid a test in the loop */
-    s = *dataptr;
-    /* why trust width? */
-    for (x = 0; x < width; x++, pixels++) {
-	if(cpp > data_size - (s - *dataptr))
-	    	return;
-	strncpy(s, colors[*pixels].string, cpp); /* why should we trust *pixel? */
-	s += cpp;
-    }
-    *s = '\0';
-}
-
-static void
-CountExtensions(
-    XpmExtension	*ext,
-    unsigned int	 num,
-    unsigned int	*ext_size,
-    unsigned int	*ext_nlines)
-{
-    unsigned int x, y, a, size, nlines;
-    char **line;
-
-    size = 0;
-    nlines = 0;
-    for (x = 0; x < num; x++, ext++) {
-	/* 1 for the name */
-	nlines += ext->nlines + 1;
-	/* 8 = 7 (for "XPMEXT ") + 1 (for 0) */
-	size += strlen(ext->name) + 8;
-	a = ext->nlines;
-	for (y = 0, line = ext->lines; y < a; y++, line++)
-	    size += strlen(*line) + 1;
-    }
-    /* 10 and 1 are for the ending "XPMENDEXT" */
-    *ext_size = size + 10;
-    *ext_nlines = nlines + 1;
-}
-
-static void
-CreateExtensions(
-    char		**dataptr,
-    unsigned int	  data_size,
-    unsigned int	  offset,
-    XpmExtension	 *ext,
-    unsigned int	  num,
-    unsigned int	  ext_nlines)
-{
-    unsigned int x, y, a, b;
-    char **line;
-
-    *(dataptr + 1) = *dataptr + offset;
-    dataptr++;
-    a = 0;
-    for (x = 0; x < num; x++, ext++) {
-	snprintf(*dataptr, data_size, "XPMEXT %s", ext->name);
-	a++;
-	if (a < ext_nlines)
-	    *(dataptr + 1) = *dataptr + strlen(ext->name) + 8;
-	dataptr++;
-	b = ext->nlines; /* can we trust these values? */
-	for (y = 0, line = ext->lines; y < b; y++, line++) {
-	    strcpy(*dataptr, *line);
-	    a++;
-	    if (a < ext_nlines)
-		*(dataptr + 1) = *dataptr + strlen(*line) + 1;
-	    dataptr++;
-	}
-    }
-    strcpy(*dataptr, "XPMENDEXT");
-}
+/*

+ * Copyright (C) 1989-95 GROUPE BULL

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to

+ * deal in the Software without restriction, including without limitation the

+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

+ * sell copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of GROUPE BULL shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from GROUPE BULL.

+ */

+

+/*****************************************************************************\

+*  CrDataFI.c:                                                                *

+*                                                                             *

+*  XPM library                                                                *

+*  Scan an image and possibly its mask and create an XPM array                *

+*                                                                             *

+*  Developed by Arnaud Le Hors                                                *

+\*****************************************************************************/

+

+/* October 2004, source code review by Thomas Biege <thomas@suse.de> */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include "XpmI.h"

+

+LFUNC(CreateColors, int, (char **dataptr, unsigned int *data_size,

+			  XpmColor *colors, unsigned int ncolors,

+			  unsigned int cpp));

+

+LFUNC(CreatePixels, void, (char **dataptr, unsigned int data_size,

+			   unsigned int width,

+			   unsigned int height, unsigned int cpp,

+			   unsigned int *pixels, XpmColor *colors));

+

+LFUNC(CountExtensions, void, (XpmExtension *ext, unsigned int num,

+			      unsigned int *ext_size,

+			      unsigned int *ext_nlines));

+

+LFUNC(CreateExtensions, void, (char **dataptr, unsigned int data_size,

+			       unsigned int offset,

+			       XpmExtension *ext, unsigned int num,

+			       unsigned int ext_nlines));

+

+int

+XpmCreateDataFromImage(

+    Display		  *display,

+    char		***data_return,

+    XImage		  *image,

+    XImage		  *shapeimage,

+    XpmAttributes	  *attributes)

+{

+    XpmImage xpmimage;

+    XpmInfo info;

+    int ErrorStatus;

+

+    /* initialize return value */

+    if (data_return)

+	*data_return = NULL;

+

+    /* create an XpmImage from the image */

+    ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,

+					     &xpmimage, attributes);

+    if (ErrorStatus != XpmSuccess)

+	return (ErrorStatus);

+

+    /* create the data from the XpmImage */

+    if (attributes) {

+	xpmSetInfo(&info, attributes);

+	ErrorStatus = XpmCreateDataFromXpmImage(data_return, &xpmimage, &info);

+    } else

+	ErrorStatus = XpmCreateDataFromXpmImage(data_return, &xpmimage, NULL);

+

+    /* free the XpmImage */

+    XpmFreeXpmImage(&xpmimage);

+

+    return (ErrorStatus);

+}

+

+#undef RETURN

+#define RETURN(status) \

+do \

+{ \

+      ErrorStatus = status; \

+      goto exit; \

+} while(0)

+

+int

+XpmCreateDataFromXpmImage(

+    char	***data_return,

+    XpmImage	  *image,

+    XpmInfo	  *info)

+{

+    /* calculation variables */

+    int ErrorStatus;

+    char buf[BUFSIZ];

+    char **header = NULL, **data, **sptr, **sptr2, *s;

+    unsigned int header_size, header_nlines;

+    unsigned int data_size, data_nlines;

+    unsigned int extensions = 0, ext_size = 0, ext_nlines = 0;

+    unsigned int offset, l, n;

+

+    *data_return = NULL;

+

+    extensions = info && (info->valuemask & XpmExtensions)

+	&& info->nextensions;

+

+    /* compute the number of extensions lines and size */

+    if (extensions)

+	CountExtensions(info->extensions, info->nextensions,

+			&ext_size, &ext_nlines);

+

+    /*

+     * alloc a temporary array of char pointer for the header section which

+     * is the hints line + the color table lines

+     */

+    header_nlines = 1 + image->ncolors; /* this may wrap and/or become 0 */

+

+    /* 2nd check superfluous if we do not need header_nlines any further */

+    if(header_nlines <= image->ncolors ||

+       header_nlines >= UINT_MAX / sizeof(char *))

+    	return(XpmNoMemory);

+

+    header_size = sizeof(char *) * header_nlines;

+    if (header_size >= UINT_MAX / sizeof(char *))

+	return (XpmNoMemory);

+    header = (char **) XpmCalloc(header_size, sizeof(char *)); /* can we trust image->ncolors */

+    if (!header)

+	return (XpmNoMemory);

+

+    /* print the hints line */

+    s = buf;

+#ifndef VOID_SPRINTF

+    s +=

+#endif

+    sprintf(s, "%d %d %d %d", image->width, image->height,

+	    image->ncolors, image->cpp);

+#ifdef VOID_SPRINTF

+    s += strlen(s);

+#endif

+

+    if (info && (info->valuemask & XpmHotspot)) {

+#ifndef VOID_SPRINTF

+	s +=

+#endif

+	sprintf(s, " %d %d", info->x_hotspot, info->y_hotspot);

+#ifdef VOID_SPRINTF

+	s += strlen(s);

+#endif

+    }

+    if (extensions) {

+	strcpy(s, " XPMEXT");

+	s += 7;

+    }

+    l = s - buf + 1;

+    *header = (char *) XpmMalloc(l);

+    if (!*header)

+	RETURN(XpmNoMemory);

+    header_size += l;

+    strcpy(*header, buf);

+

+    /* print colors */

+    ErrorStatus = CreateColors(header + 1, &header_size,

+			       image->colorTable, image->ncolors, image->cpp);

+

+    if (ErrorStatus != XpmSuccess)

+	RETURN(ErrorStatus);

+

+    /* now we know the size needed, alloc the data and copy the header lines */

+    offset = image->width * image->cpp + 1;

+

+    if(offset <= image->width || offset <= image->cpp)

+	RETURN(XpmNoMemory);

+

+    if( (image->height + ext_nlines) >= UINT_MAX / sizeof(char *))

+	RETURN(XpmNoMemory);

+    data_size = (image->height + ext_nlines) * sizeof(char *);

+

+    if (image->height > UINT_MAX / offset ||

+        image->height * offset > UINT_MAX - data_size)

+	RETURN(XpmNoMemory);

+    data_size += image->height * offset;

+

+    if( (header_size + ext_size) >= (UINT_MAX - data_size) )

+	RETURN(XpmNoMemory);

+    data_size += header_size + ext_size;

+

+    data = (char **) XpmMalloc(data_size);

+    if (!data)

+	RETURN(XpmNoMemory);

+

+    data_nlines = header_nlines + image->height + ext_nlines;

+    *data = (char *) (data + data_nlines);

+

+    /* can header have less elements then n suggests? */

+    n = image->ncolors;

+    for (l = 0, sptr = data, sptr2 = header; l <= n && sptr && sptr2; l++, sptr++, sptr2++) {

+	strcpy(*sptr, *sptr2);

+	*(sptr + 1) = *sptr + strlen(*sptr2) + 1;

+    }

+

+    /* print pixels */

+    data[header_nlines] = (char *) data + header_size

+	+ (image->height + ext_nlines) * sizeof(char *);

+

+    CreatePixels(data + header_nlines, data_size-header_nlines, image->width, image->height,

+		 image->cpp, image->data, image->colorTable);

+

+    /* print extensions */

+    if (extensions)

+	CreateExtensions(data + header_nlines + image->height - 1,

+			 data_size - header_nlines - image->height + 1, offset,

+			 info->extensions, info->nextensions,

+			 ext_nlines);

+

+    *data_return = data;

+    ErrorStatus = XpmSuccess;

+

+/* exit point, free only locally allocated variables */

+exit:

+    if (header) {

+	for (l = 0; l < header_nlines; l++)

+	    if (header[l])

+		XpmFree(header[l]);

+		XpmFree(header);

+    }

+    return(ErrorStatus);

+}

+

+static int

+CreateColors(

+    char		**dataptr,

+    unsigned int	 *data_size,

+    XpmColor		 *colors,

+    unsigned int	  ncolors,

+    unsigned int	  cpp)

+{

+    char buf[BUFSIZ];

+    unsigned int a, key, l;

+    char *s, *s2;

+    char **defaults;

+

+    /* can ncolors be trusted here? */

+    for (a = 0; a < ncolors; a++, colors++, dataptr++) {

+

+	defaults = (char **) colors;

+	if(sizeof(buf) <= cpp)

+	    return(XpmNoMemory);

+	strncpy(buf, *defaults++, cpp);

+	s = buf + cpp;

+

+	if(sizeof(buf) <= (s-buf))

+		return XpmNoMemory;

+

+	for (key = 1; key <= NKEYS; key++, defaults++) {

+	    if ((s2 = *defaults)) {

+#ifndef VOID_SPRINTF

+		s +=

+#endif

+		/* assume C99 compliance */

+			snprintf(s, sizeof(buf)-(s-buf), "\t%s %s", xpmColorKeys[key - 1], s2);

+#ifdef VOID_SPRINTF

+		s += strlen(s);

+#endif

+		/* does s point out-of-bounds? */

+		if(sizeof(buf) < (s-buf))

+			return XpmNoMemory;

+	    }

+	}

+	/* what about using strdup()? */

+	l = s - buf + 1;

+	s = (char *) XpmMalloc(l);

+	if (!s)

+	    return (XpmNoMemory);

+	*data_size += l;

+	*dataptr = strcpy(s, buf);

+    }

+    return (XpmSuccess);

+}

+

+static void

+CreatePixels(

+    char		**dataptr,

+    unsigned int	  data_size,

+    unsigned int	  width,

+    unsigned int	  height,

+    unsigned int	  cpp,

+    unsigned int	 *pixels,

+    XpmColor		 *colors)

+{

+    char *s;

+    unsigned int x, y, h, offset;

+

+    if(height <= 1)

+    	return;

+

+    h = height - 1;

+

+    offset = width * cpp + 1;

+

+    if(offset <= width || offset <= cpp)

+    	return;

+

+    /* why trust h? */

+    for (y = 0; y < h; y++, dataptr++) {

+	s = *dataptr;

+	/* why trust width? */

+	for (x = 0; x < width; x++, pixels++) {

+	    if(cpp > (data_size - (s - *dataptr)))

+	    	return;

+	    strncpy(s, colors[*pixels].string, cpp); /* why trust pixel? */

+	    s += cpp;

+	}

+	*s = '\0';

+	if(offset > data_size)

+		return;

+	*(dataptr + 1) = *dataptr + offset;

+    }

+    /* duplicate some code to avoid a test in the loop */

+    s = *dataptr;

+    /* why trust width? */

+    for (x = 0; x < width; x++, pixels++) {

+	if(cpp > data_size - (s - *dataptr))

+	    	return;

+	strncpy(s, colors[*pixels].string, cpp); /* why should we trust *pixel? */

+	s += cpp;

+    }

+    *s = '\0';

+}

+

+static void

+CountExtensions(

+    XpmExtension	*ext,

+    unsigned int	 num,

+    unsigned int	*ext_size,

+    unsigned int	*ext_nlines)

+{

+    unsigned int x, y, a, size, nlines;

+    char **line;

+

+    size = 0;

+    nlines = 0;

+    for (x = 0; x < num; x++, ext++) {

+	/* 1 for the name */

+	nlines += ext->nlines + 1;

+	/* 8 = 7 (for "XPMEXT ") + 1 (for 0) */

+	size += strlen(ext->name) + 8;

+	a = ext->nlines;

+	for (y = 0, line = ext->lines; y < a; y++, line++)

+	    size += strlen(*line) + 1;

+    }

+    /* 10 and 1 are for the ending "XPMENDEXT" */

+    *ext_size = size + 10;

+    *ext_nlines = nlines + 1;

+}

+

+static void

+CreateExtensions(

+    char		**dataptr,

+    unsigned int	  data_size,

+    unsigned int	  offset,

+    XpmExtension	 *ext,

+    unsigned int	  num,

+    unsigned int	  ext_nlines)

+{

+    unsigned int x, y, a, b;

+    char **line;

+

+    *(dataptr + 1) = *dataptr + offset;

+    dataptr++;

+    a = 0;

+    for (x = 0; x < num; x++, ext++) {

+	snprintf(*dataptr, data_size, "XPMEXT %s", ext->name);

+	a++;

+	if (a < ext_nlines)

+	    *(dataptr + 1) = *dataptr + strlen(ext->name) + 8;

+	dataptr++;

+	b = ext->nlines; /* can we trust these values? */

+	for (y = 0, line = ext->lines; y < b; y++, line++) {

+	    strcpy(*dataptr, *line);

+	    a++;

+	    if (a < ext_nlines)

+		*(dataptr + 1) = *dataptr + strlen(*line) + 1;

+	    dataptr++;

+	}

+    }

+    strcpy(*dataptr, "XPMENDEXT");

+}

diff --git a/libXpm/src/Makefile.am b/libXpm/src/Makefile.am
index 297d310b8..ba8797f7f 100644
--- a/libXpm/src/Makefile.am
+++ b/libXpm/src/Makefile.am
@@ -1,43 +1,43 @@
-# Daniel Stone disowns all copyright on this file.
-
-lib_LTLIBRARIES=libXpm.la
-
-AM_CPPFLAGS = -I$(top_srcdir)/include/X11/
-AM_CFLAGS = $(CWARNFLAGS) $(XPM_CFLAGS)
-
-libXpm_la_LDFLAGS = -version-number 4:11:0 -no-undefined
-libXpm_la_LIBADD =  $(XPM_LIBS)
-
-libXpm_la_SOURCES =					\
-	Attrib.c					\
-	CrBufFrI.c					\
-	CrBufFrP.c					\
-	CrDatFrI.c					\
-	CrDatFrP.c					\
-	CrIFrBuf.c					\
-	CrIFrDat.c					\
-	CrIFrP.c					\
-	CrPFrBuf.c					\
-	CrPFrDat.c					\
-	CrPFrI.c					\
-	Image.c						\
-	Info.c						\
-	RdFToBuf.c					\
-	RdFToDat.c					\
-	RdFToI.c					\
-	RdFToP.c					\
-	WrFFrBuf.c					\
-	WrFFrDat.c					\
-	WrFFrI.c					\
-	WrFFrP.c					\
-	XpmI.h						\
-	create.c					\
-	data.c						\
-	hashtab.c					\
-	misc.c						\
-	parse.c						\
-	rgb.c						\
-	rgbtab.h					\
-	scan.c
-
-EXTRA_DIST = amigax.c amigax.h simx.c simx.h
+# Daniel Stone disowns all copyright on this file.

+

+lib_LTLIBRARIES=libXpm.la

+

+AM_CPPFLAGS = -I$(top_srcdir)/include/X11/

+AM_CFLAGS = $(CWARNFLAGS) $(XPM_CFLAGS)

+

+libXpm_la_LDFLAGS = -version-number 4:11:0 -no-undefined

+libXpm_la_LIBADD =  $(XPM_LIBS)

+

+libXpm_la_SOURCES =					\

+	Attrib.c					\

+	CrBufFrI.c					\

+	CrBufFrP.c					\

+	CrDatFrI.c					\

+	CrDatFrP.c					\

+	CrIFrBuf.c					\

+	CrIFrDat.c					\

+	CrIFrP.c					\

+	CrPFrBuf.c					\

+	CrPFrDat.c					\

+	CrPFrI.c					\

+	Image.c						\

+	Info.c						\

+	RdFToBuf.c					\

+	RdFToDat.c					\

+	RdFToI.c					\

+	RdFToP.c					\

+	WrFFrBuf.c					\

+	WrFFrDat.c					\

+	WrFFrI.c					\

+	WrFFrP.c					\

+	XpmI.h						\

+	create.c					\

+	data.c						\

+	hashtab.c					\

+	misc.c						\

+	parse.c						\

+	rgb.c						\

+	rgbtab.h					\

+	scan.c

+

+EXTRA_DIST = amigax.c amigax.h simx.c simx.h

diff --git a/libXpm/src/RdFToBuf.c b/libXpm/src/RdFToBuf.c
index b719960af..d142750de 100644
--- a/libXpm/src/RdFToBuf.c
+++ b/libXpm/src/RdFToBuf.c
@@ -52,6 +52,7 @@
 #endif
 #if defined(FOR_MSW) || defined(WIN32)
 #include <io.h>
+typedef long off_t;
 #define stat _stat
 #define fstat _fstat
 #define fdopen _fdopen
diff --git a/libXpm/src/RdFToI.c b/libXpm/src/RdFToI.c
index e56e3f8b6..9f6e3c007 100644
--- a/libXpm/src/RdFToI.c
+++ b/libXpm/src/RdFToI.c
@@ -1,273 +1,274 @@
-/*
- * Copyright (C) 1989-95 GROUPE BULL
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of GROUPE BULL shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from GROUPE BULL.
- */
-
-/*****************************************************************************\
-*  RdFToI.c:                                                                  *
-*                                                                             *
-*  XPM library                                                                *
-*  Parse an XPM file and create the image and possibly its mask               *
-*                                                                             *
-*  Developed by Arnaud Le Hors                                                *
-\*****************************************************************************/
-
-/* October 2004, source code review by Thomas Biege <thomas@suse.de> */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "XpmI.h"
-#ifndef NO_ZPIPE
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#else
-#ifdef FOR_MSW
-#include <fcntl.h>
-#endif
-#endif
-
-LFUNC(OpenReadFile, int, (char *filename, xpmData *mdata));
-LFUNC(xpmDataClose, void, (xpmData *mdata));
-
-FUNC(xpmPipeThrough, FILE*, (int fd,
-			     const char *cmd,
-			     const char *arg1,
-			     const char *mode));
-
-#ifndef CXPMPROG
-int
-XpmReadFileToImage(
-    Display		 *display,
-    char		 *filename,
-    XImage		**image_return,
-    XImage		**shapeimage_return,
-    XpmAttributes	 *attributes)
-{
-    XpmImage image;
-    XpmInfo info;
-    int ErrorStatus;
-    xpmData mdata;
-
-    xpmInitXpmImage(&image);
-    xpmInitXpmInfo(&info);
-
-    /* open file to read */
-    if ((ErrorStatus = OpenReadFile(filename, &mdata)) != XpmSuccess)
-	return (ErrorStatus);
-
-    /* create the XImage from the XpmData */
-    if (attributes) {
-	xpmInitAttributes(attributes);
-	xpmSetInfoMask(&info, attributes);
-	ErrorStatus = xpmParseDataAndCreate(display, &mdata,
-					    image_return, shapeimage_return,
-					    &image, &info, attributes);
-    } else
-	ErrorStatus = xpmParseDataAndCreate(display, &mdata,
-					    image_return, shapeimage_return,
-					    &image, NULL, attributes);
-    if (attributes) {
-	if (ErrorStatus >= 0)		/* no fatal error */
-	    xpmSetAttributes(attributes, &image, &info);
-	XpmFreeXpmInfo(&info);
-    }
-
-    xpmDataClose(&mdata);
-    /* free the XpmImage */
-    XpmFreeXpmImage(&image);
-
-    return (ErrorStatus);
-}
-
-int
-XpmReadFileToXpmImage(
-    char	*filename,
-    XpmImage	*image,
-    XpmInfo	*info)
-{
-    xpmData mdata;
-    int ErrorStatus;
-
-    /* init returned values */
-    xpmInitXpmImage(image);
-    xpmInitXpmInfo(info);
-
-    /* open file to read */
-    if ((ErrorStatus = OpenReadFile(filename, &mdata)) != XpmSuccess)
-	return (ErrorStatus);
-
-    /* create the XpmImage from the XpmData */
-    ErrorStatus = xpmParseData(&mdata, image, info);
-
-    xpmDataClose(&mdata);
-
-    return (ErrorStatus);
-}
-#endif /* CXPMPROG */
-
-#ifndef NO_ZPIPE
-/* Do not depend on errno after read_through */
-FILE*
-xpmPipeThrough(
-    int		 fd,
-    const char	*cmd,
-    const char	*arg1,
-    const char	*mode)
-{
-    FILE* fp;
-    int status, fds[2], in = 0, out = 1;
-    pid_t pid;
-    if ( 'w' == *mode )
-	out = 0, in = 1;
-    if ( pipe(fds) < 0 )
-	return NULL;
-    pid = fork();
-    if ( pid < 0 )
-	goto fail1;
-    if ( 0 == pid )
-    {
-	close(fds[in]);
-	if ( dup2(fds[out], out) < 0 )
-	    goto err;
-	close(fds[out]);
-	if ( dup2(fd, in) < 0 )
-	    goto err;
-	close(fd);
-	pid = fork();
-	if ( pid < 0 )
-	    goto err;
-	if ( 0 == pid )
-	{
-	    execlp(cmd, cmd, arg1, (char *)NULL);
-	    perror(cmd);
-	    goto err;
-	}
-	_exit(0);
-    err:
-	_exit(1);
-    }
-    close(fds[out]);
-    /* calling process: wait for first child */
-    while ( waitpid(pid, &status, 0) < 0 && EINTR == errno )
-	;
-    if ( WIFSIGNALED(status) ||
-	 (WIFEXITED(status) && WEXITSTATUS(status) != 0) )
-	goto fail2;
-    fp = fdopen(fds[in], mode);
-    if ( !fp )
-	goto fail2;
-    close(fd); /* still open in 2nd child */
-    return fp;
-fail1:
-    close(fds[out]);
-fail2:
-    close(fds[in]);
-    return NULL;
-}
-#endif
-
-/*
- * open the given file to be read as an xpmData which is returned.
- */
-static int
-OpenReadFile(
-    char	*filename,
-    xpmData	*mdata)
-{
-    if (!filename) {
-	mdata->stream.file = (stdin);
-	mdata->type = XPMFILE;
-    } else {
-	int fd = open(filename, O_RDONLY);
-#if defined(NO_ZPIPE)
-	if ( fd < 0 )
-	    return XpmOpenFailed;
-#else
-	const char* ext = NULL;
-	if ( fd >= 0 )
-	    ext = strrchr(filename, '.');
-#ifdef STAT_ZFILE /* searching for z-files if the given name not found */
-	else
-	{
-	    size_t len = strlen(filename);
-	    char *compressfile = (char *) XpmMalloc(len + 4);
-	    if ( !compressfile )
-		return (XpmNoMemory);
-	    strcpy(compressfile, filename);
-	    strcpy(compressfile + len, ext = ".Z");
-	    fd = open(compressfile, O_RDONLY);
-	    if ( fd < 0 )
-	    {
-		strcpy(compressfile + len, ext = ".gz");
-		fd = open(compressfile, O_RDONLY);
-		if ( fd < 0 )
-		{
-		    XpmFree(compressfile);
-		    return XpmOpenFailed;
-		}
-	    }
-	    XpmFree(compressfile);
-	}
-#endif
-	if ( ext && !strcmp(ext, ".Z") )
-	{
-	    mdata->type = XPMPIPE;
-	    mdata->stream.file = xpmPipeThrough(fd, "uncompress", "-c", "r");
-	}
-	else if ( ext && !strcmp(ext, ".gz") )
-	{
-	    mdata->type = XPMPIPE;
-	    mdata->stream.file = xpmPipeThrough(fd, "gunzip", "-qc", "r");
-	}
-	else
-#endif /* z-files */
-	{
-	    mdata->type = XPMFILE;
-	    mdata->stream.file = fdopen(fd, "r");
-	}
-	if (!mdata->stream.file)
-	{
-	    close(fd);
-	    return (XpmOpenFailed);
-	}
-    }
-    mdata->CommentLength = 0;
-#ifdef CXPMPROG
-    mdata->lineNum = 0;
-    mdata->charNum = 0;
-#endif
-    return (XpmSuccess);
-}
-
-/*
- * close the file related to the xpmData if any
- */
-static void
-xpmDataClose(xpmData *mdata)
-{
-    if (mdata->stream.file != (stdin))
-	fclose(mdata->stream.file);
-}
+/*

+ * Copyright (C) 1989-95 GROUPE BULL

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to

+ * deal in the Software without restriction, including without limitation the

+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

+ * sell copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of GROUPE BULL shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from GROUPE BULL.

+ */

+

+/*****************************************************************************\

+*  RdFToI.c:                                                                  *

+*                                                                             *

+*  XPM library                                                                *

+*  Parse an XPM file and create the image and possibly its mask               *

+*                                                                             *

+*  Developed by Arnaud Le Hors                                                *

+\*****************************************************************************/

+

+/* October 2004, source code review by Thomas Biege <thomas@suse.de> */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include "XpmI.h"

+#ifndef NO_ZPIPE

+#include <fcntl.h>

+#include <errno.h>

+#include <sys/types.h>

+#include <sys/wait.h>

+typedef int pid_t;

+#else

+#ifdef FOR_MSW

+#include <fcntl.h>

+#endif

+#endif

+

+LFUNC(OpenReadFile, int, (char *filename, xpmData *mdata));

+LFUNC(xpmDataClose, void, (xpmData *mdata));

+

+FUNC(xpmPipeThrough, FILE*, (int fd,

+			     const char *cmd,

+			     const char *arg1,

+			     const char *mode));

+

+#ifndef CXPMPROG

+int

+XpmReadFileToImage(

+    Display		 *display,

+    char		 *filename,

+    XImage		**image_return,

+    XImage		**shapeimage_return,

+    XpmAttributes	 *attributes)

+{

+    XpmImage image;

+    XpmInfo info;

+    int ErrorStatus;

+    xpmData mdata;

+

+    xpmInitXpmImage(&image);

+    xpmInitXpmInfo(&info);

+

+    /* open file to read */

+    if ((ErrorStatus = OpenReadFile(filename, &mdata)) != XpmSuccess)

+	return (ErrorStatus);

+

+    /* create the XImage from the XpmData */

+    if (attributes) {

+	xpmInitAttributes(attributes);

+	xpmSetInfoMask(&info, attributes);

+	ErrorStatus = xpmParseDataAndCreate(display, &mdata,

+					    image_return, shapeimage_return,

+					    &image, &info, attributes);

+    } else

+	ErrorStatus = xpmParseDataAndCreate(display, &mdata,

+					    image_return, shapeimage_return,

+					    &image, NULL, attributes);

+    if (attributes) {

+	if (ErrorStatus >= 0)		/* no fatal error */

+	    xpmSetAttributes(attributes, &image, &info);

+	XpmFreeXpmInfo(&info);

+    }

+

+    xpmDataClose(&mdata);

+    /* free the XpmImage */

+    XpmFreeXpmImage(&image);

+

+    return (ErrorStatus);

+}

+

+int

+XpmReadFileToXpmImage(

+    char	*filename,

+    XpmImage	*image,

+    XpmInfo	*info)

+{

+    xpmData mdata;

+    int ErrorStatus;

+

+    /* init returned values */

+    xpmInitXpmImage(image);

+    xpmInitXpmInfo(info);

+

+    /* open file to read */

+    if ((ErrorStatus = OpenReadFile(filename, &mdata)) != XpmSuccess)

+	return (ErrorStatus);

+

+    /* create the XpmImage from the XpmData */

+    ErrorStatus = xpmParseData(&mdata, image, info);

+

+    xpmDataClose(&mdata);

+

+    return (ErrorStatus);

+}

+#endif /* CXPMPROG */

+

+#ifndef NO_ZPIPE

+/* Do not depend on errno after read_through */

+FILE*

+xpmPipeThrough(

+    int		 fd,

+    const char	*cmd,

+    const char	*arg1,

+    const char	*mode)

+{

+    FILE* fp;

+    int status, fds[2], in = 0, out = 1;

+    pid_t pid;

+    if ( 'w' == *mode )

+	out = 0, in = 1;

+    if ( pipe(fds) < 0 )

+	return NULL;

+    pid = fork();

+    if ( pid < 0 )

+	goto fail1;

+    if ( 0 == pid )

+    {

+	close(fds[in]);

+	if ( dup2(fds[out], out) < 0 )

+	    goto err;

+	close(fds[out]);

+	if ( dup2(fd, in) < 0 )

+	    goto err;

+	close(fd);

+	pid = fork();

+	if ( pid < 0 )

+	    goto err;

+	if ( 0 == pid )

+	{

+	    execlp(cmd, cmd, arg1, (char *)NULL);

+	    perror(cmd);

+	    goto err;

+	}

+	_exit(0);

+    err:

+	_exit(1);

+    }

+    close(fds[out]);

+    /* calling process: wait for first child */

+    while ( waitpid(pid, &status, 0) < 0 && EINTR == errno )

+	;

+    if ( WIFSIGNALED(status) ||

+	 (WIFEXITED(status) && WEXITSTATUS(status) != 0) )

+	goto fail2;

+    fp = fdopen(fds[in], mode);

+    if ( !fp )

+	goto fail2;

+    close(fd); /* still open in 2nd child */

+    return fp;

+fail1:

+    close(fds[out]);

+fail2:

+    close(fds[in]);

+    return NULL;

+}

+#endif

+

+/*

+ * open the given file to be read as an xpmData which is returned.

+ */

+static int

+OpenReadFile(

+    char	*filename,

+    xpmData	*mdata)

+{

+    if (!filename) {

+	mdata->stream.file = (stdin);

+	mdata->type = XPMFILE;

+    } else {

+	int fd = open(filename, O_RDONLY);

+#if defined(NO_ZPIPE)

+	if ( fd < 0 )

+	    return XpmOpenFailed;

+#else

+	const char* ext = NULL;

+	if ( fd >= 0 )

+	    ext = strrchr(filename, '.');

+#ifdef STAT_ZFILE /* searching for z-files if the given name not found */

+	else

+	{

+	    size_t len = strlen(filename);

+	    char *compressfile = (char *) XpmMalloc(len + 4);

+	    if ( !compressfile )

+		return (XpmNoMemory);

+	    strcpy(compressfile, filename);

+	    strcpy(compressfile + len, ext = ".Z");

+	    fd = open(compressfile, O_RDONLY);

+	    if ( fd < 0 )

+	    {

+		strcpy(compressfile + len, ext = ".gz");

+		fd = open(compressfile, O_RDONLY);

+		if ( fd < 0 )

+		{

+		    XpmFree(compressfile);

+		    return XpmOpenFailed;

+		}

+	    }

+	    XpmFree(compressfile);

+	}

+#endif

+	if ( ext && !strcmp(ext, ".Z") )

+	{

+	    mdata->type = XPMPIPE;

+	    mdata->stream.file = xpmPipeThrough(fd, "uncompress", "-c", "r");

+	}

+	else if ( ext && !strcmp(ext, ".gz") )

+	{

+	    mdata->type = XPMPIPE;

+	    mdata->stream.file = xpmPipeThrough(fd, "gunzip", "-qc", "r");

+	}

+	else

+#endif /* z-files */

+	{

+	    mdata->type = XPMFILE;

+	    mdata->stream.file = fdopen(fd, "r");

+	}

+	if (!mdata->stream.file)

+	{

+	    close(fd);

+	    return (XpmOpenFailed);

+	}

+    }

+    mdata->CommentLength = 0;

+#ifdef CXPMPROG

+    mdata->lineNum = 0;

+    mdata->charNum = 0;

+#endif

+    return (XpmSuccess);

+}

+

+/*

+ * close the file related to the xpmData if any

+ */

+static void

+xpmDataClose(xpmData *mdata)

+{

+    if (mdata->stream.file != (stdin))

+	fclose(mdata->stream.file);

+}

diff --git a/libXpm/src/WrFFrI.c b/libXpm/src/WrFFrI.c
index f2726f995..46e800577 100644
--- a/libXpm/src/WrFFrI.c
+++ b/libXpm/src/WrFFrI.c
@@ -1,363 +1,363 @@
-/*
- * Copyright (C) 1989-95 GROUPE BULL
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of GROUPE BULL shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from GROUPE BULL.
- */
-
-/*****************************************************************************\
-*  WrFFrI.c:                                                                  *
-*                                                                             *
-*  XPM library                                                                *
-*  Write an image and possibly its mask to an XPM file                        *
-*                                                                             *
-*  Developed by Arnaud Le Hors                                                *
-\*****************************************************************************/
-
-/*
- * The code related to AMIGA has been added by
- * Lorens Younes (d93-hyo@nada.kth.se) 4/96
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "XpmI.h"
-
-#ifndef NO_ZPIPE
-#include "sys/wait.h"
-#include "sys/types.h"
-#include "fcntl.h"
-#include "unistd.h"
-#include "errno.h"
-#endif
-
-/* MS Windows define a function called WriteFile @#%#&!!! */
-LFUNC(xpmWriteFile, int, (FILE *file, XpmImage *image, char *name,
-			  XpmInfo *info));
-
-LFUNC(WriteColors, void, (FILE *file, XpmColor *colors, unsigned int ncolors));
-
-LFUNC(WritePixels, int, (FILE *file, unsigned int width, unsigned int height,
-			 unsigned int cpp, unsigned int *pixels,
-			 XpmColor *colors));
-
-LFUNC(WriteExtensions, void, (FILE *file, XpmExtension *ext,
-			      unsigned int num));
-
-LFUNC(OpenWriteFile, int, (char *filename, xpmData *mdata));
-LFUNC(xpmDataClose, void, (xpmData *mdata));
-
-int
-XpmWriteFileFromImage(
-    Display		*display,
-    char		*filename,
-    XImage		*image,
-    XImage		*shapeimage,
-    XpmAttributes	*attributes)
-{
-    XpmImage xpmimage;
-    XpmInfo info;
-    int ErrorStatus;
-
-    /* create an XpmImage from the image */
-    ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,
-					     &xpmimage, attributes);
-    if (ErrorStatus != XpmSuccess)
-	return (ErrorStatus);
-
-    /* write the file from the XpmImage */
-    if (attributes) {
-	xpmSetInfo(&info, attributes);
-	ErrorStatus = XpmWriteFileFromXpmImage(filename, &xpmimage, &info);
-    } else
-	ErrorStatus = XpmWriteFileFromXpmImage(filename, &xpmimage, NULL);
-
-    /* free the XpmImage */
-    XpmFreeXpmImage(&xpmimage);
-
-    return (ErrorStatus);
-}
-
-int
-XpmWriteFileFromXpmImage(
-    char	*filename,
-    XpmImage	*image,
-    XpmInfo	*info)
-{
-    xpmData mdata;
-    char *name, *dot, *s, new_name[BUFSIZ] = {0};
-    int ErrorStatus;
-
-    /* open file to write */
-    if ((ErrorStatus = OpenWriteFile(filename, &mdata)) != XpmSuccess)
-	return (ErrorStatus);
-
-    /* figure out a name */
-    if (filename) {
-#ifdef VMS
-	name = filename;
-#else
-	if (!(name = strrchr(filename, '/'))
-#ifdef AMIGA
-	    && !(name = strrchr(filename, ':'))
-#endif
-     )
-	    name = filename;
-	else
-	    name++;
-#endif
-	/* let's try to make a valid C syntax name */
-	if (strchr(name, '.')) {
-	    strncpy(new_name, name, sizeof(new_name));
-	    new_name[sizeof(new_name)-1] = '\0';
-	    /* change '.' to '_' */
-	    name = s = new_name;
-	    while ((dot = strchr(s, '.'))) {
-		*dot = '_';
-		s = dot;
-	    }
-	}
-	if (strchr(name, '-')) {
-	    if (name != new_name) {
-		strncpy(new_name, name, sizeof(new_name));
-		new_name[sizeof(new_name)-1] = '\0';
-		name = new_name;
-	    }
-	    /* change '-' to '_' */
-	    s = name;
-	    while ((dot = strchr(s, '-'))) {
-		*dot = '_';
-		s = dot;
-	    }
-	}
-    } else
-	name = "image_name";
-
-    /* write the XpmData from the XpmImage */
-    if (ErrorStatus == XpmSuccess)
-	ErrorStatus = xpmWriteFile(mdata.stream.file, image, name, info);
-
-    xpmDataClose(&mdata);
-
-    return (ErrorStatus);
-}
-
-static int
-xpmWriteFile(
-    FILE	*file,
-    XpmImage	*image,
-    char	*name,
-    XpmInfo	*info)
-{
-    /* calculation variables */
-    unsigned int cmts, extensions;
-    int ErrorStatus;
-
-    cmts = info && (info->valuemask & XpmComments);
-    extensions = info && (info->valuemask & XpmExtensions)
-	&& info->nextensions;
-
-    /* print the header line */
-    fprintf(file, "/* XPM */\nstatic char * %s[] = {\n", name);
-
-    /* print the hints line */
-    if (cmts && info->hints_cmt)
-	fprintf(file, "/*%s*/\n", info->hints_cmt);
-
-    fprintf(file, "\"%d %d %d %d", image->width, image->height,
-	    image->ncolors, image->cpp);
-
-    if (info && (info->valuemask & XpmHotspot))
-	fprintf(file, " %d %d", info->x_hotspot, info->y_hotspot);
-
-    if (extensions)
-	fprintf(file, " XPMEXT");
-
-    fprintf(file, "\",\n");
-
-    /* print colors */
-    if (cmts && info->colors_cmt)
-	fprintf(file, "/*%s*/\n", info->colors_cmt);
-
-    WriteColors(file, image->colorTable, image->ncolors);
-
-    /* print pixels */
-    if (cmts && info->pixels_cmt)
-	fprintf(file, "/*%s*/\n", info->pixels_cmt);
-
-    ErrorStatus = WritePixels(file, image->width, image->height, image->cpp,
-			      image->data, image->colorTable);
-    if (ErrorStatus != XpmSuccess)
-	return (ErrorStatus);
-
-    /* print extensions */
-    if (extensions)
-	WriteExtensions(file, info->extensions, info->nextensions);
-
-    /* close the array */
-    fprintf(file, "};\n");
-
-    return (XpmSuccess);
-}
-
-static void
-WriteColors(
-    FILE		*file,
-    XpmColor		*colors,
-    unsigned int	 ncolors)
-{
-    unsigned int a, key;
-    char *s;
-    char **defaults;
-
-    for (a = 0; a < ncolors; a++, colors++) {
-
-	defaults = (char **) colors;
-	fprintf(file, "\"%s", *defaults++);
-
-	for (key = 1; key <= NKEYS; key++, defaults++) {
-	    if ((s = *defaults))
-		fprintf(file, "\t%s %s", xpmColorKeys[key - 1], s);
-	}
-	fprintf(file, "\",\n");
-    }
-}
-
-
-static int
-WritePixels(
-    FILE		*file,
-    unsigned int	 width,
-    unsigned int	 height,
-    unsigned int	 cpp,
-    unsigned int	*pixels,
-    XpmColor		*colors)
-{
-    char *s, *p, *buf;
-    unsigned int x, y, h;
-
-    h = height - 1;
-    if (cpp != 0 && width >= (UINT_MAX - 3)/cpp) 
-	return XpmNoMemory;    
-    p = buf = (char *) XpmMalloc(width * cpp + 3);
-    if (!buf)
-	return (XpmNoMemory);
-    *buf = '"';
-    p++;
-    for (y = 0; y < h; y++) {
-	s = p;
-	for (x = 0; x < width; x++, pixels++) {
-	    strncpy(s, colors[*pixels].string, cpp);
-	    s += cpp;
-	}
-	*s++ = '"';
-	*s = '\0';
-	fprintf(file, "%s,\n", buf);
-    }
-    /* duplicate some code to avoid a test in the loop */
-    s = p;
-    for (x = 0; x < width; x++, pixels++) {
-	strncpy(s, colors[*pixels].string, cpp);
-	s += cpp;
-    }
-    *s++ = '"';
-    *s = '\0';
-    fprintf(file, "%s", buf);
-
-    XpmFree(buf);
-    return (XpmSuccess);
-}
-
-static void
-WriteExtensions(
-    FILE		*file,
-    XpmExtension	*ext,
-    unsigned int	 num)
-{
-    unsigned int x, y, n;
-    char **line;
-
-    for (x = 0; x < num; x++, ext++) {
-	fprintf(file, ",\n\"XPMEXT %s\"", ext->name);
-	n = ext->nlines;
-	for (y = 0, line = ext->lines; y < n; y++, line++)
-	    fprintf(file, ",\n\"%s\"", *line);
-    }
-    fprintf(file, ",\n\"XPMENDEXT\"");
-}
-
-
-#ifndef NO_ZPIPE
-FUNC(xpmPipeThrough, FILE*, (int fd,
-			     const char* cmd,
-			     const char* arg1,
-			     const char* mode));
-#endif
-
-/*
- * open the given file to be written as an xpmData which is returned
- */
-static int
-OpenWriteFile(
-    char	*filename,
-    xpmData	*mdata)
-{
-    if (!filename) {
-	mdata->stream.file = (stdout);
-	mdata->type = XPMFILE;
-    } else {
-#ifndef NO_ZPIPE
-	size_t len;
-#endif
-	int fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0644);
-	if ( fd < 0 )
-	    return(XpmOpenFailed);
-#ifndef NO_ZPIPE
-	len = strlen(filename);
-	if (len > 2 && !strcmp(".Z", filename + (len - 2))) {
-	    mdata->stream.file = xpmPipeThrough(fd, "compress", NULL, "w");
-	    mdata->type = XPMPIPE;
-	} else if (len > 3 && !strcmp(".gz", filename + (len - 3))) {
-	    mdata->stream.file = xpmPipeThrough(fd, "gzip", "-q", "w");
-	    mdata->type = XPMPIPE;
-	} else
-#endif
-	{
-	    mdata->stream.file = fdopen(fd, "w");
-	    mdata->type = XPMFILE;
-	}
-	if (!mdata->stream.file)
-	    return (XpmOpenFailed);
-    }
-    return (XpmSuccess);
-}
-
-/*
- * close the file related to the xpmData if any
- */
-static void
-xpmDataClose(xpmData *mdata)
-{
-    if (mdata->stream.file != (stdout))
-	fclose(mdata->stream.file);
-}
-
+/*

+ * Copyright (C) 1989-95 GROUPE BULL

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to

+ * deal in the Software without restriction, including without limitation the

+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

+ * sell copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of GROUPE BULL shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from GROUPE BULL.

+ */

+

+/*****************************************************************************\

+*  WrFFrI.c:                                                                  *

+*                                                                             *

+*  XPM library                                                                *

+*  Write an image and possibly its mask to an XPM file                        *

+*                                                                             *

+*  Developed by Arnaud Le Hors                                                *

+\*****************************************************************************/

+

+/*

+ * The code related to AMIGA has been added by

+ * Lorens Younes (d93-hyo@nada.kth.se) 4/96

+ */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include "XpmI.h"

+

+#ifndef NO_ZPIPE

+#include "sys/wait.h"

+#include "sys/types.h"

+#include "fcntl.h"

+#include "unistd.h"

+#include "errno.h"

+#endif

+

+/* MS Windows define a function called WriteFile @#%#&!!! */

+LFUNC(xpmWriteFile, int, (FILE *file, XpmImage *image, char *name,

+			  XpmInfo *info));

+

+LFUNC(WriteColors, void, (FILE *file, XpmColor *colors, unsigned int ncolors));

+

+LFUNC(WritePixels, int, (FILE *file, unsigned int width, unsigned int height,

+			 unsigned int cpp, unsigned int *pixels,

+			 XpmColor *colors));

+

+LFUNC(WriteExtensions, void, (FILE *file, XpmExtension *ext,

+			      unsigned int num));

+

+LFUNC(OpenWriteFile, int, (char *filename, xpmData *mdata));

+LFUNC(xpmDataClose, void, (xpmData *mdata));

+

+int

+XpmWriteFileFromImage(

+    Display		*display,

+    char		*filename,

+    XImage		*image,

+    XImage		*shapeimage,

+    XpmAttributes	*attributes)

+{

+    XpmImage xpmimage;

+    XpmInfo info;

+    int ErrorStatus;

+

+    /* create an XpmImage from the image */

+    ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,

+					     &xpmimage, attributes);

+    if (ErrorStatus != XpmSuccess)

+	return (ErrorStatus);

+

+    /* write the file from the XpmImage */

+    if (attributes) {

+	xpmSetInfo(&info, attributes);

+	ErrorStatus = XpmWriteFileFromXpmImage(filename, &xpmimage, &info);

+    } else

+	ErrorStatus = XpmWriteFileFromXpmImage(filename, &xpmimage, NULL);

+

+    /* free the XpmImage */

+    XpmFreeXpmImage(&xpmimage);

+

+    return (ErrorStatus);

+}

+

+int

+XpmWriteFileFromXpmImage(

+    char	*filename,

+    XpmImage	*image,

+    XpmInfo	*info)

+{

+    xpmData mdata;

+    char *name, *dot, *s, new_name[BUFSIZ] = {0};

+    int ErrorStatus;

+

+    /* open file to write */

+    if ((ErrorStatus = OpenWriteFile(filename, &mdata)) != XpmSuccess)

+	return (ErrorStatus);

+

+    /* figure out a name */

+    if (filename) {

+#ifdef VMS

+	name = filename;

+#else

+	if (!(name = strrchr(filename, '/'))

+#ifdef AMIGA

+	    && !(name = strrchr(filename, ':'))

+#endif

+     )

+	    name = filename;

+	else

+	    name++;

+#endif

+	/* let's try to make a valid C syntax name */

+	if (strchr(name, '.')) {

+	    strncpy(new_name, name, sizeof(new_name));

+	    new_name[sizeof(new_name)-1] = '\0';

+	    /* change '.' to '_' */

+	    name = s = new_name;

+	    while ((dot = strchr(s, '.'))) {

+		*dot = '_';

+		s = dot;

+	    }

+	}

+	if (strchr(name, '-')) {

+	    if (name != new_name) {

+		strncpy(new_name, name, sizeof(new_name));

+		new_name[sizeof(new_name)-1] = '\0';

+		name = new_name;

+	    }

+	    /* change '-' to '_' */

+	    s = name;

+	    while ((dot = strchr(s, '-'))) {

+		*dot = '_';

+		s = dot;

+	    }

+	}

+    } else

+	name = "image_name";

+

+    /* write the XpmData from the XpmImage */

+    if (ErrorStatus == XpmSuccess)

+	ErrorStatus = xpmWriteFile(mdata.stream.file, image, name, info);

+

+    xpmDataClose(&mdata);

+

+    return (ErrorStatus);

+}

+

+static int

+xpmWriteFile(

+    FILE	*file,

+    XpmImage	*image,

+    char	*name,

+    XpmInfo	*info)

+{

+    /* calculation variables */

+    unsigned int cmts, extensions;

+    int ErrorStatus;

+

+    cmts = info && (info->valuemask & XpmComments);

+    extensions = info && (info->valuemask & XpmExtensions)

+	&& info->nextensions;

+

+    /* print the header line */

+    fprintf(file, "/* XPM */\nstatic char * %s[] = {\n", name);

+

+    /* print the hints line */

+    if (cmts && info->hints_cmt)

+	fprintf(file, "/*%s*/\n", info->hints_cmt);

+

+    fprintf(file, "\"%d %d %d %d", image->width, image->height,

+	    image->ncolors, image->cpp);

+

+    if (info && (info->valuemask & XpmHotspot))

+	fprintf(file, " %d %d", info->x_hotspot, info->y_hotspot);

+

+    if (extensions)

+	fprintf(file, " XPMEXT");

+

+    fprintf(file, "\",\n");

+

+    /* print colors */

+    if (cmts && info->colors_cmt)

+	fprintf(file, "/*%s*/\n", info->colors_cmt);

+

+    WriteColors(file, image->colorTable, image->ncolors);

+

+    /* print pixels */

+    if (cmts && info->pixels_cmt)

+	fprintf(file, "/*%s*/\n", info->pixels_cmt);

+

+    ErrorStatus = WritePixels(file, image->width, image->height, image->cpp,

+			      image->data, image->colorTable);

+    if (ErrorStatus != XpmSuccess)

+	return (ErrorStatus);

+

+    /* print extensions */

+    if (extensions)

+	WriteExtensions(file, info->extensions, info->nextensions);

+

+    /* close the array */

+    fprintf(file, "};\n");

+

+    return (XpmSuccess);

+}

+

+static void

+WriteColors(

+    FILE		*file,

+    XpmColor		*colors,

+    unsigned int	 ncolors)

+{

+    unsigned int a, key;

+    char *s;

+    char **defaults;

+

+    for (a = 0; a < ncolors; a++, colors++) {

+

+	defaults = (char **) colors;

+	fprintf(file, "\"%s", *defaults++);

+

+	for (key = 1; key <= NKEYS; key++, defaults++) {

+	    if ((s = *defaults))

+		fprintf(file, "\t%s %s", xpmColorKeys[key - 1], s);

+	}

+	fprintf(file, "\",\n");

+    }

+}

+

+

+static int

+WritePixels(

+    FILE		*file,

+    unsigned int	 width,

+    unsigned int	 height,

+    unsigned int	 cpp,

+    unsigned int	*pixels,

+    XpmColor		*colors)

+{

+    char *s, *p, *buf;

+    unsigned int x, y, h;

+

+    h = height - 1;

+    if (cpp != 0 && width >= (UINT_MAX - 3)/cpp) 

+	return XpmNoMemory;    

+    p = buf = (char *) XpmMalloc(width * cpp + 3);

+    if (!buf)

+	return (XpmNoMemory);

+    *buf = '"';

+    p++;

+    for (y = 0; y < h; y++) {

+	s = p;

+	for (x = 0; x < width; x++, pixels++) {

+	    strncpy(s, colors[*pixels].string, cpp);

+	    s += cpp;

+	}

+	*s++ = '"';

+	*s = '\0';

+	fprintf(file, "%s,\n", buf);

+    }

+    /* duplicate some code to avoid a test in the loop */

+    s = p;

+    for (x = 0; x < width; x++, pixels++) {

+	strncpy(s, colors[*pixels].string, cpp);

+	s += cpp;

+    }

+    *s++ = '"';

+    *s = '\0';

+    fprintf(file, "%s", buf);

+

+    XpmFree(buf);

+    return (XpmSuccess);

+}

+

+static void

+WriteExtensions(

+    FILE		*file,

+    XpmExtension	*ext,

+    unsigned int	 num)

+{

+    unsigned int x, y, n;

+    char **line;

+

+    for (x = 0; x < num; x++, ext++) {

+	fprintf(file, ",\n\"XPMEXT %s\"", ext->name);

+	n = ext->nlines;

+	for (y = 0, line = ext->lines; y < n; y++, line++)

+	    fprintf(file, ",\n\"%s\"", *line);

+    }

+    fprintf(file, ",\n\"XPMENDEXT\"");

+}

+

+

+#ifndef NO_ZPIPE

+FUNC(xpmPipeThrough, FILE*, (int fd,

+			     const char* cmd,

+			     const char* arg1,

+			     const char* mode));

+#endif

+

+/*

+ * open the given file to be written as an xpmData which is returned

+ */

+static int

+OpenWriteFile(

+    char	*filename,

+    xpmData	*mdata)

+{

+    if (!filename) {

+	mdata->stream.file = (stdout);

+	mdata->type = XPMFILE;

+    } else {

+#ifndef NO_ZPIPE

+	size_t len;

+#endif

+	int fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0644);

+	if ( fd < 0 )

+	    return(XpmOpenFailed);

+#ifndef NO_ZPIPE

+	len = strlen(filename);

+	if (len > 2 && !strcmp(".Z", filename + (len - 2))) {

+	    mdata->stream.file = xpmPipeThrough(fd, "compress", NULL, "w");

+	    mdata->type = XPMPIPE;

+	} else if (len > 3 && !strcmp(".gz", filename + (len - 3))) {

+	    mdata->stream.file = xpmPipeThrough(fd, "gzip", "-q", "w");

+	    mdata->type = XPMPIPE;

+	} else

+#endif

+	{

+	    mdata->stream.file = fdopen(fd, "w");

+	    mdata->type = XPMFILE;

+	}

+	if (!mdata->stream.file)

+	    return (XpmOpenFailed);

+    }

+    return (XpmSuccess);

+}

+

+/*

+ * close the file related to the xpmData if any

+ */

+static void

+xpmDataClose(xpmData *mdata)

+{

+    if (mdata->stream.file != (stdout))

+	fclose(mdata->stream.file);

+}

+

diff --git a/libXpm/src/XpmI.h b/libXpm/src/XpmI.h
index 9d4b1aeee..ead31ab82 100644
--- a/libXpm/src/XpmI.h
+++ b/libXpm/src/XpmI.h
@@ -1,332 +1,332 @@
-/*
- * Copyright (C) 1989-95 GROUPE BULL
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of GROUPE BULL shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from GROUPE BULL.
- */
-
-/*****************************************************************************\
-* XpmI.h:                                                                     *
-*                                                                             *
-*  XPM library                                                                *
-*  Internal Include file                                                      *
-*                                                                             *
-*  ** Everything defined here is subject to changes any time. **              *
-*                                                                             *
-*  Developed by Arnaud Le Hors                                                *
-\*****************************************************************************/
-
-/*
- * The code related to FOR_MSW has been added by
- * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
- */
-
-#ifndef XPMI_h
-#define XPMI_h
-
-#include "xpm.h"
-
-/*
- * lets try to solve include files
- */
-
-#include <sys/types.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <limits.h>
-/* stdio.h doesn't declare popen on a Sequent DYNIX OS */
-#ifdef sequent
-extern FILE *popen();
-#endif
-
-#ifdef FOR_MSW
-#include "simx.h"
-#else
-#include <X11/Xos.h>
-#include <X11/Xfuncs.h>
-#include <X11/Xmd.h>
-#endif
-
-#ifdef VMS
-#include <unixio.h>
-#include <file.h>
-#endif
-
-/* The following should help people wanting to use their own memory allocation
- * functions. To avoid the overhead of a function call when the standard
- * functions are used these are all macros, even the XpmFree function which
- * needs to be a real function for the outside world though.
- * So if change these be sure to change the XpmFree function in misc.c
- * accordingly.
- */
-#define XpmFree(ptr) free(ptr)
-
-#ifndef FOR_MSW
-#define XpmMalloc(size) malloc((size))
-#define XpmRealloc(ptr, size) realloc((ptr), (size))
-#define XpmCalloc(nelem, elsize) calloc((nelem), (elsize))
-#else
-/* checks for mallocs bigger than 64K */
-#define XpmMalloc(size) boundCheckingMalloc((long)(size))/* in simx.[ch] */
-#define XpmRealloc(ptr, size) boundCheckingRealloc((ptr),(long)(size))
-#define XpmCalloc(nelem, elsize) \
-		boundCheckingCalloc((long)(nelem),(long) (elsize))
-#endif
-
-#if defined(SCO) || defined(__USLC__)
-#include <stdint.h>	/* For SIZE_MAX */
-#endif
-#include <limits.h>
-#ifndef SIZE_MAX
-# ifdef ULONG_MAX
-#  define SIZE_MAX ULONG_MAX
-# else 
-#  define SIZE_MAX UINT_MAX
-# endif
-#endif
-
-#define XPMMAXCMTLEN BUFSIZ
-typedef struct {
-    unsigned int type;
-    union {
-	FILE *file;
-	char **data;
-    }     stream;
-    char *cptr;
-    unsigned int line;
-    int CommentLength;
-    char Comment[XPMMAXCMTLEN];
-    char *Bcmt, *Ecmt, Bos, Eos;
-    int format;			/* 1 if XPM1, 0 otherwise */
-#ifdef CXPMPROG
-    int lineNum;
-    int charNum;
-#endif
-}      xpmData;
-
-#define XPMARRAY 0
-#define XPMFILE  1
-#define XPMPIPE  2
-#define XPMBUFFER 3
-
-#define EOL '\n'
-#define TAB '\t'
-#define SPC ' '
-
-typedef struct {
-    char *type;			/* key word */
-    char *Bcmt;			/* string beginning comments */
-    char *Ecmt;			/* string ending comments */
-    char Bos;			/* character beginning strings */
-    char Eos;			/* character ending strings */
-    char *Strs;			/* strings separator */
-    char *Dec;			/* data declaration string */
-    char *Boa;			/* string beginning assignment */
-    char *Eoa;			/* string ending assignment */
-}      xpmDataType;
-
-extern xpmDataType xpmDataTypes[];
-
-/*
- * rgb values and ascii names (from rgb text file) rgb values,
- * range of 0 -> 65535 color mnemonic of rgb value
- */
-typedef struct {
-    int r, g, b;
-    char *name;
-}      xpmRgbName;
-
-/* Maximum number of rgb mnemonics allowed in rgb text file. */
-#define MAX_RGBNAMES 1024
-
-extern char *xpmColorKeys[];
-
-#define TRANSPARENT_COLOR "None"	/* this must be a string! */
-
-/* number of xpmColorKeys */
-#define NKEYS 5
-
-/* XPM internal routines */
-
-FUNC(xpmParseData, int, (xpmData *data, XpmImage *image, XpmInfo *info));
-FUNC(xpmParseDataAndCreate, int, (Display *display, xpmData *data,
-				  XImage **image_return,
-				  XImage **shapeimage_return,
-				  XpmImage *image, XpmInfo *info,
-				  XpmAttributes *attributes));
-
-FUNC(xpmFreeColorTable, void, (XpmColor *colorTable, int ncolors));
-
-FUNC(xpmInitAttributes, void, (XpmAttributes *attributes));
-
-FUNC(xpmInitXpmImage, void, (XpmImage *image));
-
-FUNC(xpmInitXpmInfo, void, (XpmInfo *info));
-
-FUNC(xpmSetInfoMask, void, (XpmInfo *info, XpmAttributes *attributes));
-FUNC(xpmSetInfo, void, (XpmInfo *info, XpmAttributes *attributes));
-FUNC(xpmSetAttributes, void, (XpmAttributes *attributes, XpmImage *image,
-			      XpmInfo *info));
-
-#if !defined(FOR_MSW) && !defined(AMIGA)
-FUNC(xpmCreatePixmapFromImage, void, (Display *display, Drawable d,
-				      XImage *ximage, Pixmap *pixmap_return));
-
-FUNC(xpmCreateImageFromPixmap, void, (Display *display, Pixmap pixmap,
-				      XImage **ximage_return,
-				      unsigned int *width,
-				      unsigned int *height));
-#endif
-
-/* structures and functions related to hastable code */
-
-typedef struct _xpmHashAtom {
-    char *name;
-    void *data;
-}      *xpmHashAtom;
-
-typedef struct {
-    unsigned int size;
-    unsigned int limit;
-    unsigned int used;
-    xpmHashAtom *atomTable;
-}      xpmHashTable;
-
-FUNC(xpmHashTableInit, int, (xpmHashTable *table));
-FUNC(xpmHashTableFree, void, (xpmHashTable *table));
-FUNC(xpmHashSlot, xpmHashAtom *, (xpmHashTable *table, char *s));
-FUNC(xpmHashIntern, int, (xpmHashTable *table, char *tag, void *data));
-
-#define HashAtomData(i) ((void *)(long)i)
-#define HashColorIndex(slot) ((unsigned long)((*slot)->data))
-#define USE_HASHTABLE (cpp > 2 && ncolors > 4)
-
-/* I/O utility */
-
-FUNC(xpmNextString, int, (xpmData *mdata));
-FUNC(xpmNextUI, int, (xpmData *mdata, unsigned int *ui_return));
-FUNC(xpmGetString, int, (xpmData *mdata, char **sptr, unsigned int *l));
-
-#define xpmGetC(mdata) \
-	((!mdata->type || mdata->type == XPMBUFFER) ? \
-	 (*mdata->cptr++) : (getc(mdata->stream.file)))
-
-FUNC(xpmNextWord, unsigned int,
-     (xpmData *mdata, char *buf, unsigned int buflen));
-FUNC(xpmGetCmt, int, (xpmData *mdata, char **cmt));
-FUNC(xpmParseHeader, int, (xpmData *mdata));
-FUNC(xpmParseValues, int, (xpmData *data, unsigned int *width,
-			   unsigned int *height, unsigned int *ncolors,
-			   unsigned int *cpp, unsigned int *x_hotspot,
-			   unsigned int *y_hotspot, unsigned int *hotspot,
-			   unsigned int *extensions));
-
-FUNC(xpmParseColors, int, (xpmData *data, unsigned int ncolors,
-			   unsigned int cpp, XpmColor **colorTablePtr,
-			   xpmHashTable *hashtable));
-
-FUNC(xpmParseExtensions, int, (xpmData *data, XpmExtension **extensions,
-			       unsigned int *nextensions));
-
-/* RGB utility */
-
-FUNC(xpmReadRgbNames, int, (char *rgb_fname, xpmRgbName *rgbn));
-FUNC(xpmGetRgbName, char *, (xpmRgbName *rgbn, int rgbn_max,
-			     int red, int green, int blue));
-FUNC(xpmFreeRgbNames, void, (xpmRgbName *rgbn, int rgbn_max));
-#ifdef FOR_MSW
-FUNC(xpmGetRGBfromName,int, (char *name, int *r, int *g, int *b));
-#endif
-
-#ifndef AMIGA
-FUNC(xpm_xynormalizeimagebits, void, (register unsigned char *bp,
-				      register XImage *img));
-FUNC(xpm_znormalizeimagebits, void, (register unsigned char *bp,
-				     register XImage *img));
-
-/*
- * Macros
- *
- * The XYNORMALIZE macro determines whether XY format data requires
- * normalization and calls a routine to do so if needed. The logic in
- * this module is designed for LSBFirst byte and bit order, so
- * normalization is done as required to present the data in this order.
- *
- * The ZNORMALIZE macro performs byte and nibble order normalization if
- * required for Z format data.
- *
- * The XYINDEX macro computes the index to the starting byte (char) boundary
- * for a bitmap_unit containing a pixel with coordinates x and y for image
- * data in XY format.
- *
- * The ZINDEX* macros compute the index to the starting byte (char) boundary
- * for a pixel with coordinates x and y for image data in ZPixmap format.
- *
- */
-
-#define XYNORMALIZE(bp, img) \
-    if ((img->byte_order == MSBFirst) || (img->bitmap_bit_order == MSBFirst)) \
-	xpm_xynormalizeimagebits((unsigned char *)(bp), img)
-
-#define ZNORMALIZE(bp, img) \
-    if (img->byte_order == MSBFirst) \
-	xpm_znormalizeimagebits((unsigned char *)(bp), img)
-
-#define XYINDEX(x, y, img) \
-    ((y) * img->bytes_per_line) + \
-    (((x) + img->xoffset) / img->bitmap_unit) * (img->bitmap_unit >> 3)
-
-#define ZINDEX(x, y, img) ((y) * img->bytes_per_line) + \
-    (((x) * img->bits_per_pixel) >> 3)
-
-#define ZINDEX32(x, y, img) ((y) * img->bytes_per_line) + ((x) << 2)
-
-#define ZINDEX16(x, y, img) ((y) * img->bytes_per_line) + ((x) << 1)
-
-#define ZINDEX8(x, y, img) ((y) * img->bytes_per_line) + (x)
-
-#define ZINDEX1(x, y, img) ((y) * img->bytes_per_line) + ((x) >> 3)
-#endif /* not AMIGA */
-
-#ifdef __STDC__
-#define Const const
-#else
-#define Const /**/
-#endif
-
-#ifdef NEED_STRDUP
-FUNC(xpmstrdup, char *, (char *s1));
-#else
-#undef xpmstrdup
-#define xpmstrdup strdup
-#endif
-
-#ifdef NEED_STRCASECMP                   
-FUNC(xpmstrcasecmp, int, (char *s1, char *s2));
-#else
-#undef xpmstrcasecmp
-#define xpmstrcasecmp strcasecmp
-#endif
-
-FUNC(xpmatoui, unsigned int,
-     (char *p, unsigned int l, unsigned int *ui_return));
-
-#endif
+/*

+ * Copyright (C) 1989-95 GROUPE BULL

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to

+ * deal in the Software without restriction, including without limitation the

+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

+ * sell copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of GROUPE BULL shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from GROUPE BULL.

+ */

+

+/*****************************************************************************\

+* XpmI.h:                                                                     *

+*                                                                             *

+*  XPM library                                                                *

+*  Internal Include file                                                      *

+*                                                                             *

+*  ** Everything defined here is subject to changes any time. **              *

+*                                                                             *

+*  Developed by Arnaud Le Hors                                                *

+\*****************************************************************************/

+

+/*

+ * The code related to FOR_MSW has been added by

+ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94

+ */

+

+#ifndef XPMI_h

+#define XPMI_h

+

+#include "xpm.h"

+

+/*

+ * lets try to solve include files

+ */

+

+#include <sys/types.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <limits.h>

+/* stdio.h doesn't declare popen on a Sequent DYNIX OS */

+#ifdef sequent

+extern FILE *popen();

+#endif

+

+#ifdef FOR_MSW

+#include "simx.h"

+#else

+#include <X11/Xos.h>

+#include <X11/Xfuncs.h>

+#include <X11/Xmd.h>

+#endif

+

+#ifdef VMS

+#include <unixio.h>

+#include <file.h>

+#endif

+

+/* The following should help people wanting to use their own memory allocation

+ * functions. To avoid the overhead of a function call when the standard

+ * functions are used these are all macros, even the XpmFree function which

+ * needs to be a real function for the outside world though.

+ * So if change these be sure to change the XpmFree function in misc.c

+ * accordingly.

+ */

+#define XpmFree(ptr) free(ptr)

+

+#ifndef FOR_MSW

+#define XpmMalloc(size) malloc((size))

+#define XpmRealloc(ptr, size) realloc((ptr), (size))

+#define XpmCalloc(nelem, elsize) calloc((nelem), (elsize))

+#else

+/* checks for mallocs bigger than 64K */

+#define XpmMalloc(size) boundCheckingMalloc((long)(size))/* in simx.[ch] */

+#define XpmRealloc(ptr, size) boundCheckingRealloc((ptr),(long)(size))

+#define XpmCalloc(nelem, elsize) \

+		boundCheckingCalloc((long)(nelem),(long) (elsize))

+#endif

+

+#if defined(SCO) || defined(__USLC__)

+#include <stdint.h>	/* For SIZE_MAX */

+#endif

+#include <limits.h>

+#ifndef SIZE_MAX

+# ifdef ULONG_MAX

+#  define SIZE_MAX ULONG_MAX

+# else 

+#  define SIZE_MAX UINT_MAX

+# endif

+#endif

+

+#define XPMMAXCMTLEN BUFSIZ

+typedef struct {

+    unsigned int type;

+    union {

+	FILE *file;

+	char **data;

+    }     stream;

+    char *cptr;

+    unsigned int line;

+    int CommentLength;

+    char Comment[XPMMAXCMTLEN];

+    char *Bcmt, *Ecmt, Bos, Eos;

+    int format;			/* 1 if XPM1, 0 otherwise */

+#ifdef CXPMPROG

+    int lineNum;

+    int charNum;

+#endif

+}      xpmData;

+

+#define XPMARRAY 0

+#define XPMFILE  1

+#define XPMPIPE  2

+#define XPMBUFFER 3

+

+#define EOL '\n'

+#define TAB '\t'

+#define SPC ' '

+

+typedef struct {

+    char *type;			/* key word */

+    char *Bcmt;			/* string beginning comments */

+    char *Ecmt;			/* string ending comments */

+    char Bos;			/* character beginning strings */

+    char Eos;			/* character ending strings */

+    char *Strs;			/* strings separator */

+    char *Dec;			/* data declaration string */

+    char *Boa;			/* string beginning assignment */

+    char *Eoa;			/* string ending assignment */

+}      xpmDataType;

+

+extern xpmDataType xpmDataTypes[];

+

+/*

+ * rgb values and ascii names (from rgb text file) rgb values,

+ * range of 0 -> 65535 color mnemonic of rgb value

+ */

+typedef struct {

+    int r, g, b;

+    char *name;

+}      xpmRgbName;

+

+/* Maximum number of rgb mnemonics allowed in rgb text file. */

+#define MAX_RGBNAMES 1024

+

+extern char *xpmColorKeys[];

+

+#define TRANSPARENT_COLOR "None"	/* this must be a string! */

+

+/* number of xpmColorKeys */

+#define NKEYS 5

+

+/* XPM internal routines */

+

+FUNC(xpmParseData, int, (xpmData *data, XpmImage *image, XpmInfo *info));

+FUNC(xpmParseDataAndCreate, int, (Display *display, xpmData *data,

+				  XImage **image_return,

+				  XImage **shapeimage_return,

+				  XpmImage *image, XpmInfo *info,

+				  XpmAttributes *attributes));

+

+FUNC(xpmFreeColorTable, void, (XpmColor *colorTable, int ncolors));

+

+FUNC(xpmInitAttributes, void, (XpmAttributes *attributes));

+

+FUNC(xpmInitXpmImage, void, (XpmImage *image));

+

+FUNC(xpmInitXpmInfo, void, (XpmInfo *info));

+

+FUNC(xpmSetInfoMask, void, (XpmInfo *info, XpmAttributes *attributes));

+FUNC(xpmSetInfo, void, (XpmInfo *info, XpmAttributes *attributes));

+FUNC(xpmSetAttributes, void, (XpmAttributes *attributes, XpmImage *image,

+			      XpmInfo *info));

+

+#if !defined(FOR_MSW) && !defined(AMIGA)

+FUNC(xpmCreatePixmapFromImage, void, (Display *display, Drawable d,

+				      XImage *ximage, Pixmap *pixmap_return));

+

+FUNC(xpmCreateImageFromPixmap, void, (Display *display, Pixmap pixmap,

+				      XImage **ximage_return,

+				      unsigned int *width,

+				      unsigned int *height));

+#endif

+

+/* structures and functions related to hastable code */

+

+typedef struct _xpmHashAtom {

+    char *name;

+    void *data;

+}      *xpmHashAtom;

+

+typedef struct {

+    unsigned int size;

+    unsigned int limit;

+    unsigned int used;

+    xpmHashAtom *atomTable;

+}      xpmHashTable;

+

+FUNC(xpmHashTableInit, int, (xpmHashTable *table));

+FUNC(xpmHashTableFree, void, (xpmHashTable *table));

+FUNC(xpmHashSlot, xpmHashAtom *, (xpmHashTable *table, char *s));

+FUNC(xpmHashIntern, int, (xpmHashTable *table, char *tag, void *data));

+

+#define HashAtomData(i) ((void *)(long)i)

+#define HashColorIndex(slot) ((unsigned long)((*slot)->data))

+#define USE_HASHTABLE (cpp > 2 && ncolors > 4)

+

+/* I/O utility */

+

+FUNC(xpmNextString, int, (xpmData *mdata));

+FUNC(xpmNextUI, int, (xpmData *mdata, unsigned int *ui_return));

+FUNC(xpmGetString, int, (xpmData *mdata, char **sptr, unsigned int *l));

+

+#define xpmGetC(mdata) \

+	((!mdata->type || mdata->type == XPMBUFFER) ? \

+	 (*mdata->cptr++) : (getc(mdata->stream.file)))

+

+FUNC(xpmNextWord, unsigned int,

+     (xpmData *mdata, char *buf, unsigned int buflen));

+FUNC(xpmGetCmt, int, (xpmData *mdata, char **cmt));

+FUNC(xpmParseHeader, int, (xpmData *mdata));

+FUNC(xpmParseValues, int, (xpmData *data, unsigned int *width,

+			   unsigned int *height, unsigned int *ncolors,

+			   unsigned int *cpp, unsigned int *x_hotspot,

+			   unsigned int *y_hotspot, unsigned int *hotspot,

+			   unsigned int *extensions));

+

+FUNC(xpmParseColors, int, (xpmData *data, unsigned int ncolors,

+			   unsigned int cpp, XpmColor **colorTablePtr,

+			   xpmHashTable *hashtable));

+

+FUNC(xpmParseExtensions, int, (xpmData *data, XpmExtension **extensions,

+			       unsigned int *nextensions));

+

+/* RGB utility */

+

+FUNC(xpmReadRgbNames, int, (char *rgb_fname, xpmRgbName *rgbn));

+FUNC(xpmGetRgbName, char *, (xpmRgbName *rgbn, int rgbn_max,

+			     int red, int green, int blue));

+FUNC(xpmFreeRgbNames, void, (xpmRgbName *rgbn, int rgbn_max));

+#ifdef FOR_MSW

+FUNC(xpmGetRGBfromName,int, (char *name, int *r, int *g, int *b));

+#endif

+

+#ifndef AMIGA

+FUNC(xpm_xynormalizeimagebits, void, (register unsigned char *bp,

+				      register XImage *img));

+FUNC(xpm_znormalizeimagebits, void, (register unsigned char *bp,

+				     register XImage *img));

+

+/*

+ * Macros

+ *

+ * The XYNORMALIZE macro determines whether XY format data requires

+ * normalization and calls a routine to do so if needed. The logic in

+ * this module is designed for LSBFirst byte and bit order, so

+ * normalization is done as required to present the data in this order.

+ *

+ * The ZNORMALIZE macro performs byte and nibble order normalization if

+ * required for Z format data.

+ *

+ * The XYINDEX macro computes the index to the starting byte (char) boundary

+ * for a bitmap_unit containing a pixel with coordinates x and y for image

+ * data in XY format.

+ *

+ * The ZINDEX* macros compute the index to the starting byte (char) boundary

+ * for a pixel with coordinates x and y for image data in ZPixmap format.

+ *

+ */

+

+#define XYNORMALIZE(bp, img) \

+    if ((img->byte_order == MSBFirst) || (img->bitmap_bit_order == MSBFirst)) \

+	xpm_xynormalizeimagebits((unsigned char *)(bp), img)

+

+#define ZNORMALIZE(bp, img) \

+    if (img->byte_order == MSBFirst) \

+	xpm_znormalizeimagebits((unsigned char *)(bp), img)

+

+#define XYINDEX(x, y, img) \

+    ((y) * img->bytes_per_line) + \

+    (((x) + img->xoffset) / img->bitmap_unit) * (img->bitmap_unit >> 3)

+

+#define ZINDEX(x, y, img) ((y) * img->bytes_per_line) + \

+    (((x) * img->bits_per_pixel) >> 3)

+

+#define ZINDEX32(x, y, img) ((y) * img->bytes_per_line) + ((x) << 2)

+

+#define ZINDEX16(x, y, img) ((y) * img->bytes_per_line) + ((x) << 1)

+

+#define ZINDEX8(x, y, img) ((y) * img->bytes_per_line) + (x)

+

+#define ZINDEX1(x, y, img) ((y) * img->bytes_per_line) + ((x) >> 3)

+#endif /* not AMIGA */

+

+#ifdef __STDC__

+#define Const const

+#else

+#define Const /**/

+#endif

+

+#ifdef NEED_STRDUP

+FUNC(xpmstrdup, char *, (char *s1));

+#else

+#undef xpmstrdup

+#define xpmstrdup strdup

+#endif

+

+#ifdef NEED_STRCASECMP                   

+FUNC(xpmstrcasecmp, int, (char *s1, char *s2));

+#else

+#undef xpmstrcasecmp

+#define xpmstrcasecmp strcasecmp

+#endif

+

+FUNC(xpmatoui, unsigned int,

+     (char *p, unsigned int l, unsigned int *ui_return));

+

+#endif

diff --git a/libXpm/src/amigax.h b/libXpm/src/amigax.h
index 213ed7619..b8f6ac4b7 100644
--- a/libXpm/src/amigax.h
+++ b/libXpm/src/amigax.h
@@ -48,8 +48,8 @@
 /* really never used */
 #define ZPixmap   2
 
-#define Bool     int
-#define Status   int
+typedef int Bool;
+typedef int Status;
 #define True     1
 #define False    0
 
diff --git a/libXpm/src/config.h b/libXpm/src/config.h
new file mode 100644
index 000000000..c22e05936
--- /dev/null
+++ b/libXpm/src/config.h
@@ -0,0 +1,3 @@
+#include <unistd.h>
+
+#define NO_ZPIPE
diff --git a/libXpm/src/create.c b/libXpm/src/create.c
index 7c75a4211..f9823ca6c 100644
--- a/libXpm/src/create.c
+++ b/libXpm/src/create.c
@@ -1,2517 +1,2517 @@
-/*
- * Copyright (C) 1989-95 GROUPE BULL
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of GROUPE BULL shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from GROUPE BULL.
- */
-
-/*****************************************************************************\
-* create.c:                                                                   *
-*                                                                             *
-*  XPM library                                                                *
-*  Create an X image and possibly its related shape mask                      *
-*  from the given XpmImage.                                                   *
-*                                                                             *
-*  Developed by Arnaud Le Hors                                                *
-\*****************************************************************************/
-
-/*
- * The code related to FOR_MSW has been added by
- * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
- */
-
-/*
- * The code related to AMIGA has been added by
- * Lorens Younes (d93-hyo@nada.kth.se) 4/96
- */
-
-/* October 2004, source code review by Thomas Biege <thomas@suse.de> */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "XpmI.h"
-#include <ctype.h>
-
-LFUNC(xpmVisualType, int, (Visual *visual));
-
-LFUNC(AllocColor, int, (Display *display, Colormap colormap,
-			char *colorname, XColor *xcolor, void *closure));
-LFUNC(FreeColors, int, (Display *display, Colormap colormap,
-			Pixel *pixels, int n, void *closure));
-
-#ifndef FOR_MSW
-LFUNC(SetCloseColor, int, (Display *display, Colormap colormap,
-			   Visual *visual, XColor *col,
-			   Pixel *image_pixel, Pixel *mask_pixel,
-			   Pixel *alloc_pixels, unsigned int *nalloc_pixels,
-			   XpmAttributes *attributes, XColor *cols, int ncols,
-			   XpmAllocColorFunc allocColor, void *closure));
-#else
-/* let the window system take care of close colors */
-#endif
-
-LFUNC(SetColor, int, (Display *display, Colormap colormap, Visual *visual,
-		      char *colorname, unsigned int color_index,
-		      Pixel *image_pixel, Pixel *mask_pixel,
-		      unsigned int *mask_pixel_index,
-		      Pixel *alloc_pixels, unsigned int *nalloc_pixels,
-		      Pixel *used_pixels, unsigned int *nused_pixels,
-		      XpmAttributes *attributes, XColor *cols, int ncols,
-		      XpmAllocColorFunc allocColor, void *closure));
-
-LFUNC(CreateXImage, int, (Display *display, Visual *visual,
-			  unsigned int depth, int format, unsigned int width,
-                          unsigned int height, XImage **image_return));
-
-LFUNC(CreateColors, int, (Display *display, XpmAttributes *attributes,
-                          XpmColor *colors, unsigned int ncolors,
-                          Pixel *image_pixels, Pixel *mask_pixels,
-                          unsigned int *mask_pixel_index,
-                          Pixel *alloc_pixels, unsigned int *nalloc_pixels,
-                          Pixel *used_pixels, unsigned int *nused_pixels));
-
-#ifndef FOR_MSW
-LFUNC(ParseAndPutPixels, int, (xpmData *data, unsigned int width,
-			       unsigned int height, unsigned int ncolors,
-			       unsigned int cpp, XpmColor *colorTable,
-			       xpmHashTable *hashtable,
-			       XImage *image, Pixel *image_pixels,
-			       XImage *mask, Pixel *mask_pixels));
-#else  /* FOR_MSW */
-LFUNC(ParseAndPutPixels, int, (Display *dc, xpmData *data, unsigned int width,
-			       unsigned int height, unsigned int ncolors,
-			       unsigned int cpp, XpmColor *colorTable,
-			       xpmHashTable *hashtable,
-			       XImage *image, Pixel *image_pixels,
-			       XImage *mask, Pixel *mask_pixels));
-#endif
-
-#ifndef FOR_MSW
-# ifndef AMIGA
-/* XImage pixel routines */
-LFUNC(PutImagePixels, void, (XImage *image, unsigned int width,
-			     unsigned int height, unsigned int *pixelindex,
-			     Pixel *pixels));
-
-LFUNC(PutImagePixels32, void, (XImage *image, unsigned int width,
-			       unsigned int height, unsigned int *pixelindex,
-			       Pixel *pixels));
-
-LFUNC(PutImagePixels16, void, (XImage *image, unsigned int width,
-			       unsigned int height, unsigned int *pixelindex,
-			       Pixel *pixels));
-
-LFUNC(PutImagePixels8, void, (XImage *image, unsigned int width,
-			      unsigned int height, unsigned int *pixelindex,
-			      Pixel *pixels));
-
-LFUNC(PutImagePixels1, void, (XImage *image, unsigned int width,
-			      unsigned int height, unsigned int *pixelindex,
-			      Pixel *pixels));
-
-LFUNC(PutPixel1, int, (XImage *ximage, int x, int y, unsigned long pixel));
-LFUNC(PutPixel, int, (XImage *ximage, int x, int y, unsigned long pixel));
-#if !defined(WORD64) && !defined(LONG64)
-LFUNC(PutPixel32, int, (XImage *ximage, int x, int y, unsigned long pixel));
-#endif
-LFUNC(PutPixel32MSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
-LFUNC(PutPixel32LSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
-LFUNC(PutPixel16MSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
-LFUNC(PutPixel16LSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
-LFUNC(PutPixel8, int, (XImage *ximage, int x, int y, unsigned long pixel));
-LFUNC(PutPixel1MSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
-LFUNC(PutPixel1LSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
-
-# else /* AMIGA */
-LFUNC(APutImagePixels, void, (XImage *ximage, unsigned int width,
-			      unsigned int height, unsigned int *pixelindex,
-			      Pixel *pixels));
-# endif/* AMIGA */
-#else  /* FOR_MSW */
-/* FOR_MSW pixel routine */
-LFUNC(MSWPutImagePixels, void, (Display *dc, XImage *image,
-				unsigned int width, unsigned int height,
-				unsigned int *pixelindex, Pixel *pixels));
-#endif /* FOR_MSW */
-
-#ifdef NEED_STRCASECMP
-FUNC(xpmstrcasecmp, int, (char *s1, char *s2));
-
-/*
- * in case strcasecmp is not provided by the system here is one
- * which does the trick
- */
-int
-xpmstrcasecmp(
-    register char	*s1,
-    register char	*s2)
-{
-    register int c1, c2;
-
-    while (*s1 && *s2) {
-	c1 = tolower(*s1);
-	c2 = tolower(*s2);
-	if (c1 != c2)
-	    return (c1 - c2);
-	s1++;
-	s2++;
-    }
-    return (int) (*s1 - *s2);
-}
-
-#endif
-
-/*
- * return the default color key related to the given visual
- */
-static int
-xpmVisualType(Visual *visual)
-{
-#ifndef FOR_MSW
-# ifndef AMIGA
-    switch (visual->class) {
-    case StaticGray:
-    case GrayScale:
-	switch (visual->map_entries) {
-	case 2:
-	    return (XPM_MONO);
-	case 4:
-	    return (XPM_GRAY4);
-	default:
-	    return (XPM_GRAY);
-	}
-    default:
-	return (XPM_COLOR);
-    }
-# else
-    /* set the key explicitly in the XpmAttributes to override this */
-    return (XPM_COLOR);
-# endif
-#else
-    /* there should be a similar switch for MSW */
-    return (XPM_COLOR);
-#endif
-}
-
-
-typedef struct {
-    int cols_index;
-    long closeness;
-}      CloseColor;
-
-static int
-closeness_cmp(Const void *a, Const void *b)
-{
-    CloseColor *x = (CloseColor *) a, *y = (CloseColor *) b;
-
-    /* cast to int as qsort requires */
-    return (int) (x->closeness - y->closeness);
-}
-
-
-/* default AllocColor function:
- *   call XParseColor if colorname is given, return negative value if failure
- *   call XAllocColor and return 0 if failure, positive otherwise
- */
-static int
-AllocColor(
-    Display	*display,
-    Colormap	 colormap,
-    char	*colorname,
-    XColor	*xcolor,
-    void	*closure)		/* not used */
-{
-    int status;
-    if (colorname)
-	if (!XParseColor(display, colormap, colorname, xcolor))
-	    return -1;
-    status = XAllocColor(display, colormap, xcolor);
-    return status != 0 ? 1 : 0;
-}
-
-
-#ifndef FOR_MSW
-/*
- * set a close color in case the exact one can't be set
- * return 0 if success, 1 otherwise.
- */
-
-static int
-SetCloseColor(
-    Display		*display,
-    Colormap		 colormap,
-    Visual		*visual,
-    XColor		*col,
-    Pixel		*image_pixel,
-    Pixel		*mask_pixel,
-    Pixel		*alloc_pixels,
-    unsigned int	*nalloc_pixels,
-    XpmAttributes	*attributes,
-    XColor		*cols,
-    int			 ncols,
-    XpmAllocColorFunc	 allocColor,
-    void		*closure)
-{
-
-    /*
-     * Allocation failed, so try close colors. To get here the visual must
-     * be GreyScale, PseudoColor or DirectColor (or perhaps StaticColor?
-     * What about sharing systems like QDSS?). Beware: we have to treat
-     * DirectColor differently.
-     */
-
-
-    long int red_closeness, green_closeness, blue_closeness;
-    int n;
-    Bool alloc_color;
-
-    if (attributes && (attributes->valuemask & XpmCloseness))
-	red_closeness = green_closeness = blue_closeness =
-	    attributes->closeness;
-    else {
-	red_closeness = attributes->red_closeness;
-	green_closeness = attributes->green_closeness;
-	blue_closeness = attributes->blue_closeness;
-    }
-    if (attributes && (attributes->valuemask & XpmAllocCloseColors))
-	alloc_color = attributes->alloc_close_colors;
-    else
-	alloc_color = True;
-
-    /*
-     * We sort the colormap by closeness and try to allocate the color
-     * closest to the target. If the allocation of this close color fails,
-     * which almost never happens, then one of two scenarios is possible.
-     * Either the colormap must have changed (since the last close color
-     * allocation or possibly while we were sorting the colormap), or the
-     * color is allocated as Read/Write by some other client. (Note: X
-     * _should_ allow clients to check if a particular color is Read/Write,
-     * but it doesn't! :-( ). We cannot determine which of these scenarios
-     * occurred, so we try the next closest color, and so on, until no more
-     * colors are within closeness of the target. If we knew that the
-     * colormap had changed, we could skip this sequence.
-     * 
-     * If _none_ of the colors within closeness of the target can be allocated,
-     * then we can finally be pretty sure that the colormap has actually
-     * changed. In this case we try to allocate the original color (again),
-     * then try the closecolor stuff (again)...
-     * 
-     * In theory it would be possible for an infinite loop to occur if another
-     * process kept changing the colormap every time we sorted it, so we set
-     * a maximum on the number of iterations. After this many tries, we use
-     * XGrabServer() to ensure that the colormap remains unchanged.
-     * 
-     * This approach gives particularly bad worst case performance - as many as
-     * <MaximumIterations> colormap reads and sorts may be needed, and as
-     * many as <MaximumIterations> * <ColormapSize> attempted allocations
-     * may fail. On an 8-bit system, this means as many as 3 colormap reads,
-     * 3 sorts and 768 failed allocations per execution of this code!
-     * Luckily, my experiments show that in general use in a typical 8-bit
-     * color environment only about 1 in every 10000 allocations fails to
-     * succeed in the fastest possible time. So virtually every time what
-     * actually happens is a single sort followed by a successful allocate.
-     * The very first allocation also costs a colormap read, but no further
-     * reads are usually necessary.
-     */
-
-#define ITERATIONS 2			/* more than one is almost never
-					 * necessary */
-
-    for (n = 0; n <= ITERATIONS; ++n) {
-	CloseColor *closenesses =
-	    (CloseColor *) XpmCalloc(ncols, sizeof(CloseColor));
-	int i, c;
-
-	for (i = 0; i < ncols; ++i) {	/* build & sort closenesses table */
-#define COLOR_FACTOR       3
-#define BRIGHTNESS_FACTOR  1
-
-	    closenesses[i].cols_index = i;
-	    closenesses[i].closeness =
-		COLOR_FACTOR * (abs((long) col->red - (long) cols[i].red)
-				+ abs((long) col->green - (long) cols[i].green)
-				+ abs((long) col->blue - (long) cols[i].blue))
-		+ BRIGHTNESS_FACTOR * abs(((long) col->red +
-					   (long) col->green +
-					   (long) col->blue)
-					   - ((long) cols[i].red +
-					      (long) cols[i].green +
-					      (long) cols[i].blue));
-	}
-	qsort(closenesses, ncols, sizeof(CloseColor), closeness_cmp);
-
-	i = 0;
-	c = closenesses[i].cols_index;
-	while ((long) cols[c].red >= (long) col->red - red_closeness &&
-	       (long) cols[c].red <= (long) col->red + red_closeness &&
-	       (long) cols[c].green >= (long) col->green - green_closeness &&
-	       (long) cols[c].green <= (long) col->green + green_closeness &&
-	       (long) cols[c].blue >= (long) col->blue - blue_closeness &&
-	       (long) cols[c].blue <= (long) col->blue + blue_closeness) {
-	    if (alloc_color) {
-		if ((*allocColor)(display, colormap, NULL, &cols[c], closure)){
-		    if (n == ITERATIONS)
-			XUngrabServer(display);
-		    XpmFree(closenesses);
-		    *image_pixel = cols[c].pixel;
-		    *mask_pixel = 1;
-		    alloc_pixels[(*nalloc_pixels)++] = cols[c].pixel;
-		    return (0);
-		} else {
-		    ++i;
-		    if (i == ncols)
-			break;
-		    c = closenesses[i].cols_index;
-		}
-	    } else {
-		if (n == ITERATIONS)
-		    XUngrabServer(display);
-		XpmFree(closenesses);
-		*image_pixel = cols[c].pixel;
-		*mask_pixel = 1;
-		return (0);
-	    }
-	}
-
-	/* Couldn't allocate _any_ of the close colors! */
-
-	if (n == ITERATIONS)
-	    XUngrabServer(display);
-	XpmFree(closenesses);
-
-	if (i == 0 || i == ncols)	/* no color close enough or cannot */
-	    return (1);			/* alloc any color (full of r/w's) */
-
-	if ((*allocColor)(display, colormap, NULL, col, closure)) {
-	    *image_pixel = col->pixel;
-	    *mask_pixel = 1;
-	    alloc_pixels[(*nalloc_pixels)++] = col->pixel;
-	    return (0);
-	} else {			/* colormap has probably changed, so
-					 * re-read... */
-	    if (n == ITERATIONS - 1)
-		XGrabServer(display);
-
-#if 0
-	    if (visual->class == DirectColor) {
-		/* TODO */
-	    } else
-#endif
-		XQueryColors(display, colormap, cols, ncols);
-	}
-    }
-    return (1);
-}
-
-#define USE_CLOSECOLOR attributes && \
-(((attributes->valuemask & XpmCloseness) && attributes->closeness != 0) \
- || ((attributes->valuemask & XpmRGBCloseness) && \
-     (attributes->red_closeness != 0 \
-      || attributes->green_closeness != 0 \
-      || attributes->blue_closeness != 0)))
-
-#else
-    /* FOR_MSW part */
-    /* nothing to do here, the window system does it */
-#endif
-
-/*
- * set the color pixel related to the given colorname,
- * return 0 if success, 1 otherwise.
- */
-
-static int
-SetColor(
-    Display		*display,
-    Colormap		 colormap,
-    Visual		*visual,
-    char		*colorname,
-    unsigned int	 color_index,
-    Pixel		*image_pixel,
-    Pixel		*mask_pixel,
-    unsigned int	*mask_pixel_index,
-    Pixel		*alloc_pixels,
-    unsigned int	*nalloc_pixels,
-    Pixel		*used_pixels,
-    unsigned int	*nused_pixels,
-    XpmAttributes	*attributes,
-    XColor		*cols,
-    int			 ncols,
-    XpmAllocColorFunc	 allocColor,
-    void		*closure)
-{
-    XColor xcolor;
-    int status;
-
-    if (xpmstrcasecmp(colorname, TRANSPARENT_COLOR)) {
-	status = (*allocColor)(display, colormap, colorname, &xcolor, closure);
-	if (status < 0)		/* parse color failed */
-	    return (1);
-
-	if (status == 0) {
-#ifndef FOR_MSW
-	    if (USE_CLOSECOLOR)
-		return (SetCloseColor(display, colormap, visual, &xcolor,
-				      image_pixel, mask_pixel,
-				      alloc_pixels, nalloc_pixels,
-				      attributes, cols, ncols,
-				      allocColor, closure));
-	    else
-#endif /* ndef FOR_MSW */
-		return (1);
-	} else
-	    alloc_pixels[(*nalloc_pixels)++] = xcolor.pixel;
-	*image_pixel = xcolor.pixel;
-#ifndef FOR_MSW
-	*mask_pixel = 1;
-#else
-	*mask_pixel = RGB(0,0,0);
-#endif
-	used_pixels[(*nused_pixels)++] = xcolor.pixel;
-    } else {
-	*image_pixel = 0;
-#ifndef FOR_MSW
-	*mask_pixel = 0;
-#else
-  	*mask_pixel = RGB(255,255,255);
-#endif
-	/* store the color table index */
-	*mask_pixel_index = color_index;
-    }
-    return (0);
-}
-
-
-static int
-CreateColors(
-    Display		*display,
-    XpmAttributes	*attributes,
-    XpmColor		*colors,
-    unsigned int	 ncolors,
-    Pixel		*image_pixels,
-    Pixel		*mask_pixels,
-    unsigned int	*mask_pixel_index,
-    Pixel		*alloc_pixels,
-    unsigned int	*nalloc_pixels,
-    Pixel		*used_pixels,
-    unsigned int	*nused_pixels)
-{
-    /* variables stored in the XpmAttributes structure */
-    Visual *visual;
-    Colormap colormap;
-    XpmColorSymbol *colorsymbols = NULL;
-    unsigned int numsymbols;
-    XpmAllocColorFunc allocColor;
-    void *closure;
-
-    char *colorname;
-    unsigned int color, key;
-    Bool pixel_defined;
-    XpmColorSymbol *symbol = NULL;
-    char **defaults;
-    int ErrorStatus = XpmSuccess;
-    char *s;
-    int default_index;
-
-    XColor *cols = NULL;
-    unsigned int ncols = 0;
-
-    /*
-     * retrieve information from the XpmAttributes
-     */
-    if (attributes && attributes->valuemask & XpmColorSymbols) {
-	colorsymbols = attributes->colorsymbols;
-	numsymbols = attributes->numsymbols;
-    } else
-	numsymbols = 0;
-
-    if (attributes && attributes->valuemask & XpmVisual)
-	visual = attributes->visual;
-    else
-	visual = XDefaultVisual(display, XDefaultScreen(display));
-
-    if (attributes && (attributes->valuemask & XpmColormap))
-	colormap = attributes->colormap;
-    else
-	colormap = XDefaultColormap(display, XDefaultScreen(display));
-
-    if (attributes && (attributes->valuemask & XpmColorKey))
-	key = attributes->color_key;
-    else
-	key = xpmVisualType(visual);
-
-    if (attributes && (attributes->valuemask & XpmAllocColor))
-	allocColor = attributes->alloc_color;
-    else
-	allocColor = AllocColor;
-    if (attributes && (attributes->valuemask & XpmColorClosure))
-	closure = attributes->color_closure;
-    else
-	closure = NULL;
-
-#ifndef FOR_MSW
-    if (USE_CLOSECOLOR) {
-	/* originally from SetCloseColor */
-#if 0
-	if (visual->class == DirectColor) {
-
-	    /*
-	     * TODO: Implement close colors for DirectColor visuals. This is
-	     * difficult situation. Chances are that we will never get here,
-	     * because any machine that supports DirectColor will probably
-	     * also support TrueColor (and probably PseudoColor). Also,
-	     * DirectColor colormaps can be very large, so looking for close
-	     * colors may be too slow.
-	     */
-	} else {
-#endif
-	    unsigned int i;
-
-#ifndef AMIGA
-	    ncols = visual->map_entries;
-#else
-	    ncols = colormap->Count;
-#endif
-	    cols = (XColor *) XpmCalloc(ncols, sizeof(XColor));
-	    for (i = 0; i < ncols; ++i)
-		cols[i].pixel = i;
-	    XQueryColors(display, colormap, cols, ncols);
-#if 0
-	}
-#endif
-    }
-#endif /* ndef FOR_MSW */
-
-    switch (key) {
-    case XPM_MONO:
-	default_index = 2;
-	break;
-    case XPM_GRAY4:
-	default_index = 3;
-	break;
-    case XPM_GRAY:
-	default_index = 4;
-	break;
-    case XPM_COLOR:
-    default:
-	default_index = 5;
-	break;
-    }
-
-    for (color = 0; color < ncolors; color++, colors++,
-					 image_pixels++, mask_pixels++) {
-	colorname = NULL;
-	pixel_defined = False;
-	defaults = (char **) colors;
-
-	/*
-	 * look for a defined symbol
-	 */
-	if (numsymbols) {
-
-	    unsigned int n;
-
-	    s = defaults[1];
-	    for (n = 0, symbol = colorsymbols; n < numsymbols; n++, symbol++) {
-		if (symbol->name && s && !strcmp(symbol->name, s))
-		    /* override name */
-		    break;
-		if (!symbol->name && symbol->value) {	/* override value */
-		    int def_index = default_index;
-
-		    while (defaults[def_index] == NULL)	/* find defined
-							 * colorname */
-			--def_index;
-		    if (def_index < 2) {/* nothing towards mono, so try
-					 * towards color */
-			def_index = default_index + 1;
-			while (def_index <= 5 && defaults[def_index] == NULL)
-			    ++def_index;
-		    }
-		    if (def_index >= 2 && defaults[def_index] != NULL &&
-			!xpmstrcasecmp(symbol->value, defaults[def_index]))
-			break;
-		}
-	    }
-	    if (n != numsymbols) {
-		if (symbol->name && symbol->value)
-		    colorname = symbol->value;
-		else
-		    pixel_defined = True;
-	    }
-	}
-	if (!pixel_defined) {		/* pixel not given as symbol value */
-
-	    unsigned int k;
-
-	    if (colorname) {		/* colorname given as symbol value */
-		if (!SetColor(display, colormap, visual, colorname, color,
-			      image_pixels, mask_pixels, mask_pixel_index,
-			      alloc_pixels, nalloc_pixels, used_pixels,
-			      nused_pixels, attributes, cols, ncols,
-			      allocColor, closure))
-		    pixel_defined = True;
-		else
-		    ErrorStatus = XpmColorError;
-	    }
-	    k = key;
-	    while (!pixel_defined && k > 1) {
-		if (defaults[k]) {
-		    if (!SetColor(display, colormap, visual, defaults[k],
-				  color, image_pixels, mask_pixels,
-				  mask_pixel_index, alloc_pixels,
-				  nalloc_pixels, used_pixels, nused_pixels,
-				  attributes, cols, ncols,
-				  allocColor, closure)) {
-			pixel_defined = True;
-			break;
-		    } else
-			ErrorStatus = XpmColorError;
-		}
-		k--;
-	    }
-	    k = key + 1;
-	    while (!pixel_defined && k < NKEYS + 1) {
-		if (defaults[k]) {
-		    if (!SetColor(display, colormap, visual, defaults[k],
-				  color, image_pixels, mask_pixels,
-				  mask_pixel_index, alloc_pixels,
-				  nalloc_pixels, used_pixels, nused_pixels,
-				  attributes, cols, ncols,
-				  allocColor, closure)) {
-			pixel_defined = True;
-			break;
-		    } else
-			ErrorStatus = XpmColorError;
-		}
-		k++;
-	    }
-	    if (!pixel_defined) {
-		if (cols)
-		    XpmFree(cols);
-		return (XpmColorFailed);
-	    }
-	} else {
-	    /* simply use the given pixel */
-	    *image_pixels = symbol->pixel;
-	    /* the following makes the mask to be built even if none
-	       is given a particular pixel */
-	    if (symbol->value
-		&& !xpmstrcasecmp(symbol->value, TRANSPARENT_COLOR)) {
-		*mask_pixels = 0;
-		*mask_pixel_index = color;
-	    } else
-		*mask_pixels = 1;
-	    used_pixels[(*nused_pixels)++] = *image_pixels;
-	}
-    }
-    if (cols)
-	XpmFree(cols);
-    return (ErrorStatus);
-}
-
-
-/* default FreeColors function, simply call XFreeColors */
-static int
-FreeColors(
-    Display	*display,
-    Colormap	 colormap,
-    Pixel	*pixels,
-    int		 n,
-    void	*closure)		/* not used */
-{
-    return XFreeColors(display, colormap, pixels, n, 0);
-}
-
-
-/* function call in case of error */
-
-#undef RETURN
-#define RETURN(status) \
-do \
-{ \
-      ErrorStatus = status; \
-      goto error; \
-} while(0)
-
-int
-XpmCreateImageFromXpmImage(
-    Display		 *display,
-    XpmImage		 *image,
-    XImage		**image_return,
-    XImage		**shapeimage_return,
-    XpmAttributes	 *attributes)
-{
-    /* variables stored in the XpmAttributes structure */
-    Visual *visual;
-    Colormap colormap;
-    unsigned int depth;
-    int bitmap_format;
-    XpmFreeColorsFunc freeColors;
-
-    /* variables to return */
-    XImage *ximage = NULL;
-    XImage *shapeimage = NULL;
-    unsigned int mask_pixel_index = XpmUndefPixel;
-    int ErrorStatus;
-
-    /* calculation variables */
-    Pixel *image_pixels = NULL;
-    Pixel *mask_pixels = NULL;
-    Pixel *alloc_pixels = NULL;
-    Pixel *used_pixels = NULL;
-    unsigned int nalloc_pixels = 0;
-    unsigned int nused_pixels = 0;
-
-    /* initialize return values */
-    if (image_return)
-	*image_return = NULL;
-    if (shapeimage_return)
-	*shapeimage_return = NULL;
-
-    /* retrieve information from the XpmAttributes */
-    if (attributes && (attributes->valuemask & XpmVisual))
-	visual = attributes->visual;
-    else
-	visual = XDefaultVisual(display, XDefaultScreen(display));
-
-    if (attributes && (attributes->valuemask & XpmColormap))
-	colormap = attributes->colormap;
-    else
-	colormap = XDefaultColormap(display, XDefaultScreen(display));
-
-    if (attributes && (attributes->valuemask & XpmDepth))
-	depth = attributes->depth;
-    else
-	depth = XDefaultDepth(display, XDefaultScreen(display));
-
-    if (attributes && (attributes->valuemask & XpmBitmapFormat))
-	bitmap_format = attributes->bitmap_format;
-    else
-	bitmap_format = ZPixmap;
-
-    if (attributes && (attributes->valuemask & XpmFreeColors))
-	freeColors = attributes->free_colors;
-    else
-	freeColors = FreeColors;
-
-    ErrorStatus = XpmSuccess;
-
-    if (image->ncolors >= UINT_MAX / sizeof(Pixel)) 
-	return (XpmNoMemory);
-
-    /* malloc pixels index tables */
-    image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
-    if (!image_pixels)
-	return (XpmNoMemory);
-
-    mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
-    if (!mask_pixels)
-	RETURN(XpmNoMemory);
-
-    /* maximum of allocated pixels will be the number of colors */
-    alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
-    if (!alloc_pixels)
-	RETURN(XpmNoMemory);
-
-    /* maximum of allocated pixels will be the number of colors */
-    used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
-    if (!used_pixels)
-	RETURN(XpmNoMemory);
-
-    /* get pixel colors, store them in index tables */
-    ErrorStatus = CreateColors(display, attributes, image->colorTable,
-			       image->ncolors, image_pixels, mask_pixels,
-			       &mask_pixel_index, alloc_pixels, &nalloc_pixels,
-			       used_pixels, &nused_pixels);
-
-    if (ErrorStatus != XpmSuccess
-	&& (ErrorStatus < 0 || (attributes
-				&& (attributes->valuemask & XpmExactColors)
-				&& attributes->exactColors)))
-	RETURN(ErrorStatus);
-
-    /* create the ximage */
-    if (image_return) {
-	ErrorStatus = CreateXImage(display, visual, depth,
-				   (depth == 1 ? bitmap_format : ZPixmap),
-				   image->width, image->height, &ximage);
-	if (ErrorStatus != XpmSuccess)
-	    RETURN(ErrorStatus);
-
-#ifndef FOR_MSW
-# ifndef AMIGA
-
-	/*
-	 * set the ximage data using optimized functions for ZPixmap
-	 */
-
-	if (ximage->bits_per_pixel == 8)
-	    PutImagePixels8(ximage, image->width, image->height,
-			    image->data, image_pixels);
-	else if (((ximage->bits_per_pixel | ximage->depth) == 1) &&
-		 (ximage->byte_order == ximage->bitmap_bit_order))
-	    PutImagePixels1(ximage, image->width, image->height,
-			    image->data, image_pixels);
-	else if (ximage->bits_per_pixel == 16)
-	    PutImagePixels16(ximage, image->width, image->height,
-			     image->data, image_pixels);
-	else if (ximage->bits_per_pixel == 32)
-	    PutImagePixels32(ximage, image->width, image->height,
-			     image->data, image_pixels);
-	else
-	    PutImagePixels(ximage, image->width, image->height,
-			   image->data, image_pixels);
-# else /* AMIGA */
-	APutImagePixels(ximage, image->width, image->height,
-			image->data, image_pixels);
-# endif
-#else  /* FOR_MSW */
-	MSWPutImagePixels(display, ximage, image->width, image->height,
-			  image->data, image_pixels);
-#endif
-    }
-    /* create the shape mask image */
-    if (mask_pixel_index != XpmUndefPixel && shapeimage_return) {
-	ErrorStatus = CreateXImage(display, visual, 1, bitmap_format,
-				   image->width, image->height, &shapeimage);
-	if (ErrorStatus != XpmSuccess)
-	    RETURN(ErrorStatus);
-
-#ifndef FOR_MSW
-# ifndef AMIGA
-	PutImagePixels1(shapeimage, image->width, image->height,
-			image->data, mask_pixels);
-# else /* AMIGA */
-	APutImagePixels(shapeimage, image->width, image->height,
-			image->data, mask_pixels);
-# endif
-#else  /* FOR_MSW */
-	MSWPutImagePixels(display, shapeimage, image->width, image->height,
-			  image->data, mask_pixels);
-#endif
-
-    }
-    XpmFree(image_pixels);
-    XpmFree(mask_pixels);
-
-    /* if requested return used pixels in the XpmAttributes structure */
-    if (attributes && (attributes->valuemask & XpmReturnPixels ||
-/* 3.2 backward compatibility code */
-	attributes->valuemask & XpmReturnInfos)) {
-/* end 3.2 bc */
-	attributes->pixels = used_pixels;
-	attributes->npixels = nused_pixels;
-	attributes->mask_pixel = mask_pixel_index;
-    } else
-	XpmFree(used_pixels);
-
-    /* if requested return alloc'ed pixels in the XpmAttributes structure */
-    if (attributes && (attributes->valuemask & XpmReturnAllocPixels)) {
-	attributes->alloc_pixels = alloc_pixels;
-	attributes->nalloc_pixels = nalloc_pixels;
-    } else
-	XpmFree(alloc_pixels);
-
-    /* return created images */
-    if (image_return)
-	*image_return = ximage;
-    if (shapeimage_return)
-	*shapeimage_return = shapeimage;
-
-    return (ErrorStatus);
-
-/* exit point in case of error, free only locally allocated variables */
-error:
-    if (ximage)
-	XDestroyImage(ximage);
-    if (shapeimage)
-	XDestroyImage(shapeimage);
-    if (image_pixels)
-	XpmFree(image_pixels);
-    if (mask_pixels)
-	XpmFree(mask_pixels);
-    if (nalloc_pixels)
-	(*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL);
-    if (alloc_pixels)
-	XpmFree(alloc_pixels);
-    if (used_pixels)
-	XpmFree(used_pixels);
-
-    return (ErrorStatus);
-}
-
-
-/*
- * Create an XImage with its data
- */
-static int
-CreateXImage(
-    Display	 *display,
-    Visual	 *visual,
-    unsigned int  depth,
-    int		  format,
-    unsigned int  width,
-    unsigned int  height,
-    XImage	**image_return)
-{
-    int bitmap_pad;
-
-    /* first get bitmap_pad */
-    if (depth > 16)
-	bitmap_pad = 32;
-    else if (depth > 8)
-	bitmap_pad = 16;
-    else
-	bitmap_pad = 8;
-
-    /* then create the XImage with data = NULL and bytes_per_line = 0 */
-    *image_return = XCreateImage(display, visual, depth, format, 0, 0,
-				 width, height, bitmap_pad, 0);
-    if (!*image_return)
-	return (XpmNoMemory);
-
-#if !defined(FOR_MSW) && !defined(AMIGA)
-    if (height != 0 && (*image_return)->bytes_per_line >= INT_MAX / height) {
-	XDestroyImage(*image_return);
-	return XpmNoMemory;
-    }
-    /* now that bytes_per_line must have been set properly alloc data */
-    if((*image_return)->bytes_per_line == 0 ||  height == 0)
-    	return XpmNoMemory;
-    (*image_return)->data =
-	(char *) XpmMalloc((*image_return)->bytes_per_line * height);
-
-    if (!(*image_return)->data) {
-	XDestroyImage(*image_return);
-	*image_return = NULL;
-	return (XpmNoMemory);
-    }
-#else
-    /* under FOR_MSW and AMIGA XCreateImage has done it all */
-#endif
-    return (XpmSuccess);
-}
-
-#ifndef FOR_MSW
-# ifndef AMIGA
-/*
- * The functions below are written from X11R5 MIT's code (XImUtil.c)
- *
- * The idea is to have faster functions than the standard XPutPixel function
- * to build the image data. Indeed we can speed up things by suppressing tests
- * performed for each pixel. We do the same tests but at the image level.
- * We also assume that we use only ZPixmap images with null offsets.
- */
-
-LFUNC(_putbits, void, (register char *src, int dstoffset,
-		       register int numbits, register char *dst));
-
-LFUNC(_XReverse_Bytes, int, (register unsigned char *bpt, register unsigned int nb));
-
-static unsigned char Const _reverse_byte[0x100] = {
-    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
-    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
-    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
-    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
-    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
-    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
-    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
-    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
-    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
-    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
-    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
-    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
-    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
-    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
-    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
-    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
-    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
-    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
-    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
-    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
-    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
-    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
-    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
-    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
-    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
-    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
-    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
-    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
-    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
-    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
-    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
-    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
-};
-
-static int
-_XReverse_Bytes(
-    register unsigned char	*bpt,
-    register unsigned int	 nb)
-{
-    do {
-	*bpt = _reverse_byte[*bpt];
-	bpt++;
-    } while (--nb > 0); /* is nb user-controled? */
-    return 0;
-}
-
-
-void
-xpm_xynormalizeimagebits(
-    register unsigned char	*bp,
-    register XImage		*img)
-{
-    register unsigned char c;
-
-    if (img->byte_order != img->bitmap_bit_order) {
-	switch (img->bitmap_unit) {
-
-	case 16:
-	    c = *bp;
-	    *bp = *(bp + 1);
-	    *(bp + 1) = c;
-	    break;
-
-	case 32:
-	    c = *(bp + 3);
-	    *(bp + 3) = *bp;
-	    *bp = c;
-	    c = *(bp + 2);
-	    *(bp + 2) = *(bp + 1);
-	    *(bp + 1) = c;
-	    break;
-	}
-    }
-    if (img->bitmap_bit_order == MSBFirst)
-	_XReverse_Bytes(bp, img->bitmap_unit >> 3);
-}
-
-void
-xpm_znormalizeimagebits(
-    register unsigned char	*bp,
-    register XImage		*img)
-{
-    register unsigned char c;
-
-    switch (img->bits_per_pixel) {
-
-    case 2:
-	_XReverse_Bytes(bp, 1);
-	break;
-
-    case 4:
-	*bp = ((*bp >> 4) & 0xF) | ((*bp << 4) & ~0xF);
-	break;
-
-    case 16:
-	c = *bp;
-	*bp = *(bp + 1);
-	*(bp + 1) = c;
-	break;
-
-    case 24:
-	c = *(bp + 2);
-	*(bp + 2) = *bp;
-	*bp = c;
-	break;
-
-    case 32:
-	c = *(bp + 3);
-	*(bp + 3) = *bp;
-	*bp = c;
-	c = *(bp + 2);
-	*(bp + 2) = *(bp + 1);
-	*(bp + 1) = c;
-	break;
-    }
-}
-
-static unsigned char Const _lomask[0x09] = {
-0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
-static unsigned char Const _himask[0x09] = {
-0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00};
-
-static void
-_putbits(
-    register char	*src,		/* address of source bit string */
-    int			 dstoffset,	/* bit offset into destination;
-					 * range is 0-31 */
-    register int	 numbits,	/* number of bits to copy to
-					 * destination */
-    register char	*dst)		/* address of destination bit string */
-{
-    register unsigned char chlo, chhi;
-    int hibits;
-
-    dst = dst + (dstoffset >> 3);
-    dstoffset = dstoffset & 7;
-    hibits = 8 - dstoffset;
-    chlo = *dst & _lomask[dstoffset];
-    for (;;) {
-	chhi = (*src << dstoffset) & _himask[dstoffset];
-	if (numbits <= hibits) {
-	    chhi = chhi & _lomask[dstoffset + numbits];
-	    *dst = (*dst & _himask[dstoffset + numbits]) | chlo | chhi;
-	    break;
-	}
-	*dst = chhi | chlo;
-	dst++;
-	numbits = numbits - hibits;
-	chlo = (unsigned char) (*src & _himask[hibits]) >> hibits;
-	src++;
-	if (numbits <= dstoffset) {
-	    chlo = chlo & _lomask[numbits];
-	    *dst = (*dst & _himask[numbits]) | chlo;
-	    break;
-	}
-	numbits = numbits - dstoffset;
-    }
-}
-
-/*
- * Default method to write pixels into a Z image data structure.
- * The algorithm used is:
- *
- *	copy the destination bitmap_unit or Zpixel to temp
- *	normalize temp if needed
- *	copy the pixel bits into the temp
- *	renormalize temp if needed
- *	copy the temp back into the destination image data
- */
-
-static void
-PutImagePixels(
-    XImage		*image,
-    unsigned int	 width,
-    unsigned int	 height,
-    unsigned int	*pixelindex,
-    Pixel		*pixels)
-{
-    register char *src;
-    register char *dst;
-    register unsigned int *iptr;
-    register unsigned int x, y;
-    register char *data;
-    Pixel pixel, px;
-    int nbytes, depth, ibu, ibpp, i;
-
-    data = image->data;
-    iptr = pixelindex;
-    depth = image->depth;
-    if (depth == 1) {
-	ibu = image->bitmap_unit;
-	for (y = 0; y < height; y++) /* how can we trust height */
-	    for (x = 0; x < width; x++, iptr++) { /* how can we trust width */
-		pixel = pixels[*iptr];
-		for (i = 0, px = pixel; i < sizeof(unsigned long);
-		     i++, px >>= 8)
-		    ((unsigned char *) &pixel)[i] = px;
-		src = &data[XYINDEX(x, y, image)];
-		dst = (char *) &px;
-		px = 0;
-		nbytes = ibu >> 3;
-		for (i = nbytes; --i >= 0;)
-		    *dst++ = *src++;
-		XYNORMALIZE(&px, image);
-		_putbits((char *) &pixel, (x % ibu), 1, (char *) &px);
-		XYNORMALIZE(&px, image);
-		src = (char *) &px;
-		dst = &data[XYINDEX(x, y, image)];
-		for (i = nbytes; --i >= 0;)
-		    *dst++ = *src++;
-	    }
-    } else {
-	ibpp = image->bits_per_pixel;
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		pixel = pixels[*iptr];
-		if (depth == 4)
-		    pixel &= 0xf;
-		for (i = 0, px = pixel; i < sizeof(unsigned long); i++,
-		     px >>= 8)
-		    ((unsigned char *) &pixel)[i] = px;
-		src = &data[ZINDEX(x, y, image)];
-		dst = (char *) &px;
-		px = 0;
-		nbytes = (ibpp + 7) >> 3;
-		for (i = nbytes; --i >= 0;)
-		    *dst++ = *src++;
-		ZNORMALIZE(&px, image);
-		_putbits((char *) &pixel, (x * ibpp) & 7, ibpp, (char *) &px);
-		ZNORMALIZE(&px, image);
-		src = (char *) &px;
-		dst = &data[ZINDEX(x, y, image)];
-		for (i = nbytes; --i >= 0;)
-		    *dst++ = *src++;
-	    }
-    }
-}
-
-/*
- * write pixels into a 32-bits Z image data structure
- */
-
-#if !defined(WORD64) && !defined(LONG64)
-/* this item is static but deterministic so let it slide; doesn't
- * hurt re-entrancy of this library. Note if it is actually const then would
- * be OK under rules of ANSI-C but probably not C++ which may not
- * want to allocate space for it.
- */
-static unsigned long byteorderpixel = MSBFirst << 24;
-
-#endif
-
-/*
-   WITHOUT_SPEEDUPS is a flag to be turned on if you wish to use the original
-   3.2e code - by default you get the speeded-up version.
-*/
-
-static void
-PutImagePixels32(
-    XImage		*image,
-    unsigned int	 width,
-    unsigned int	 height,
-    unsigned int	*pixelindex,
-    Pixel		*pixels)
-{
-    unsigned char *data;
-    unsigned int *iptr;
-    unsigned int y;
-    Pixel pixel;
-
-#ifdef WITHOUT_SPEEDUPS
-
-    unsigned int x;
-    unsigned char *addr;
-
-    data = (unsigned char *) image->data;
-    iptr = pixelindex;
-#if !defined(WORD64) && !defined(LONG64)
-    if (*((char *) &byteorderpixel) == image->byte_order) {
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		addr = &data[ZINDEX32(x, y, image)];
-		*((unsigned long *) addr) = pixels[*iptr];
-	    }
-    } else
-#endif
-    if (image->byte_order == MSBFirst)
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		addr = &data[ZINDEX32(x, y, image)];
-		pixel = pixels[*iptr];
-		addr[0] = pixel >> 24;
-		addr[1] = pixel >> 16;
-		addr[2] = pixel >> 8;
-		addr[3] = pixel;
-	    }
-    else
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		addr = &data[ZINDEX32(x, y, image)];
-		pixel = pixels[*iptr];
-		addr[0] = pixel;
-		addr[1] = pixel >> 8;
-		addr[2] = pixel >> 16;
-		addr[3] = pixel >> 24;
-	    }
-
-#else  /* WITHOUT_SPEEDUPS */
-
-    unsigned int bpl = image->bytes_per_line;
-    unsigned char *data_ptr, *max_data;
-
-    data = (unsigned char *) image->data;
-    iptr = pixelindex;
-#if !defined(WORD64) && !defined(LONG64)
-    if (*((char *) &byteorderpixel) == image->byte_order) {
-	for (y = 0; y < height; y++) {
-	    data_ptr = data;
-	    max_data = data_ptr + (width << 2);
-
-	    while (data_ptr < max_data) {
-		*((unsigned long *) data_ptr) = pixels[*(iptr++)];
-		data_ptr += (1 << 2);
-	    }
-	    data += bpl;
-	}
-    } else
-#endif
-    if (image->byte_order == MSBFirst)
-	for (y = 0; y < height; y++) {
-	    data_ptr = data;
-	    max_data = data_ptr + (width << 2);
-
-	    while (data_ptr < max_data) {
-		pixel = pixels[*(iptr++)];
-
-		*data_ptr++ = pixel >> 24;
-		*data_ptr++ = pixel >> 16;
-		*data_ptr++ = pixel >> 8;
-		*data_ptr++ = pixel;
-
-	    }
-	    data += bpl;
-	}
-    else
-	for (y = 0; y < height; y++) {
-	    data_ptr = data;
-	    max_data = data_ptr + (width << 2);
-
-	    while (data_ptr < max_data) {
-		pixel = pixels[*(iptr++)];
-
-		*data_ptr++ = pixel;
-		*data_ptr++ = pixel >> 8;
-		*data_ptr++ = pixel >> 16;
-		*data_ptr++ = pixel >> 24;
-	    }
-	    data += bpl;
-	}
-
-#endif /* WITHOUT_SPEEDUPS */
-}
-
-/*
- * write pixels into a 16-bits Z image data structure
- */
-
-static void
-PutImagePixels16(
-    XImage		*image,
-    unsigned int	 width,
-    unsigned int	 height,
-    unsigned int	*pixelindex,
-    Pixel		*pixels)
-{
-    unsigned char *data;
-    unsigned int *iptr;
-    unsigned int y;
-
-#ifdef WITHOUT_SPEEDUPS
-
-    unsigned int x;
-    unsigned char *addr;
-
-    data = (unsigned char *) image->data;
-    iptr = pixelindex;
-    if (image->byte_order == MSBFirst)
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		addr = &data[ZINDEX16(x, y, image)];
-		addr[0] = pixels[*iptr] >> 8;
-		addr[1] = pixels[*iptr];
-	    }
-    else
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		addr = &data[ZINDEX16(x, y, image)];
-		addr[0] = pixels[*iptr];
-		addr[1] = pixels[*iptr] >> 8;
-	    }
-
-#else  /* WITHOUT_SPEEDUPS */
-
-    Pixel pixel;
-
-    unsigned int bpl = image->bytes_per_line;
-    unsigned char *data_ptr, *max_data;
-
-    data = (unsigned char *) image->data;
-    iptr = pixelindex;
-    if (image->byte_order == MSBFirst)
-	for (y = 0; y < height; y++) {
-	    data_ptr = data;
-	    max_data = data_ptr + (width << 1);
-
-	    while (data_ptr < max_data) {
-		pixel = pixels[*(iptr++)];
-
-		data_ptr[0] = pixel >> 8;
-		data_ptr[1] = pixel;
-
-		data_ptr += (1 << 1);
-	    }
-	    data += bpl;
-	}
-    else
-	for (y = 0; y < height; y++) {
-	    data_ptr = data;
-	    max_data = data_ptr + (width << 1);
-
-	    while (data_ptr < max_data) {
-		pixel = pixels[*(iptr++)];
-
-		data_ptr[0] = pixel;
-		data_ptr[1] = pixel >> 8;
-
-		data_ptr += (1 << 1);
-	    }
-	    data += bpl;
-	}
-
-#endif /* WITHOUT_SPEEDUPS */
-}
-
-/*
- * write pixels into a 8-bits Z image data structure
- */
-
-static void
-PutImagePixels8(
-    XImage		*image,
-    unsigned int	 width,
-    unsigned int	 height,
-    unsigned int	*pixelindex,
-    Pixel		*pixels)
-{
-    char *data;
-    unsigned int *iptr;
-    unsigned int y;
-
-#ifdef WITHOUT_SPEEDUPS
-
-    unsigned int x;
-
-    data = image->data;
-    iptr = pixelindex;
-    for (y = 0; y < height; y++)
-	for (x = 0; x < width; x++, iptr++)
-	    data[ZINDEX8(x, y, image)] = pixels[*iptr];
-
-#else  /* WITHOUT_SPEEDUPS */
-
-    unsigned int bpl = image->bytes_per_line;
-    char *data_ptr, *max_data;
-
-    data = image->data;
-    iptr = pixelindex;
-
-    for (y = 0; y < height; y++) {
-	data_ptr = data;
-	max_data = data_ptr + width;
-
-	while (data_ptr < max_data)
-	    *(data_ptr++) = pixels[*(iptr++)];
-
-	data += bpl;
-    }
-
-#endif /* WITHOUT_SPEEDUPS */
-}
-
-/*
- * write pixels into a 1-bit depth image data structure and **offset null**
- */
-
-static void
-PutImagePixels1(
-    XImage		*image,
-    unsigned int	 width,
-    unsigned int	 height,
-    unsigned int	*pixelindex,
-    Pixel		*pixels)
-{
-    if (image->byte_order != image->bitmap_bit_order)
-	PutImagePixels(image, width, height, pixelindex, pixels);
-    else {
-	unsigned int *iptr;
-	unsigned int y;
-	char *data;
-
-#ifdef WITHOUT_SPEEDUPS
-
-	unsigned int x;
-
-	data = image->data;
-	iptr = pixelindex;
-	if (image->bitmap_bit_order == MSBFirst)
-	    for (y = 0; y < height; y++)
-		for (x = 0; x < width; x++, iptr++) {
-		    if (pixels[*iptr] & 1)
-			data[ZINDEX1(x, y, image)] |= 0x80 >> (x & 7);
-		    else
-			data[ZINDEX1(x, y, image)] &= ~(0x80 >> (x & 7));
-		}
-	else
-	    for (y = 0; y < height; y++)
-		for (x = 0; x < width; x++, iptr++) {
-		    if (pixels[*iptr] & 1)
-			data[ZINDEX1(x, y, image)] |= 1 << (x & 7);
-		    else
-			data[ZINDEX1(x, y, image)] &= ~(1 << (x & 7));
-		}
-
-#else  /* WITHOUT_SPEEDUPS */
-
-	char value;
-	char *data_ptr, *max_data;
-	int bpl = image->bytes_per_line;
-	int diff, count;
-
-	data = image->data;
-	iptr = pixelindex;
-
-	diff = width & 7;
-	width >>= 3;
-
-	if (image->bitmap_bit_order == MSBFirst)
-	    for (y = 0; y < height; y++) {
-		data_ptr = data;
-		max_data = data_ptr + width;
-		while (data_ptr < max_data) {
-		    value = 0;
-
-		    value = (value << 1) | (pixels[*(iptr++)] & 1);
-		    value = (value << 1) | (pixels[*(iptr++)] & 1);
-		    value = (value << 1) | (pixels[*(iptr++)] & 1);
-		    value = (value << 1) | (pixels[*(iptr++)] & 1);
-		    value = (value << 1) | (pixels[*(iptr++)] & 1);
-		    value = (value << 1) | (pixels[*(iptr++)] & 1);
-		    value = (value << 1) | (pixels[*(iptr++)] & 1);
-		    value = (value << 1) | (pixels[*(iptr++)] & 1);
-
-		    *(data_ptr++) = value;
-		}
-		if (diff) {
-		    value = 0;
-		    for (count = 0; count < diff; count++) {
-			if (pixels[*(iptr++)] & 1)
-			    value |= (0x80 >> count);
-		    }
-		    *(data_ptr) = value;
-		}
-		data += bpl;
-	    }
-	else
-	    for (y = 0; y < height; y++) {
-		data_ptr = data;
-		max_data = data_ptr + width;
-		while (data_ptr < max_data) {
-		    value = 0;
-		    iptr += 8;
-
-		    value = (value << 1) | (pixels[*(--iptr)] & 1);
-		    value = (value << 1) | (pixels[*(--iptr)] & 1);
-		    value = (value << 1) | (pixels[*(--iptr)] & 1);
-		    value = (value << 1) | (pixels[*(--iptr)] & 1);
-		    value = (value << 1) | (pixels[*(--iptr)] & 1);
-		    value = (value << 1) | (pixels[*(--iptr)] & 1);
-		    value = (value << 1) | (pixels[*(--iptr)] & 1);
-		    value = (value << 1) | (pixels[*(--iptr)] & 1);
-
-		    iptr += 8;
-		    *(data_ptr++) = value;
-		}
-		if (diff) {
-		    value = 0;
-		    for (count = 0; count < diff; count++) {
-			if (pixels[*(iptr++)] & 1)
-			    value |= (1 << count);
-		    }
-		    *(data_ptr) = value;
-		}
-		data += bpl;
-	    }
-
-#endif /* WITHOUT_SPEEDUPS */
-    }
-}
-
-int
-XpmCreatePixmapFromXpmImage(
-    Display		*display,
-    Drawable		 d,
-    XpmImage		*image,
-    Pixmap		*pixmap_return,
-    Pixmap		*shapemask_return,
-    XpmAttributes	*attributes)
-{
-    XImage *ximage, *shapeimage;
-    int ErrorStatus;
-
-    /* initialize return values */
-    if (pixmap_return)
-	*pixmap_return = 0;
-    if (shapemask_return)
-	*shapemask_return = 0;
-
-    /* create the ximages */
-    ErrorStatus = XpmCreateImageFromXpmImage(display, image,
-					     (pixmap_return ? &ximage : NULL),
-					     (shapemask_return ?
-					      &shapeimage : NULL),
-					     attributes);
-    if (ErrorStatus < 0)
-	return (ErrorStatus);
-
-    /* create the pixmaps and destroy images */
-    if (pixmap_return && ximage) {
-	xpmCreatePixmapFromImage(display, d, ximage, pixmap_return);
-	XDestroyImage(ximage);
-    }
-    if (shapemask_return && shapeimage) {
-	xpmCreatePixmapFromImage(display, d, shapeimage, shapemask_return);
-	XDestroyImage(shapeimage);
-    }
-    return (ErrorStatus);
-}
-
-# else /* AMIGA */
-
-static void
-APutImagePixels (
-    XImage        *image,
-    unsigned int   width,
-    unsigned int   height,
-    unsigned int  *pixelindex,
-    Pixel         *pixels)
-{
-    unsigned int   *data = pixelindex;
-    unsigned int    x, y;
-    unsigned char  *array;
-    XImage         *tmp_img;
-    BOOL            success = FALSE;
-    
-    array = XpmMalloc ((((width+15)>>4)<<4)*sizeof (*array));
-    if (array != NULL)
-    {
-	tmp_img = AllocXImage ((((width+15)>>4)<<4), 1,
-			       image->rp->BitMap->Depth);
-	if (tmp_img != NULL)
-	{
-	    for (y = 0; y < height; ++y)
-	    {
-		for (x = 0; x < width; ++x)
-		    array[x] = pixels[*(data++)];
-		WritePixelLine8 (image->rp, 0, y, width, array, tmp_img->rp);
-	    }
-	    FreeXImage (tmp_img);
-	    success = TRUE;
-	}
-	XpmFree (array);
-    }
-    
-    if (!success)
-    {
-	for (y = 0; y < height; ++y)
-	    for (x = 0; x < width; ++x)
-		XPutPixel (image, x, y, pixels[*(data++)]);
-    }
-}
-
-# endif/* AMIGA */
-#else  /* FOR_MSW part follows */
-static void
-MSWPutImagePixels(
-    Display		*dc,
-    XImage		*image,
-    unsigned int	 width,
-    unsigned int	 height,
-    unsigned int	*pixelindex,
-    Pixel		*pixels)
-{
-    unsigned int *data = pixelindex;
-    unsigned int x, y;
-    HBITMAP obm;
-
-    obm = SelectObject(*dc, image->bitmap);
-    for (y = 0; y < height; y++) {
-	for (x = 0; x < width; x++) {
-	    SetPixel(*dc, x, y, pixels[*(data++)]); /* data is [x+y*width] */
-	}
-    }
-    SelectObject(*dc, obm);
-}
-
-#endif /* FOR_MSW */
-
-
-
-#if !defined(FOR_MSW) && !defined(AMIGA)
-
-static int
-PutPixel1(
-    register XImage	*ximage,
-    int			 x,
-    int			 y,
-    unsigned long	 pixel)
-{
-    register char *src;
-    register char *dst;
-    register int i;
-    Pixel px;
-    int nbytes;
-
-    if(x < 0 || y < 0)
-    	return 0;
-
-    for (i=0, px=pixel; i<sizeof(unsigned long); i++, px>>=8)
-	((unsigned char *)&pixel)[i] = px;
-    src = &ximage->data[XYINDEX(x, y, ximage)];
-    dst = (char *)&px;
-    px = 0;
-    nbytes = ximage->bitmap_unit >> 3;
-    for (i = nbytes; --i >= 0; ) *dst++ = *src++;
-    XYNORMALIZE(&px, ximage);
-    i = ((x + ximage->xoffset) % ximage->bitmap_unit);
-    _putbits ((char *)&pixel, i, 1, (char *)&px);
-    XYNORMALIZE(&px, ximage);
-    src = (char *) &px;
-    dst = &ximage->data[XYINDEX(x, y, ximage)];
-    for (i = nbytes; --i >= 0; )
-	*dst++ = *src++;
-
-    return 1;
-}
-
-static int
-PutPixel(
-    register XImage	*ximage,
-    int			 x,
-    int			 y,
-    unsigned long	 pixel)
-{
-    register char *src;
-    register char *dst;
-    register int i;
-    Pixel px;
-    unsigned int nbytes, ibpp;
-
-    if(x < 0 || y < 0)
-    	return 0;
-
-    ibpp = ximage->bits_per_pixel;
-    if (ximage->depth == 4)
-	pixel &= 0xf;
-    for (i = 0, px = pixel; i < sizeof(unsigned long); i++, px >>= 8)
-	((unsigned char *) &pixel)[i] = px;
-    src = &ximage->data[ZINDEX(x, y, ximage)];
-    dst = (char *) &px;
-    px = 0;
-    nbytes = (ibpp + 7) >> 3;
-    for (i = nbytes; --i >= 0;)
-	*dst++ = *src++;
-    ZNORMALIZE(&px, ximage);
-    _putbits((char *) &pixel, (x * ibpp) & 7, ibpp, (char *) &px);
-    ZNORMALIZE(&px, ximage);
-    src = (char *) &px;
-    dst = &ximage->data[ZINDEX(x, y, ximage)];
-    for (i = nbytes; --i >= 0;)
-	*dst++ = *src++;
-
-    return 1;
-}
-
-#if !defined(WORD64) && !defined(LONG64)
-static int
-PutPixel32(
-    register XImage	*ximage,
-    int			 x,
-    int			 y,
-    unsigned long	 pixel)
-{
-    unsigned char *addr;
-
-    if(x < 0 || y < 0)
-    	return 0;
-
-    addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)];
-    *((unsigned long *)addr) = pixel;
-    return 1;
-}
-#endif
-
-static int
-PutPixel32MSB(
-    register XImage	*ximage,
-    int			 x,
-    int			 y,
-    unsigned long	 pixel)
-{
-    unsigned char *addr;
-
-    if(x < 0 || y < 0)
-    	return 0;
-
-    addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)];
-    addr[0] = pixel >> 24;
-    addr[1] = pixel >> 16;
-    addr[2] = pixel >> 8;
-    addr[3] = pixel;
-    return 1;
-}
-
-static int
-PutPixel32LSB(
-    register XImage	*ximage,
-    int			 x,
-    int			 y,
-    unsigned long	 pixel)
-{
-    unsigned char *addr;
-
-    if(x < 0 || y < 0)
-    	return 0;
-
-    addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)];
-    addr[3] = pixel >> 24;
-    addr[2] = pixel >> 16;
-    addr[1] = pixel >> 8;
-    addr[0] = pixel;
-    return 1;
-}
-
-static int
-PutPixel16MSB(
-    register XImage	*ximage,
-    int			 x,
-    int			 y,
-    unsigned long	 pixel)
-{
-    unsigned char *addr;
-    
-    if(x < 0 || y < 0)
-    	return 0;
-
-    addr = &((unsigned char *)ximage->data) [ZINDEX16(x, y, ximage)];
-    addr[0] = pixel >> 8;
-    addr[1] = pixel;
-    return 1;
-}
-
-static int
-PutPixel16LSB(
-    register XImage	*ximage,
-    int			 x,
-    int			 y,
-    unsigned long	 pixel)
-{
-    unsigned char *addr;
-    
-    if(x < 0 || y < 0)
-    	return 0;
-
-    addr = &((unsigned char *)ximage->data) [ZINDEX16(x, y, ximage)];
-    addr[1] = pixel >> 8;
-    addr[0] = pixel;
-    return 1;
-}
-
-static int
-PutPixel8(
-    register XImage	*ximage,
-    int			 x,
-    int			 y,
-    unsigned long	 pixel)
-{
-    if(x < 0 || y < 0)
-    	return 0;
-
-    ximage->data[ZINDEX8(x, y, ximage)] = pixel;
-    return 1;
-}
-
-static int
-PutPixel1MSB(
-    register XImage	*ximage,
-    int			 x,
-    int			 y,
-    unsigned long	 pixel)
-{
-    if(x < 0 || y < 0)
-    	return 0;
-
-    if (pixel & 1)
-	ximage->data[ZINDEX1(x, y, ximage)] |= 0x80 >> (x & 7);
-    else
-	ximage->data[ZINDEX1(x, y, ximage)] &= ~(0x80 >> (x & 7));
-    return 1;
-}
-
-static int
-PutPixel1LSB(
-    register XImage	*ximage,
-    int			 x,
-    int			 y,
-    unsigned long	 pixel)
-{
-    if(x < 0 || y < 0)
-    	return 0;
-
-    if (pixel & 1)
-	ximage->data[ZINDEX1(x, y, ximage)] |= 1 << (x & 7);
-    else
-	ximage->data[ZINDEX1(x, y, ximage)] &= ~(1 << (x & 7));
-    return 1;
-}
-
-#endif /* not FOR_MSW && not AMIGA */
-
-/*
- * This function parses an Xpm file or data and directly create an XImage
- */
-int
-xpmParseDataAndCreate(
-    Display		 *display,
-    xpmData		 *data,
-    XImage		**image_return,
-    XImage		**shapeimage_return,
-    XpmImage		 *image,
-    XpmInfo		 *info,
-    XpmAttributes	 *attributes)
-{
-    /* variables stored in the XpmAttributes structure */
-    Visual *visual;
-    Colormap colormap;
-    unsigned int depth;
-    int bitmap_format;
-    XpmFreeColorsFunc freeColors;
-
-    /* variables to return */
-    XImage *ximage = NULL;
-    XImage *shapeimage = NULL;
-    unsigned int mask_pixel_index = XpmUndefPixel;
-
-    /* calculation variables */
-    Pixel *image_pixels = NULL;
-    Pixel *mask_pixels = NULL;
-    Pixel *alloc_pixels = NULL;
-    Pixel *used_pixels = NULL;
-    unsigned int nalloc_pixels = 0;
-    unsigned int nused_pixels = 0;
-    unsigned int width, height, ncolors, cpp;
-    unsigned int x_hotspot, y_hotspot, hotspot = 0, extensions = 0;
-    XpmColor *colorTable = NULL;
-    char *hints_cmt = NULL;
-    char *colors_cmt = NULL;
-    char *pixels_cmt = NULL;
-
-    unsigned int cmts;
-    int ErrorStatus;
-    xpmHashTable hashtable;
-
-
-    /* initialize return values */
-    if (image_return)
-	*image_return = NULL;
-    if (shapeimage_return)
-	*shapeimage_return = NULL;
-
-
-    /* retrieve information from the XpmAttributes */
-    if (attributes && (attributes->valuemask & XpmVisual))
-	visual = attributes->visual;
-    else
-	visual = XDefaultVisual(display, XDefaultScreen(display));
-
-    if (attributes && (attributes->valuemask & XpmColormap))
-	colormap = attributes->colormap;
-    else
-	colormap = XDefaultColormap(display, XDefaultScreen(display));
-
-    if (attributes && (attributes->valuemask & XpmDepth))
-	depth = attributes->depth;
-    else
-	depth = XDefaultDepth(display, XDefaultScreen(display));
-
-    if (attributes && (attributes->valuemask & XpmBitmapFormat))
-	bitmap_format = attributes->bitmap_format;
-    else
-	bitmap_format = ZPixmap;
-
-    if (attributes && (attributes->valuemask & XpmFreeColors))
-	freeColors = attributes->free_colors;
-    else
-	freeColors = FreeColors;
-
-    cmts = info && (info->valuemask & XpmReturnComments);
-
-    /*
-     * parse the header
-     */
-    ErrorStatus = xpmParseHeader(data);
-    if (ErrorStatus != XpmSuccess)
-	return (ErrorStatus);
-
-    /*
-     * read values
-     */
-    ErrorStatus = xpmParseValues(data, &width, &height, &ncolors, &cpp,
-				 &x_hotspot, &y_hotspot, &hotspot,
-				 &extensions);
-    if (ErrorStatus != XpmSuccess)
-	return (ErrorStatus);
-
-    /*
-     * store the hints comment line
-     */
-    if (cmts)
-	xpmGetCmt(data, &hints_cmt);
-
-    /*
-     * init the hashtable
-     */
-    if (USE_HASHTABLE) {
-	ErrorStatus = xpmHashTableInit(&hashtable);
-	if (ErrorStatus != XpmSuccess)
-	    RETURN(ErrorStatus);
-    }
-
-    /*
-     * read colors
-     */
-    ErrorStatus = xpmParseColors(data, ncolors, cpp, &colorTable, &hashtable);
-    if (ErrorStatus != XpmSuccess)
-	RETURN(ErrorStatus);
-
-    /*
-     * store the colors comment line
-     */
-    if (cmts)
-	xpmGetCmt(data, &colors_cmt);
-
-    /* malloc pixels index tables */
-    if (ncolors >= UINT_MAX / sizeof(Pixel)) 
-	RETURN(XpmNoMemory);
-
-    image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
-    if (!image_pixels)
-	RETURN(XpmNoMemory);
-
-    mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
-    if (!mask_pixels)
-	RETURN(XpmNoMemory);
-
-    /* maximum of allocated pixels will be the number of colors */
-    alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
-    if (!alloc_pixels)
-	RETURN(XpmNoMemory);
-
-    /* maximum of allocated pixels will be the number of colors */
-    used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
-    if (!used_pixels)
-	RETURN(XpmNoMemory);
-
-    /* get pixel colors, store them in index tables */
-    ErrorStatus = CreateColors(display, attributes, colorTable, ncolors,
-			       image_pixels, mask_pixels, &mask_pixel_index,
-			       alloc_pixels, &nalloc_pixels, used_pixels,
-			       &nused_pixels);
-
-    if (ErrorStatus != XpmSuccess
-	&& (ErrorStatus < 0 || (attributes
-				&& (attributes->valuemask & XpmExactColors)
-				&& attributes->exactColors)))
-	RETURN(ErrorStatus);
-
-    /* now create the ximage */
-    if (image_return) {
-	ErrorStatus = CreateXImage(display, visual, depth,
-				   (depth == 1 ? bitmap_format : ZPixmap),
-				   width, height, &ximage);
-	if (ErrorStatus != XpmSuccess)
-	    RETURN(ErrorStatus);
-
-#if !defined(FOR_MSW) && !defined(AMIGA)
-
-	/*
-	 * set the XImage pointer function, to be used with XPutPixel,
-	 * to an internal optimized function
-	 */
-
-	if (ximage->bits_per_pixel == 8)
-	    ximage->f.put_pixel = PutPixel8;
-	else if (((ximage->bits_per_pixel | ximage->depth) == 1) &&
-		 (ximage->byte_order == ximage->bitmap_bit_order))
-	    if (ximage->bitmap_bit_order == MSBFirst)
-		ximage->f.put_pixel = PutPixel1MSB;
-	    else
-		ximage->f.put_pixel = PutPixel1LSB;
-	else if (ximage->bits_per_pixel == 16)
-	    if (ximage->bitmap_bit_order == MSBFirst)
-		ximage->f.put_pixel = PutPixel16MSB;
-	    else
-		ximage->f.put_pixel = PutPixel16LSB;
-	else if (ximage->bits_per_pixel == 32)
-#if !defined(WORD64) && !defined(LONG64)
-	    if (*((char *)&byteorderpixel) == ximage->byte_order)
-		ximage->f.put_pixel = PutPixel32;
-	    else
-#endif
-		if (ximage->bitmap_bit_order == MSBFirst)
-		    ximage->f.put_pixel = PutPixel32MSB;
-		else
-		    ximage->f.put_pixel = PutPixel32LSB;
-	else if ((ximage->bits_per_pixel | ximage->depth) == 1)
-	    ximage->f.put_pixel = PutPixel1;
-	else
-	    ximage->f.put_pixel = PutPixel;
-#endif /* not FOR_MSW && not AMIGA */
-    }
-
-    /* create the shape mask image */
-    if (mask_pixel_index != XpmUndefPixel && shapeimage_return) {
-	ErrorStatus = CreateXImage(display, visual, 1, bitmap_format,
-				   width, height, &shapeimage);
-	if (ErrorStatus != XpmSuccess)
-	    RETURN(ErrorStatus);
-
-#if !defined(FOR_MSW) && !defined(AMIGA)
-	if (shapeimage->bitmap_bit_order == MSBFirst)
-	    shapeimage->f.put_pixel = PutPixel1MSB;
-	else
-	    shapeimage->f.put_pixel = PutPixel1LSB;
-#endif
-    }
-
-    /*
-     * read pixels and put them in the XImage
-     */
-    ErrorStatus = ParseAndPutPixels(
-#ifdef FOR_MSW
-				    display,
-#endif
-				    data, width, height, ncolors, cpp,
-				    colorTable, &hashtable,
-				    ximage, image_pixels,
-				    shapeimage, mask_pixels);
-    XpmFree(image_pixels);
-    image_pixels = NULL;
-    XpmFree(mask_pixels);
-    mask_pixels = NULL;
-
-    /*
-     * free the hastable
-     */
-    if (ErrorStatus != XpmSuccess)
-	RETURN(ErrorStatus);
-    else if (USE_HASHTABLE)
-	xpmHashTableFree(&hashtable);
-
-    /*
-     * store the pixels comment line
-     */
-    if (cmts)
-	xpmGetCmt(data, &pixels_cmt);
-
-    /*
-     * parse extensions
-     */
-    if (info && (info->valuemask & XpmReturnExtensions)) {
-	if (extensions) {
-	    ErrorStatus = xpmParseExtensions(data, &info->extensions,
-					     &info->nextensions);
-	    if (ErrorStatus != XpmSuccess)
-		RETURN(ErrorStatus);
-	} else {
-	    info->extensions = NULL;
-	    info->nextensions = 0;
-	}
-    }
-    /*
-     * store found informations in the XpmImage structure
-     */
-    image->width = width;
-    image->height = height;
-    image->cpp = cpp;
-    image->ncolors = ncolors;
-    image->colorTable = colorTable;
-    image->data = NULL;
-
-    if (info) {
-	if (cmts) {
-	    info->hints_cmt = hints_cmt;
-	    info->colors_cmt = colors_cmt;
-	    info->pixels_cmt = pixels_cmt;
-	}
-	if (hotspot) {
-	    info->x_hotspot = x_hotspot;
-	    info->y_hotspot = y_hotspot;
-	    info->valuemask |= XpmHotspot;
-	}
-    }
-    /* if requested return used pixels in the XpmAttributes structure */
-    if (attributes && (attributes->valuemask & XpmReturnPixels ||
-/* 3.2 backward compatibility code */
-	attributes->valuemask & XpmReturnInfos)) {
-/* end 3.2 bc */
-	attributes->pixels = used_pixels;
-	attributes->npixels = nused_pixels;
-	attributes->mask_pixel = mask_pixel_index;
-    } else
-	XpmFree(used_pixels);
-
-    /* if requested return alloc'ed pixels in the XpmAttributes structure */
-    if (attributes && (attributes->valuemask & XpmReturnAllocPixels)) {
-	attributes->alloc_pixels = alloc_pixels;
-	attributes->nalloc_pixels = nalloc_pixels;
-    } else
-	XpmFree(alloc_pixels);
-
-    /* return created images */
-    if (image_return)
-	*image_return = ximage;
-    if (shapeimage_return)
-	*shapeimage_return = shapeimage;
-
-    return (XpmSuccess);
-
-/* exit point in case of error, free only locally allocated variables */
-error:
-    if (USE_HASHTABLE)
-	xpmHashTableFree(&hashtable);
-    if (colorTable)
-	xpmFreeColorTable(colorTable, ncolors);
-    if (hints_cmt)
-	XpmFree(hints_cmt);
-    if (colors_cmt)
-	XpmFree(colors_cmt);
-    if (pixels_cmt)
-	XpmFree(pixels_cmt);
-    if (ximage)
-	XDestroyImage(ximage);
-    if (shapeimage)
-	XDestroyImage(shapeimage);
-    if (image_pixels)
-	XpmFree(image_pixels);
-    if (mask_pixels)
-	XpmFree(mask_pixels);
-    if (nalloc_pixels)
-	(*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL);
-    if (alloc_pixels)
-	XpmFree(alloc_pixels);
-    if (used_pixels)
-	XpmFree(used_pixels);
-
-    return (ErrorStatus);
-}
-
-static int
-ParseAndPutPixels(
-#ifdef FOR_MSW
-    Display		*dc,
-#endif
-    xpmData		*data,
-    unsigned int	 width,
-    unsigned int	 height,
-    unsigned int	 ncolors,
-    unsigned int	 cpp,
-    XpmColor		*colorTable,
-    xpmHashTable	*hashtable,
-    XImage		*image,
-    Pixel		*image_pixels,
-    XImage		*shapeimage,
-    Pixel		*shape_pixels)
-{
-    unsigned int a, x, y;
-
-    switch (cpp) {
-
-    case (1):				/* Optimize for single character
-					 * colors */
-	{
-	    unsigned short colidx[256];
-#ifdef FOR_MSW
-	    HDC shapedc;
-	    HBITMAP obm, sobm;
-
-	    if ( shapeimage ) {
-		shapedc = CreateCompatibleDC(*dc);
-		sobm = SelectObject(shapedc, shapeimage->bitmap);
-	    } else {
-	        shapedc = NULL;
-	    }
-	    obm = SelectObject(*dc, image->bitmap);
-#endif
-	    if (ncolors > 256)
-		return (XpmFileInvalid);
-
-	    bzero((char *)colidx, 256 * sizeof(short));
-	    for (a = 0; a < ncolors; a++)
-		colidx[(unsigned char)colorTable[a].string[0]] = a + 1;
-
-	    for (y = 0; y < height; y++) {
-		xpmNextString(data);
-		for (x = 0; x < width; x++) {
-		    int c = xpmGetC(data);
-
-		    if (c > 0 && c < 256 && colidx[c] != 0) {
-#ifndef FOR_MSW
-			XPutPixel(image, x, y, image_pixels[colidx[c] - 1]);
-			if (shapeimage)
-			    XPutPixel(shapeimage, x, y,
-				      shape_pixels[colidx[c] - 1]);
-#else
-			SetPixel(*dc, x, y, image_pixels[colidx[c] - 1]);
-			if (shapedc) {
-			    SetPixel(shapedc, x, y, shape_pixels[colidx[c] - 1]);
-			}
-#endif
-		    } else
-			return (XpmFileInvalid);
-		}
-	    }
-#ifdef FOR_MSW
-	    if ( shapedc ) {
-	        SelectObject(shapedc, sobm);
-		DeleteDC(shapedc);
-	    }
-	    SelectObject(*dc, obm);
-#endif
-	}
-	break;
-
-    case (2):				/* Optimize for double character
-					 * colors */
-	{
-
-/* free all allocated pointers at all exits */
-#define FREE_CIDX {int f; for (f = 0; f < 256; f++) \
-if (cidx[f]) XpmFree(cidx[f]);}
-
-	    /* array of pointers malloced by need */
-	    unsigned short *cidx[256];
-	    unsigned int char1;
-
-	    bzero((char *)cidx, 256 * sizeof(unsigned short *)); /* init */
-	    for (a = 0; a < ncolors; a++) {
-		char1 = (unsigned char) colorTable[a].string[0];
-		if (cidx[char1] == NULL) { /* get new memory */
-		    cidx[char1] = (unsigned short *)
-			XpmCalloc(256, sizeof(unsigned short));
-		    if (cidx[char1] == NULL) { /* new block failed */
-			FREE_CIDX;
-			return (XpmNoMemory);
-		    }
-		}
-		cidx[char1][(unsigned char)colorTable[a].string[1]] = a + 1;
-	    }
-
-	    for (y = 0; y < height; y++) {
-		xpmNextString(data);
-		for (x = 0; x < width; x++) {
-		    int cc1 = xpmGetC(data);
-		    if (cc1 > 0 && cc1 < 256) {
-			int cc2 = xpmGetC(data);
-			if (cc2 > 0 && cc2 < 256 &&
-			    cidx[cc1] && cidx[cc1][cc2] != 0) {
-#ifndef FOR_MSW
-			    XPutPixel(image, x, y,
-				      image_pixels[cidx[cc1][cc2] - 1]);
-			    if (shapeimage)
-				XPutPixel(shapeimage, x, y,
-					  shape_pixels[cidx[cc1][cc2] - 1]);
-#else
-			SelectObject(*dc, image->bitmap);
-			SetPixel(*dc, x, y, image_pixels[cidx[cc1][cc2] - 1]);
-			if (shapeimage) {
-			    SelectObject(*dc, shapeimage->bitmap);
-			    SetPixel(*dc, x, y,
-				     shape_pixels[cidx[cc1][cc2] - 1]);
-			}
-#endif
-			} else {
-			    FREE_CIDX;
-			    return (XpmFileInvalid);
-			}
-		    } else {
-			FREE_CIDX;
-			return (XpmFileInvalid);
-		    }
-		}
-	    }
-	    FREE_CIDX;
-	}
-	break;
-
-    default:				/* Non-optimized case of long color
-					 * names */
-	{
-	    char *s;
-	    char buf[BUFSIZ];
-
-	    if (cpp >= sizeof(buf))
-		return (XpmFileInvalid);
-
-	    buf[cpp] = '\0';
-	    if (USE_HASHTABLE) {
-		xpmHashAtom *slot;
-
-		for (y = 0; y < height; y++) {
-		    xpmNextString(data);
-		    for (x = 0; x < width; x++) {
-			for (a = 0, s = buf; a < cpp; a++, s++)
-			    *s = xpmGetC(data);
-			slot = xpmHashSlot(hashtable, buf);
-			if (!*slot)	/* no color matches */
-			    return (XpmFileInvalid);
-#ifndef FOR_MSW
-			XPutPixel(image, x, y,
-				  image_pixels[HashColorIndex(slot)]);
-			if (shapeimage)
-			    XPutPixel(shapeimage, x, y,
-				      shape_pixels[HashColorIndex(slot)]);
-#else
-			SelectObject(*dc, image->bitmap);
-			SetPixel(*dc, x, y,
-				 image_pixels[HashColorIndex(slot)]);
-			if (shapeimage) {
-			    SelectObject(*dc, shapeimage->bitmap);
-			    SetPixel(*dc, x, y,
-				     shape_pixels[HashColorIndex(slot)]);
-			}
-#endif
-		    }
-		}
-	    } else {
-		for (y = 0; y < height; y++) {
-		    xpmNextString(data);
-		    for (x = 0; x < width; x++) {
-			for (a = 0, s = buf; a < cpp; a++, s++)
-			    *s = xpmGetC(data);
-			for (a = 0; a < ncolors; a++)
-			    if (!strcmp(colorTable[a].string, buf))
-				break;
-			if (a == ncolors)	/* no color matches */
-			    return (XpmFileInvalid);
-#ifndef FOR_MSW
-			XPutPixel(image, x, y, image_pixels[a]);
-			if (shapeimage)
-			    XPutPixel(shapeimage, x, y, shape_pixels[a]);
-#else
-			SelectObject(*dc, image->bitmap);
-			SetPixel(*dc, x, y, image_pixels[a]);
-			if (shapeimage) {
-			    SelectObject(*dc, shapeimage->bitmap);
-			    SetPixel(*dc, x, y, shape_pixels[a]);
-			}
-#endif
-		    }
-		}
-	    }
-	}
-	break;
-    }
-    return (XpmSuccess);
-}
+/*

+ * Copyright (C) 1989-95 GROUPE BULL

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to

+ * deal in the Software without restriction, including without limitation the

+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

+ * sell copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of GROUPE BULL shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from GROUPE BULL.

+ */

+

+/*****************************************************************************\

+* create.c:                                                                   *

+*                                                                             *

+*  XPM library                                                                *

+*  Create an X image and possibly its related shape mask                      *

+*  from the given XpmImage.                                                   *

+*                                                                             *

+*  Developed by Arnaud Le Hors                                                *

+\*****************************************************************************/

+

+/*

+ * The code related to FOR_MSW has been added by

+ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94

+ */

+

+/*

+ * The code related to AMIGA has been added by

+ * Lorens Younes (d93-hyo@nada.kth.se) 4/96

+ */

+

+/* October 2004, source code review by Thomas Biege <thomas@suse.de> */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include "XpmI.h"

+#include <ctype.h>

+

+LFUNC(xpmVisualType, int, (Visual *visual));

+

+LFUNC(AllocColor, int, (Display *display, Colormap colormap,

+			char *colorname, XColor *xcolor, void *closure));

+LFUNC(FreeColors, int, (Display *display, Colormap colormap,

+			Pixel *pixels, int n, void *closure));

+

+#ifndef FOR_MSW

+LFUNC(SetCloseColor, int, (Display *display, Colormap colormap,

+			   Visual *visual, XColor *col,

+			   Pixel *image_pixel, Pixel *mask_pixel,

+			   Pixel *alloc_pixels, unsigned int *nalloc_pixels,

+			   XpmAttributes *attributes, XColor *cols, int ncols,

+			   XpmAllocColorFunc allocColor, void *closure));

+#else

+/* let the window system take care of close colors */

+#endif

+

+LFUNC(SetColor, int, (Display *display, Colormap colormap, Visual *visual,

+		      char *colorname, unsigned int color_index,

+		      Pixel *image_pixel, Pixel *mask_pixel,

+		      unsigned int *mask_pixel_index,

+		      Pixel *alloc_pixels, unsigned int *nalloc_pixels,

+		      Pixel *used_pixels, unsigned int *nused_pixels,

+		      XpmAttributes *attributes, XColor *cols, int ncols,

+		      XpmAllocColorFunc allocColor, void *closure));

+

+LFUNC(CreateXImage, int, (Display *display, Visual *visual,

+			  unsigned int depth, int format, unsigned int width,

+                          unsigned int height, XImage **image_return));

+

+LFUNC(CreateColors, int, (Display *display, XpmAttributes *attributes,

+                          XpmColor *colors, unsigned int ncolors,

+                          Pixel *image_pixels, Pixel *mask_pixels,

+                          unsigned int *mask_pixel_index,

+                          Pixel *alloc_pixels, unsigned int *nalloc_pixels,

+                          Pixel *used_pixels, unsigned int *nused_pixels));

+

+#ifndef FOR_MSW

+LFUNC(ParseAndPutPixels, int, (xpmData *data, unsigned int width,

+			       unsigned int height, unsigned int ncolors,

+			       unsigned int cpp, XpmColor *colorTable,

+			       xpmHashTable *hashtable,

+			       XImage *image, Pixel *image_pixels,

+			       XImage *mask, Pixel *mask_pixels));

+#else  /* FOR_MSW */

+LFUNC(ParseAndPutPixels, int, (Display *dc, xpmData *data, unsigned int width,

+			       unsigned int height, unsigned int ncolors,

+			       unsigned int cpp, XpmColor *colorTable,

+			       xpmHashTable *hashtable,

+			       XImage *image, Pixel *image_pixels,

+			       XImage *mask, Pixel *mask_pixels));

+#endif

+

+#ifndef FOR_MSW

+# ifndef AMIGA

+/* XImage pixel routines */

+LFUNC(PutImagePixels, void, (XImage *image, unsigned int width,

+			     unsigned int height, unsigned int *pixelindex,

+			     Pixel *pixels));

+

+LFUNC(PutImagePixels32, void, (XImage *image, unsigned int width,

+			       unsigned int height, unsigned int *pixelindex,

+			       Pixel *pixels));

+

+LFUNC(PutImagePixels16, void, (XImage *image, unsigned int width,

+			       unsigned int height, unsigned int *pixelindex,

+			       Pixel *pixels));

+

+LFUNC(PutImagePixels8, void, (XImage *image, unsigned int width,

+			      unsigned int height, unsigned int *pixelindex,

+			      Pixel *pixels));

+

+LFUNC(PutImagePixels1, void, (XImage *image, unsigned int width,

+			      unsigned int height, unsigned int *pixelindex,

+			      Pixel *pixels));

+

+LFUNC(PutPixel1, int, (XImage *ximage, int x, int y, unsigned long pixel));

+LFUNC(PutPixel, int, (XImage *ximage, int x, int y, unsigned long pixel));

+#if !defined(WORD64) && !defined(LONG64)

+LFUNC(PutPixel32, int, (XImage *ximage, int x, int y, unsigned long pixel));

+#endif

+LFUNC(PutPixel32MSB, int, (XImage *ximage, int x, int y, unsigned long pixel));

+LFUNC(PutPixel32LSB, int, (XImage *ximage, int x, int y, unsigned long pixel));

+LFUNC(PutPixel16MSB, int, (XImage *ximage, int x, int y, unsigned long pixel));

+LFUNC(PutPixel16LSB, int, (XImage *ximage, int x, int y, unsigned long pixel));

+LFUNC(PutPixel8, int, (XImage *ximage, int x, int y, unsigned long pixel));

+LFUNC(PutPixel1MSB, int, (XImage *ximage, int x, int y, unsigned long pixel));

+LFUNC(PutPixel1LSB, int, (XImage *ximage, int x, int y, unsigned long pixel));

+

+# else /* AMIGA */

+LFUNC(APutImagePixels, void, (XImage *ximage, unsigned int width,

+			      unsigned int height, unsigned int *pixelindex,

+			      Pixel *pixels));

+# endif/* AMIGA */

+#else  /* FOR_MSW */

+/* FOR_MSW pixel routine */

+LFUNC(MSWPutImagePixels, void, (Display *dc, XImage *image,

+				unsigned int width, unsigned int height,

+				unsigned int *pixelindex, Pixel *pixels));

+#endif /* FOR_MSW */

+

+#ifdef NEED_STRCASECMP

+FUNC(xpmstrcasecmp, int, (char *s1, char *s2));

+

+/*

+ * in case strcasecmp is not provided by the system here is one

+ * which does the trick

+ */

+int

+xpmstrcasecmp(

+    register char	*s1,

+    register char	*s2)

+{

+    register int c1, c2;

+

+    while (*s1 && *s2) {

+	c1 = tolower(*s1);

+	c2 = tolower(*s2);

+	if (c1 != c2)

+	    return (c1 - c2);

+	s1++;

+	s2++;

+    }

+    return (int) (*s1 - *s2);

+}

+

+#endif

+

+/*

+ * return the default color key related to the given visual

+ */

+static int

+xpmVisualType(Visual *visual)

+{

+#ifndef FOR_MSW

+# ifndef AMIGA

+    switch (visual->class) {

+    case StaticGray:

+    case GrayScale:

+	switch (visual->map_entries) {

+	case 2:

+	    return (XPM_MONO);

+	case 4:

+	    return (XPM_GRAY4);

+	default:

+	    return (XPM_GRAY);

+	}

+    default:

+	return (XPM_COLOR);

+    }

+# else

+    /* set the key explicitly in the XpmAttributes to override this */

+    return (XPM_COLOR);

+# endif

+#else

+    /* there should be a similar switch for MSW */

+    return (XPM_COLOR);

+#endif

+}

+

+

+typedef struct {

+    int cols_index;

+    long closeness;

+}      CloseColor;

+

+static int

+closeness_cmp(Const void *a, Const void *b)

+{

+    CloseColor *x = (CloseColor *) a, *y = (CloseColor *) b;

+

+    /* cast to int as qsort requires */

+    return (int) (x->closeness - y->closeness);

+}

+

+

+/* default AllocColor function:

+ *   call XParseColor if colorname is given, return negative value if failure

+ *   call XAllocColor and return 0 if failure, positive otherwise

+ */

+static int

+AllocColor(

+    Display	*display,

+    Colormap	 colormap,

+    char	*colorname,

+    XColor	*xcolor,

+    void	*closure)		/* not used */

+{

+    int status;

+    if (colorname)

+	if (!XParseColor(display, colormap, colorname, xcolor))

+	    return -1;

+    status = XAllocColor(display, colormap, xcolor);

+    return status != 0 ? 1 : 0;

+}

+

+

+#ifndef FOR_MSW

+/*

+ * set a close color in case the exact one can't be set

+ * return 0 if success, 1 otherwise.

+ */

+

+static int

+SetCloseColor(

+    Display		*display,

+    Colormap		 colormap,

+    Visual		*visual,

+    XColor		*col,

+    Pixel		*image_pixel,

+    Pixel		*mask_pixel,

+    Pixel		*alloc_pixels,

+    unsigned int	*nalloc_pixels,

+    XpmAttributes	*attributes,

+    XColor		*cols,

+    int			 ncols,

+    XpmAllocColorFunc	 allocColor,

+    void		*closure)

+{

+

+    /*

+     * Allocation failed, so try close colors. To get here the visual must

+     * be GreyScale, PseudoColor or DirectColor (or perhaps StaticColor?

+     * What about sharing systems like QDSS?). Beware: we have to treat

+     * DirectColor differently.

+     */

+

+

+    long int red_closeness, green_closeness, blue_closeness;

+    int n;

+    Bool alloc_color;

+

+    if (attributes && (attributes->valuemask & XpmCloseness))

+	red_closeness = green_closeness = blue_closeness =

+	    attributes->closeness;

+    else {

+	red_closeness = attributes->red_closeness;

+	green_closeness = attributes->green_closeness;

+	blue_closeness = attributes->blue_closeness;

+    }

+    if (attributes && (attributes->valuemask & XpmAllocCloseColors))

+	alloc_color = attributes->alloc_close_colors;

+    else

+	alloc_color = True;

+

+    /*

+     * We sort the colormap by closeness and try to allocate the color

+     * closest to the target. If the allocation of this close color fails,

+     * which almost never happens, then one of two scenarios is possible.

+     * Either the colormap must have changed (since the last close color

+     * allocation or possibly while we were sorting the colormap), or the

+     * color is allocated as Read/Write by some other client. (Note: X

+     * _should_ allow clients to check if a particular color is Read/Write,

+     * but it doesn't! :-( ). We cannot determine which of these scenarios

+     * occurred, so we try the next closest color, and so on, until no more

+     * colors are within closeness of the target. If we knew that the

+     * colormap had changed, we could skip this sequence.

+     * 

+     * If _none_ of the colors within closeness of the target can be allocated,

+     * then we can finally be pretty sure that the colormap has actually

+     * changed. In this case we try to allocate the original color (again),

+     * then try the closecolor stuff (again)...

+     * 

+     * In theory it would be possible for an infinite loop to occur if another

+     * process kept changing the colormap every time we sorted it, so we set

+     * a maximum on the number of iterations. After this many tries, we use

+     * XGrabServer() to ensure that the colormap remains unchanged.

+     * 

+     * This approach gives particularly bad worst case performance - as many as

+     * <MaximumIterations> colormap reads and sorts may be needed, and as

+     * many as <MaximumIterations> * <ColormapSize> attempted allocations

+     * may fail. On an 8-bit system, this means as many as 3 colormap reads,

+     * 3 sorts and 768 failed allocations per execution of this code!

+     * Luckily, my experiments show that in general use in a typical 8-bit

+     * color environment only about 1 in every 10000 allocations fails to

+     * succeed in the fastest possible time. So virtually every time what

+     * actually happens is a single sort followed by a successful allocate.

+     * The very first allocation also costs a colormap read, but no further

+     * reads are usually necessary.

+     */

+

+#define ITERATIONS 2			/* more than one is almost never

+					 * necessary */

+

+    for (n = 0; n <= ITERATIONS; ++n) {

+	CloseColor *closenesses =

+	    (CloseColor *) XpmCalloc(ncols, sizeof(CloseColor));

+	int i, c;

+

+	for (i = 0; i < ncols; ++i) {	/* build & sort closenesses table */

+#define COLOR_FACTOR       3

+#define BRIGHTNESS_FACTOR  1

+

+	    closenesses[i].cols_index = i;

+	    closenesses[i].closeness =

+		COLOR_FACTOR * (abs((long) col->red - (long) cols[i].red)

+				+ abs((long) col->green - (long) cols[i].green)

+				+ abs((long) col->blue - (long) cols[i].blue))

+		+ BRIGHTNESS_FACTOR * abs(((long) col->red +

+					   (long) col->green +

+					   (long) col->blue)

+					   - ((long) cols[i].red +

+					      (long) cols[i].green +

+					      (long) cols[i].blue));

+	}

+	qsort(closenesses, ncols, sizeof(CloseColor), closeness_cmp);

+

+	i = 0;

+	c = closenesses[i].cols_index;

+	while ((long) cols[c].red >= (long) col->red - red_closeness &&

+	       (long) cols[c].red <= (long) col->red + red_closeness &&

+	       (long) cols[c].green >= (long) col->green - green_closeness &&

+	       (long) cols[c].green <= (long) col->green + green_closeness &&

+	       (long) cols[c].blue >= (long) col->blue - blue_closeness &&

+	       (long) cols[c].blue <= (long) col->blue + blue_closeness) {

+	    if (alloc_color) {

+		if ((*allocColor)(display, colormap, NULL, &cols[c], closure)){

+		    if (n == ITERATIONS)

+			XUngrabServer(display);

+		    XpmFree(closenesses);

+		    *image_pixel = cols[c].pixel;

+		    *mask_pixel = 1;

+		    alloc_pixels[(*nalloc_pixels)++] = cols[c].pixel;

+		    return (0);

+		} else {

+		    ++i;

+		    if (i == ncols)

+			break;

+		    c = closenesses[i].cols_index;

+		}

+	    } else {

+		if (n == ITERATIONS)

+		    XUngrabServer(display);

+		XpmFree(closenesses);

+		*image_pixel = cols[c].pixel;

+		*mask_pixel = 1;

+		return (0);

+	    }

+	}

+

+	/* Couldn't allocate _any_ of the close colors! */

+

+	if (n == ITERATIONS)

+	    XUngrabServer(display);

+	XpmFree(closenesses);

+

+	if (i == 0 || i == ncols)	/* no color close enough or cannot */

+	    return (1);			/* alloc any color (full of r/w's) */

+

+	if ((*allocColor)(display, colormap, NULL, col, closure)) {

+	    *image_pixel = col->pixel;

+	    *mask_pixel = 1;

+	    alloc_pixels[(*nalloc_pixels)++] = col->pixel;

+	    return (0);

+	} else {			/* colormap has probably changed, so

+					 * re-read... */

+	    if (n == ITERATIONS - 1)

+		XGrabServer(display);

+

+#if 0

+	    if (visual->class == DirectColor) {

+		/* TODO */

+	    } else

+#endif

+		XQueryColors(display, colormap, cols, ncols);

+	}

+    }

+    return (1);

+}

+

+#define USE_CLOSECOLOR attributes && \

+(((attributes->valuemask & XpmCloseness) && attributes->closeness != 0) \

+ || ((attributes->valuemask & XpmRGBCloseness) && \

+     (attributes->red_closeness != 0 \

+      || attributes->green_closeness != 0 \

+      || attributes->blue_closeness != 0)))

+

+#else

+    /* FOR_MSW part */

+    /* nothing to do here, the window system does it */

+#endif

+

+/*

+ * set the color pixel related to the given colorname,

+ * return 0 if success, 1 otherwise.

+ */

+

+static int

+SetColor(

+    Display		*display,

+    Colormap		 colormap,

+    Visual		*visual,

+    char		*colorname,

+    unsigned int	 color_index,

+    Pixel		*image_pixel,

+    Pixel		*mask_pixel,

+    unsigned int	*mask_pixel_index,

+    Pixel		*alloc_pixels,

+    unsigned int	*nalloc_pixels,

+    Pixel		*used_pixels,

+    unsigned int	*nused_pixels,

+    XpmAttributes	*attributes,

+    XColor		*cols,

+    int			 ncols,

+    XpmAllocColorFunc	 allocColor,

+    void		*closure)

+{

+    XColor xcolor;

+    int status;

+

+    if (xpmstrcasecmp(colorname, TRANSPARENT_COLOR)) {

+	status = (*allocColor)(display, colormap, colorname, &xcolor, closure);

+	if (status < 0)		/* parse color failed */

+	    return (1);

+

+	if (status == 0) {

+#ifndef FOR_MSW

+	    if (USE_CLOSECOLOR)

+		return (SetCloseColor(display, colormap, visual, &xcolor,

+				      image_pixel, mask_pixel,

+				      alloc_pixels, nalloc_pixels,

+				      attributes, cols, ncols,

+				      allocColor, closure));

+	    else

+#endif /* ndef FOR_MSW */

+		return (1);

+	} else

+	    alloc_pixels[(*nalloc_pixels)++] = xcolor.pixel;

+	*image_pixel = xcolor.pixel;

+#ifndef FOR_MSW

+	*mask_pixel = 1;

+#else

+	*mask_pixel = RGB(0,0,0);

+#endif

+	used_pixels[(*nused_pixels)++] = xcolor.pixel;

+    } else {

+	*image_pixel = 0;

+#ifndef FOR_MSW

+	*mask_pixel = 0;

+#else

+  	*mask_pixel = RGB(255,255,255);

+#endif

+	/* store the color table index */

+	*mask_pixel_index = color_index;

+    }

+    return (0);

+}

+

+

+static int

+CreateColors(

+    Display		*display,

+    XpmAttributes	*attributes,

+    XpmColor		*colors,

+    unsigned int	 ncolors,

+    Pixel		*image_pixels,

+    Pixel		*mask_pixels,

+    unsigned int	*mask_pixel_index,

+    Pixel		*alloc_pixels,

+    unsigned int	*nalloc_pixels,

+    Pixel		*used_pixels,

+    unsigned int	*nused_pixels)

+{

+    /* variables stored in the XpmAttributes structure */

+    Visual *visual;

+    Colormap colormap;

+    XpmColorSymbol *colorsymbols = NULL;

+    unsigned int numsymbols;

+    XpmAllocColorFunc allocColor;

+    void *closure;

+

+    char *colorname;

+    unsigned int color, key;

+    Bool pixel_defined;

+    XpmColorSymbol *symbol = NULL;

+    char **defaults;

+    int ErrorStatus = XpmSuccess;

+    char *s;

+    int default_index;

+

+    XColor *cols = NULL;

+    unsigned int ncols = 0;

+

+    /*

+     * retrieve information from the XpmAttributes

+     */

+    if (attributes && attributes->valuemask & XpmColorSymbols) {

+	colorsymbols = attributes->colorsymbols;

+	numsymbols = attributes->numsymbols;

+    } else

+	numsymbols = 0;

+

+    if (attributes && attributes->valuemask & XpmVisual)

+	visual = attributes->visual;

+    else

+	visual = XDefaultVisual(display, XDefaultScreen(display));

+

+    if (attributes && (attributes->valuemask & XpmColormap))

+	colormap = attributes->colormap;

+    else

+	colormap = XDefaultColormap(display, XDefaultScreen(display));

+

+    if (attributes && (attributes->valuemask & XpmColorKey))

+	key = attributes->color_key;

+    else

+	key = xpmVisualType(visual);

+

+    if (attributes && (attributes->valuemask & XpmAllocColor))

+	allocColor = attributes->alloc_color;

+    else

+	allocColor = AllocColor;

+    if (attributes && (attributes->valuemask & XpmColorClosure))

+	closure = attributes->color_closure;

+    else

+	closure = NULL;

+

+#ifndef FOR_MSW

+    if (USE_CLOSECOLOR) {

+	/* originally from SetCloseColor */

+#if 0

+	if (visual->class == DirectColor) {

+

+	    /*

+	     * TODO: Implement close colors for DirectColor visuals. This is

+	     * difficult situation. Chances are that we will never get here,

+	     * because any machine that supports DirectColor will probably

+	     * also support TrueColor (and probably PseudoColor). Also,

+	     * DirectColor colormaps can be very large, so looking for close

+	     * colors may be too slow.

+	     */

+	} else {

+#endif

+	    unsigned int i;

+

+#ifndef AMIGA

+	    ncols = visual->map_entries;

+#else

+	    ncols = colormap->Count;

+#endif

+	    cols = (XColor *) XpmCalloc(ncols, sizeof(XColor));

+	    for (i = 0; i < ncols; ++i)

+		cols[i].pixel = i;

+	    XQueryColors(display, colormap, cols, ncols);

+#if 0

+	}

+#endif

+    }

+#endif /* ndef FOR_MSW */

+

+    switch (key) {

+    case XPM_MONO:

+	default_index = 2;

+	break;

+    case XPM_GRAY4:

+	default_index = 3;

+	break;

+    case XPM_GRAY:

+	default_index = 4;

+	break;

+    case XPM_COLOR:

+    default:

+	default_index = 5;

+	break;

+    }

+

+    for (color = 0; color < ncolors; color++, colors++,

+					 image_pixels++, mask_pixels++) {

+	colorname = NULL;

+	pixel_defined = False;

+	defaults = (char **) colors;

+

+	/*

+	 * look for a defined symbol

+	 */

+	if (numsymbols) {

+

+	    unsigned int n;

+

+	    s = defaults[1];

+	    for (n = 0, symbol = colorsymbols; n < numsymbols; n++, symbol++) {

+		if (symbol->name && s && !strcmp(symbol->name, s))

+		    /* override name */

+		    break;

+		if (!symbol->name && symbol->value) {	/* override value */

+		    int def_index = default_index;

+

+		    while (defaults[def_index] == NULL)	/* find defined

+							 * colorname */

+			--def_index;

+		    if (def_index < 2) {/* nothing towards mono, so try

+					 * towards color */

+			def_index = default_index + 1;

+			while (def_index <= 5 && defaults[def_index] == NULL)

+			    ++def_index;

+		    }

+		    if (def_index >= 2 && defaults[def_index] != NULL &&

+			!xpmstrcasecmp(symbol->value, defaults[def_index]))

+			break;

+		}

+	    }

+	    if (n != numsymbols) {

+		if (symbol->name && symbol->value)

+		    colorname = symbol->value;

+		else

+		    pixel_defined = True;

+	    }

+	}

+	if (!pixel_defined) {		/* pixel not given as symbol value */

+

+	    unsigned int k;

+

+	    if (colorname) {		/* colorname given as symbol value */

+		if (!SetColor(display, colormap, visual, colorname, color,

+			      image_pixels, mask_pixels, mask_pixel_index,

+			      alloc_pixels, nalloc_pixels, used_pixels,

+			      nused_pixels, attributes, cols, ncols,

+			      allocColor, closure))

+		    pixel_defined = True;

+		else

+		    ErrorStatus = XpmColorError;

+	    }

+	    k = key;

+	    while (!pixel_defined && k > 1) {

+		if (defaults[k]) {

+		    if (!SetColor(display, colormap, visual, defaults[k],

+				  color, image_pixels, mask_pixels,

+				  mask_pixel_index, alloc_pixels,

+				  nalloc_pixels, used_pixels, nused_pixels,

+				  attributes, cols, ncols,

+				  allocColor, closure)) {

+			pixel_defined = True;

+			break;

+		    } else

+			ErrorStatus = XpmColorError;

+		}

+		k--;

+	    }

+	    k = key + 1;

+	    while (!pixel_defined && k < NKEYS + 1) {

+		if (defaults[k]) {

+		    if (!SetColor(display, colormap, visual, defaults[k],

+				  color, image_pixels, mask_pixels,

+				  mask_pixel_index, alloc_pixels,

+				  nalloc_pixels, used_pixels, nused_pixels,

+				  attributes, cols, ncols,

+				  allocColor, closure)) {

+			pixel_defined = True;

+			break;

+		    } else

+			ErrorStatus = XpmColorError;

+		}

+		k++;

+	    }

+	    if (!pixel_defined) {

+		if (cols)

+		    XpmFree(cols);

+		return (XpmColorFailed);

+	    }

+	} else {

+	    /* simply use the given pixel */

+	    *image_pixels = symbol->pixel;

+	    /* the following makes the mask to be built even if none

+	       is given a particular pixel */

+	    if (symbol->value

+		&& !xpmstrcasecmp(symbol->value, TRANSPARENT_COLOR)) {

+		*mask_pixels = 0;

+		*mask_pixel_index = color;

+	    } else

+		*mask_pixels = 1;

+	    used_pixels[(*nused_pixels)++] = *image_pixels;

+	}

+    }

+    if (cols)

+	XpmFree(cols);

+    return (ErrorStatus);

+}

+

+

+/* default FreeColors function, simply call XFreeColors */

+static int

+FreeColors(

+    Display	*display,

+    Colormap	 colormap,

+    Pixel	*pixels,

+    int		 n,

+    void	*closure)		/* not used */

+{

+    return XFreeColors(display, colormap, pixels, n, 0);

+}

+

+

+/* function call in case of error */

+

+#undef RETURN

+#define RETURN(status) \

+do \

+{ \

+      ErrorStatus = status; \

+      goto error; \

+} while(0)

+

+int

+XpmCreateImageFromXpmImage(

+    Display		 *display,

+    XpmImage		 *image,

+    XImage		**image_return,

+    XImage		**shapeimage_return,

+    XpmAttributes	 *attributes)

+{

+    /* variables stored in the XpmAttributes structure */

+    Visual *visual;

+    Colormap colormap;

+    unsigned int depth;

+    int bitmap_format;

+    XpmFreeColorsFunc freeColors;

+

+    /* variables to return */

+    XImage *ximage = NULL;

+    XImage *shapeimage = NULL;

+    unsigned int mask_pixel_index = XpmUndefPixel;

+    int ErrorStatus;

+

+    /* calculation variables */

+    Pixel *image_pixels = NULL;

+    Pixel *mask_pixels = NULL;

+    Pixel *alloc_pixels = NULL;

+    Pixel *used_pixels = NULL;

+    unsigned int nalloc_pixels = 0;

+    unsigned int nused_pixels = 0;

+

+    /* initialize return values */

+    if (image_return)

+	*image_return = NULL;

+    if (shapeimage_return)

+	*shapeimage_return = NULL;

+

+    /* retrieve information from the XpmAttributes */

+    if (attributes && (attributes->valuemask & XpmVisual))

+	visual = attributes->visual;

+    else

+	visual = XDefaultVisual(display, XDefaultScreen(display));

+

+    if (attributes && (attributes->valuemask & XpmColormap))

+	colormap = attributes->colormap;

+    else

+	colormap = XDefaultColormap(display, XDefaultScreen(display));

+

+    if (attributes && (attributes->valuemask & XpmDepth))

+	depth = attributes->depth;

+    else

+	depth = XDefaultDepth(display, XDefaultScreen(display));

+

+    if (attributes && (attributes->valuemask & XpmBitmapFormat))

+	bitmap_format = attributes->bitmap_format;

+    else

+	bitmap_format = ZPixmap;

+

+    if (attributes && (attributes->valuemask & XpmFreeColors))

+	freeColors = attributes->free_colors;

+    else

+	freeColors = FreeColors;

+

+    ErrorStatus = XpmSuccess;

+

+    if (image->ncolors >= UINT_MAX / sizeof(Pixel)) 

+	return (XpmNoMemory);

+

+    /* malloc pixels index tables */

+    image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);

+    if (!image_pixels)

+	return (XpmNoMemory);

+

+    mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);

+    if (!mask_pixels)

+	RETURN(XpmNoMemory);

+

+    /* maximum of allocated pixels will be the number of colors */

+    alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);

+    if (!alloc_pixels)

+	RETURN(XpmNoMemory);

+

+    /* maximum of allocated pixels will be the number of colors */

+    used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);

+    if (!used_pixels)

+	RETURN(XpmNoMemory);

+

+    /* get pixel colors, store them in index tables */

+    ErrorStatus = CreateColors(display, attributes, image->colorTable,

+			       image->ncolors, image_pixels, mask_pixels,

+			       &mask_pixel_index, alloc_pixels, &nalloc_pixels,

+			       used_pixels, &nused_pixels);

+

+    if (ErrorStatus != XpmSuccess

+	&& (ErrorStatus < 0 || (attributes

+				&& (attributes->valuemask & XpmExactColors)

+				&& attributes->exactColors)))

+	RETURN(ErrorStatus);

+

+    /* create the ximage */

+    if (image_return) {

+	ErrorStatus = CreateXImage(display, visual, depth,

+				   (depth == 1 ? bitmap_format : ZPixmap),

+				   image->width, image->height, &ximage);

+	if (ErrorStatus != XpmSuccess)

+	    RETURN(ErrorStatus);

+

+#ifndef FOR_MSW

+# ifndef AMIGA

+

+	/*

+	 * set the ximage data using optimized functions for ZPixmap

+	 */

+

+	if (ximage->bits_per_pixel == 8)

+	    PutImagePixels8(ximage, image->width, image->height,

+			    image->data, image_pixels);

+	else if (((ximage->bits_per_pixel | ximage->depth) == 1) &&

+		 (ximage->byte_order == ximage->bitmap_bit_order))

+	    PutImagePixels1(ximage, image->width, image->height,

+			    image->data, image_pixels);

+	else if (ximage->bits_per_pixel == 16)

+	    PutImagePixels16(ximage, image->width, image->height,

+			     image->data, image_pixels);

+	else if (ximage->bits_per_pixel == 32)

+	    PutImagePixels32(ximage, image->width, image->height,

+			     image->data, image_pixels);

+	else

+	    PutImagePixels(ximage, image->width, image->height,

+			   image->data, image_pixels);

+# else /* AMIGA */

+	APutImagePixels(ximage, image->width, image->height,

+			image->data, image_pixels);

+# endif

+#else  /* FOR_MSW */

+	MSWPutImagePixels(display, ximage, image->width, image->height,

+			  image->data, image_pixels);

+#endif

+    }

+    /* create the shape mask image */

+    if (mask_pixel_index != XpmUndefPixel && shapeimage_return) {

+	ErrorStatus = CreateXImage(display, visual, 1, bitmap_format,

+				   image->width, image->height, &shapeimage);

+	if (ErrorStatus != XpmSuccess)

+	    RETURN(ErrorStatus);

+

+#ifndef FOR_MSW

+# ifndef AMIGA

+	PutImagePixels1(shapeimage, image->width, image->height,

+			image->data, mask_pixels);

+# else /* AMIGA */

+	APutImagePixels(shapeimage, image->width, image->height,

+			image->data, mask_pixels);

+# endif

+#else  /* FOR_MSW */

+	MSWPutImagePixels(display, shapeimage, image->width, image->height,

+			  image->data, mask_pixels);

+#endif

+

+    }

+    XpmFree(image_pixels);

+    XpmFree(mask_pixels);

+

+    /* if requested return used pixels in the XpmAttributes structure */

+    if (attributes && (attributes->valuemask & XpmReturnPixels ||

+/* 3.2 backward compatibility code */

+	attributes->valuemask & XpmReturnInfos)) {

+/* end 3.2 bc */

+	attributes->pixels = used_pixels;

+	attributes->npixels = nused_pixels;

+	attributes->mask_pixel = mask_pixel_index;

+    } else

+	XpmFree(used_pixels);

+

+    /* if requested return alloc'ed pixels in the XpmAttributes structure */

+    if (attributes && (attributes->valuemask & XpmReturnAllocPixels)) {

+	attributes->alloc_pixels = alloc_pixels;

+	attributes->nalloc_pixels = nalloc_pixels;

+    } else

+	XpmFree(alloc_pixels);

+

+    /* return created images */

+    if (image_return)

+	*image_return = ximage;

+    if (shapeimage_return)

+	*shapeimage_return = shapeimage;

+

+    return (ErrorStatus);

+

+/* exit point in case of error, free only locally allocated variables */

+error:

+    if (ximage)

+	XDestroyImage(ximage);

+    if (shapeimage)

+	XDestroyImage(shapeimage);

+    if (image_pixels)

+	XpmFree(image_pixels);

+    if (mask_pixels)

+	XpmFree(mask_pixels);

+    if (nalloc_pixels)

+	(*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL);

+    if (alloc_pixels)

+	XpmFree(alloc_pixels);

+    if (used_pixels)

+	XpmFree(used_pixels);

+

+    return (ErrorStatus);

+}

+

+

+/*

+ * Create an XImage with its data

+ */

+static int

+CreateXImage(

+    Display	 *display,

+    Visual	 *visual,

+    unsigned int  depth,

+    int		  format,

+    unsigned int  width,

+    unsigned int  height,

+    XImage	**image_return)

+{

+    int bitmap_pad;

+

+    /* first get bitmap_pad */

+    if (depth > 16)

+	bitmap_pad = 32;

+    else if (depth > 8)

+	bitmap_pad = 16;

+    else

+	bitmap_pad = 8;

+

+    /* then create the XImage with data = NULL and bytes_per_line = 0 */

+    *image_return = XCreateImage(display, visual, depth, format, 0, 0,

+				 width, height, bitmap_pad, 0);

+    if (!*image_return)

+	return (XpmNoMemory);

+

+#if !defined(FOR_MSW) && !defined(AMIGA)

+    if (height != 0 && (*image_return)->bytes_per_line >= INT_MAX / height) {

+	XDestroyImage(*image_return);

+	return XpmNoMemory;

+    }

+    /* now that bytes_per_line must have been set properly alloc data */

+    if((*image_return)->bytes_per_line == 0 ||  height == 0)

+    	return XpmNoMemory;

+    (*image_return)->data =

+	(char *) XpmMalloc((*image_return)->bytes_per_line * height);

+

+    if (!(*image_return)->data) {

+	XDestroyImage(*image_return);

+	*image_return = NULL;

+	return (XpmNoMemory);

+    }

+#else

+    /* under FOR_MSW and AMIGA XCreateImage has done it all */

+#endif

+    return (XpmSuccess);

+}

+

+#ifndef FOR_MSW

+# ifndef AMIGA

+/*

+ * The functions below are written from X11R5 MIT's code (XImUtil.c)

+ *

+ * The idea is to have faster functions than the standard XPutPixel function

+ * to build the image data. Indeed we can speed up things by suppressing tests

+ * performed for each pixel. We do the same tests but at the image level.

+ * We also assume that we use only ZPixmap images with null offsets.

+ */

+

+LFUNC(_putbits, void, (register char *src, int dstoffset,

+		       register int numbits, register char *dst));

+

+LFUNC(_XReverse_Bytes, int, (register unsigned char *bpt, register unsigned int nb));

+

+static unsigned char Const _reverse_byte[0x100] = {

+    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,

+    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,

+    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,

+    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,

+    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,

+    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,

+    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,

+    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,

+    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,

+    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,

+    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,

+    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,

+    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,

+    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,

+    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,

+    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,

+    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,

+    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,

+    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,

+    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,

+    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,

+    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,

+    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,

+    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,

+    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,

+    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,

+    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,

+    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,

+    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,

+    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,

+    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,

+    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff

+};

+

+static int

+_XReverse_Bytes(

+    register unsigned char	*bpt,

+    register unsigned int	 nb)

+{

+    do {

+	*bpt = _reverse_byte[*bpt];

+	bpt++;

+    } while (--nb > 0); /* is nb user-controled? */

+    return 0;

+}

+

+

+void

+xpm_xynormalizeimagebits(

+    register unsigned char	*bp,

+    register XImage		*img)

+{

+    register unsigned char c;

+

+    if (img->byte_order != img->bitmap_bit_order) {

+	switch (img->bitmap_unit) {

+

+	case 16:

+	    c = *bp;

+	    *bp = *(bp + 1);

+	    *(bp + 1) = c;

+	    break;

+

+	case 32:

+	    c = *(bp + 3);

+	    *(bp + 3) = *bp;

+	    *bp = c;

+	    c = *(bp + 2);

+	    *(bp + 2) = *(bp + 1);

+	    *(bp + 1) = c;

+	    break;

+	}

+    }

+    if (img->bitmap_bit_order == MSBFirst)

+	_XReverse_Bytes(bp, img->bitmap_unit >> 3);

+}

+

+void

+xpm_znormalizeimagebits(

+    register unsigned char	*bp,

+    register XImage		*img)

+{

+    register unsigned char c;

+

+    switch (img->bits_per_pixel) {

+

+    case 2:

+	_XReverse_Bytes(bp, 1);

+	break;

+

+    case 4:

+	*bp = ((*bp >> 4) & 0xF) | ((*bp << 4) & ~0xF);

+	break;

+

+    case 16:

+	c = *bp;

+	*bp = *(bp + 1);

+	*(bp + 1) = c;

+	break;

+

+    case 24:

+	c = *(bp + 2);

+	*(bp + 2) = *bp;

+	*bp = c;

+	break;

+

+    case 32:

+	c = *(bp + 3);

+	*(bp + 3) = *bp;

+	*bp = c;

+	c = *(bp + 2);

+	*(bp + 2) = *(bp + 1);

+	*(bp + 1) = c;

+	break;

+    }

+}

+

+static unsigned char Const _lomask[0x09] = {

+0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};

+static unsigned char Const _himask[0x09] = {

+0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00};

+

+static void

+_putbits(

+    register char	*src,		/* address of source bit string */

+    int			 dstoffset,	/* bit offset into destination;

+					 * range is 0-31 */

+    register int	 numbits,	/* number of bits to copy to

+					 * destination */

+    register char	*dst)		/* address of destination bit string */

+{

+    register unsigned char chlo, chhi;

+    int hibits;

+

+    dst = dst + (dstoffset >> 3);

+    dstoffset = dstoffset & 7;

+    hibits = 8 - dstoffset;

+    chlo = *dst & _lomask[dstoffset];

+    for (;;) {

+	chhi = (*src << dstoffset) & _himask[dstoffset];

+	if (numbits <= hibits) {

+	    chhi = chhi & _lomask[dstoffset + numbits];

+	    *dst = (*dst & _himask[dstoffset + numbits]) | chlo | chhi;

+	    break;

+	}

+	*dst = chhi | chlo;

+	dst++;

+	numbits = numbits - hibits;

+	chlo = (unsigned char) (*src & _himask[hibits]) >> hibits;

+	src++;

+	if (numbits <= dstoffset) {

+	    chlo = chlo & _lomask[numbits];

+	    *dst = (*dst & _himask[numbits]) | chlo;

+	    break;

+	}

+	numbits = numbits - dstoffset;

+    }

+}

+

+/*

+ * Default method to write pixels into a Z image data structure.

+ * The algorithm used is:

+ *

+ *	copy the destination bitmap_unit or Zpixel to temp

+ *	normalize temp if needed

+ *	copy the pixel bits into the temp

+ *	renormalize temp if needed

+ *	copy the temp back into the destination image data

+ */

+

+static void

+PutImagePixels(

+    XImage		*image,

+    unsigned int	 width,

+    unsigned int	 height,

+    unsigned int	*pixelindex,

+    Pixel		*pixels)

+{

+    register char *src;

+    register char *dst;

+    register unsigned int *iptr;

+    register unsigned int x, y;

+    register char *data;

+    Pixel pixel, px;

+    int nbytes, depth, ibu, ibpp, i;

+

+    data = image->data;

+    iptr = pixelindex;

+    depth = image->depth;

+    if (depth == 1) {

+	ibu = image->bitmap_unit;

+	for (y = 0; y < height; y++) /* how can we trust height */

+	    for (x = 0; x < width; x++, iptr++) { /* how can we trust width */

+		pixel = pixels[*iptr];

+		for (i = 0, px = pixel; i < sizeof(unsigned long);

+		     i++, px >>= 8)

+		    ((unsigned char *) &pixel)[i] = px;

+		src = &data[XYINDEX(x, y, image)];

+		dst = (char *) &px;

+		px = 0;

+		nbytes = ibu >> 3;

+		for (i = nbytes; --i >= 0;)

+		    *dst++ = *src++;

+		XYNORMALIZE(&px, image);

+		_putbits((char *) &pixel, (x % ibu), 1, (char *) &px);

+		XYNORMALIZE(&px, image);

+		src = (char *) &px;

+		dst = &data[XYINDEX(x, y, image)];

+		for (i = nbytes; --i >= 0;)

+		    *dst++ = *src++;

+	    }

+    } else {

+	ibpp = image->bits_per_pixel;

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		pixel = pixels[*iptr];

+		if (depth == 4)

+		    pixel &= 0xf;

+		for (i = 0, px = pixel; i < sizeof(unsigned long); i++,

+		     px >>= 8)

+		    ((unsigned char *) &pixel)[i] = px;

+		src = &data[ZINDEX(x, y, image)];

+		dst = (char *) &px;

+		px = 0;

+		nbytes = (ibpp + 7) >> 3;

+		for (i = nbytes; --i >= 0;)

+		    *dst++ = *src++;

+		ZNORMALIZE(&px, image);

+		_putbits((char *) &pixel, (x * ibpp) & 7, ibpp, (char *) &px);

+		ZNORMALIZE(&px, image);

+		src = (char *) &px;

+		dst = &data[ZINDEX(x, y, image)];

+		for (i = nbytes; --i >= 0;)

+		    *dst++ = *src++;

+	    }

+    }

+}

+

+/*

+ * write pixels into a 32-bits Z image data structure

+ */

+

+#if !defined(WORD64) && !defined(LONG64)

+/* this item is static but deterministic so let it slide; doesn't

+ * hurt re-entrancy of this library. Note if it is actually const then would

+ * be OK under rules of ANSI-C but probably not C++ which may not

+ * want to allocate space for it.

+ */

+static unsigned long byteorderpixel = MSBFirst << 24;

+

+#endif

+

+/*

+   WITHOUT_SPEEDUPS is a flag to be turned on if you wish to use the original

+   3.2e code - by default you get the speeded-up version.

+*/

+

+static void

+PutImagePixels32(

+    XImage		*image,

+    unsigned int	 width,

+    unsigned int	 height,

+    unsigned int	*pixelindex,

+    Pixel		*pixels)

+{

+    unsigned char *data;

+    unsigned int *iptr;

+    unsigned int y;

+    Pixel pixel;

+

+#ifdef WITHOUT_SPEEDUPS

+

+    unsigned int x;

+    unsigned char *addr;

+

+    data = (unsigned char *) image->data;

+    iptr = pixelindex;

+#if !defined(WORD64) && !defined(LONG64)

+    if (*((char *) &byteorderpixel) == image->byte_order) {

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		addr = &data[ZINDEX32(x, y, image)];

+		*((unsigned long *) addr) = pixels[*iptr];

+	    }

+    } else

+#endif

+    if (image->byte_order == MSBFirst)

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		addr = &data[ZINDEX32(x, y, image)];

+		pixel = pixels[*iptr];

+		addr[0] = pixel >> 24;

+		addr[1] = pixel >> 16;

+		addr[2] = pixel >> 8;

+		addr[3] = pixel;

+	    }

+    else

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		addr = &data[ZINDEX32(x, y, image)];

+		pixel = pixels[*iptr];

+		addr[0] = pixel;

+		addr[1] = pixel >> 8;

+		addr[2] = pixel >> 16;

+		addr[3] = pixel >> 24;

+	    }

+

+#else  /* WITHOUT_SPEEDUPS */

+

+    unsigned int bpl = image->bytes_per_line;

+    unsigned char *data_ptr, *max_data;

+

+    data = (unsigned char *) image->data;

+    iptr = pixelindex;

+#if !defined(WORD64) && !defined(LONG64)

+    if (*((char *) &byteorderpixel) == image->byte_order) {

+	for (y = 0; y < height; y++) {

+	    data_ptr = data;

+	    max_data = data_ptr + (width << 2);

+

+	    while (data_ptr < max_data) {

+		*((unsigned long *) data_ptr) = pixels[*(iptr++)];

+		data_ptr += (1 << 2);

+	    }

+	    data += bpl;

+	}

+    } else

+#endif

+    if (image->byte_order == MSBFirst)

+	for (y = 0; y < height; y++) {

+	    data_ptr = data;

+	    max_data = data_ptr + (width << 2);

+

+	    while (data_ptr < max_data) {

+		pixel = pixels[*(iptr++)];

+

+		*data_ptr++ = pixel >> 24;

+		*data_ptr++ = pixel >> 16;

+		*data_ptr++ = pixel >> 8;

+		*data_ptr++ = pixel;

+

+	    }

+	    data += bpl;

+	}

+    else

+	for (y = 0; y < height; y++) {

+	    data_ptr = data;

+	    max_data = data_ptr + (width << 2);

+

+	    while (data_ptr < max_data) {

+		pixel = pixels[*(iptr++)];

+

+		*data_ptr++ = pixel;

+		*data_ptr++ = pixel >> 8;

+		*data_ptr++ = pixel >> 16;

+		*data_ptr++ = pixel >> 24;

+	    }

+	    data += bpl;

+	}

+

+#endif /* WITHOUT_SPEEDUPS */

+}

+

+/*

+ * write pixels into a 16-bits Z image data structure

+ */

+

+static void

+PutImagePixels16(

+    XImage		*image,

+    unsigned int	 width,

+    unsigned int	 height,

+    unsigned int	*pixelindex,

+    Pixel		*pixels)

+{

+    unsigned char *data;

+    unsigned int *iptr;

+    unsigned int y;

+

+#ifdef WITHOUT_SPEEDUPS

+

+    unsigned int x;

+    unsigned char *addr;

+

+    data = (unsigned char *) image->data;

+    iptr = pixelindex;

+    if (image->byte_order == MSBFirst)

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		addr = &data[ZINDEX16(x, y, image)];

+		addr[0] = pixels[*iptr] >> 8;

+		addr[1] = pixels[*iptr];

+	    }

+    else

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		addr = &data[ZINDEX16(x, y, image)];

+		addr[0] = pixels[*iptr];

+		addr[1] = pixels[*iptr] >> 8;

+	    }

+

+#else  /* WITHOUT_SPEEDUPS */

+

+    Pixel pixel;

+

+    unsigned int bpl = image->bytes_per_line;

+    unsigned char *data_ptr, *max_data;

+

+    data = (unsigned char *) image->data;

+    iptr = pixelindex;

+    if (image->byte_order == MSBFirst)

+	for (y = 0; y < height; y++) {

+	    data_ptr = data;

+	    max_data = data_ptr + (width << 1);

+

+	    while (data_ptr < max_data) {

+		pixel = pixels[*(iptr++)];

+

+		data_ptr[0] = pixel >> 8;

+		data_ptr[1] = pixel;

+

+		data_ptr += (1 << 1);

+	    }

+	    data += bpl;

+	}

+    else

+	for (y = 0; y < height; y++) {

+	    data_ptr = data;

+	    max_data = data_ptr + (width << 1);

+

+	    while (data_ptr < max_data) {

+		pixel = pixels[*(iptr++)];

+

+		data_ptr[0] = pixel;

+		data_ptr[1] = pixel >> 8;

+

+		data_ptr += (1 << 1);

+	    }

+	    data += bpl;

+	}

+

+#endif /* WITHOUT_SPEEDUPS */

+}

+

+/*

+ * write pixels into a 8-bits Z image data structure

+ */

+

+static void

+PutImagePixels8(

+    XImage		*image,

+    unsigned int	 width,

+    unsigned int	 height,

+    unsigned int	*pixelindex,

+    Pixel		*pixels)

+{

+    char *data;

+    unsigned int *iptr;

+    unsigned int y;

+

+#ifdef WITHOUT_SPEEDUPS

+

+    unsigned int x;

+

+    data = image->data;

+    iptr = pixelindex;

+    for (y = 0; y < height; y++)

+	for (x = 0; x < width; x++, iptr++)

+	    data[ZINDEX8(x, y, image)] = pixels[*iptr];

+

+#else  /* WITHOUT_SPEEDUPS */

+

+    unsigned int bpl = image->bytes_per_line;

+    char *data_ptr, *max_data;

+

+    data = image->data;

+    iptr = pixelindex;

+

+    for (y = 0; y < height; y++) {

+	data_ptr = data;

+	max_data = data_ptr + width;

+

+	while (data_ptr < max_data)

+	    *(data_ptr++) = pixels[*(iptr++)];

+

+	data += bpl;

+    }

+

+#endif /* WITHOUT_SPEEDUPS */

+}

+

+/*

+ * write pixels into a 1-bit depth image data structure and **offset null**

+ */

+

+static void

+PutImagePixels1(

+    XImage		*image,

+    unsigned int	 width,

+    unsigned int	 height,

+    unsigned int	*pixelindex,

+    Pixel		*pixels)

+{

+    if (image->byte_order != image->bitmap_bit_order)

+	PutImagePixels(image, width, height, pixelindex, pixels);

+    else {

+	unsigned int *iptr;

+	unsigned int y;

+	char *data;

+

+#ifdef WITHOUT_SPEEDUPS

+

+	unsigned int x;

+

+	data = image->data;

+	iptr = pixelindex;

+	if (image->bitmap_bit_order == MSBFirst)

+	    for (y = 0; y < height; y++)

+		for (x = 0; x < width; x++, iptr++) {

+		    if (pixels[*iptr] & 1)

+			data[ZINDEX1(x, y, image)] |= 0x80 >> (x & 7);

+		    else

+			data[ZINDEX1(x, y, image)] &= ~(0x80 >> (x & 7));

+		}

+	else

+	    for (y = 0; y < height; y++)

+		for (x = 0; x < width; x++, iptr++) {

+		    if (pixels[*iptr] & 1)

+			data[ZINDEX1(x, y, image)] |= 1 << (x & 7);

+		    else

+			data[ZINDEX1(x, y, image)] &= ~(1 << (x & 7));

+		}

+

+#else  /* WITHOUT_SPEEDUPS */

+

+	char value;

+	char *data_ptr, *max_data;

+	int bpl = image->bytes_per_line;

+	int diff, count;

+

+	data = image->data;

+	iptr = pixelindex;

+

+	diff = width & 7;

+	width >>= 3;

+

+	if (image->bitmap_bit_order == MSBFirst)

+	    for (y = 0; y < height; y++) {

+		data_ptr = data;

+		max_data = data_ptr + width;

+		while (data_ptr < max_data) {

+		    value = 0;

+

+		    value = (value << 1) | (pixels[*(iptr++)] & 1);

+		    value = (value << 1) | (pixels[*(iptr++)] & 1);

+		    value = (value << 1) | (pixels[*(iptr++)] & 1);

+		    value = (value << 1) | (pixels[*(iptr++)] & 1);

+		    value = (value << 1) | (pixels[*(iptr++)] & 1);

+		    value = (value << 1) | (pixels[*(iptr++)] & 1);

+		    value = (value << 1) | (pixels[*(iptr++)] & 1);

+		    value = (value << 1) | (pixels[*(iptr++)] & 1);

+

+		    *(data_ptr++) = value;

+		}

+		if (diff) {

+		    value = 0;

+		    for (count = 0; count < diff; count++) {

+			if (pixels[*(iptr++)] & 1)

+			    value |= (0x80 >> count);

+		    }

+		    *(data_ptr) = value;

+		}

+		data += bpl;

+	    }

+	else

+	    for (y = 0; y < height; y++) {

+		data_ptr = data;

+		max_data = data_ptr + width;

+		while (data_ptr < max_data) {

+		    value = 0;

+		    iptr += 8;

+

+		    value = (value << 1) | (pixels[*(--iptr)] & 1);

+		    value = (value << 1) | (pixels[*(--iptr)] & 1);

+		    value = (value << 1) | (pixels[*(--iptr)] & 1);

+		    value = (value << 1) | (pixels[*(--iptr)] & 1);

+		    value = (value << 1) | (pixels[*(--iptr)] & 1);

+		    value = (value << 1) | (pixels[*(--iptr)] & 1);

+		    value = (value << 1) | (pixels[*(--iptr)] & 1);

+		    value = (value << 1) | (pixels[*(--iptr)] & 1);

+

+		    iptr += 8;

+		    *(data_ptr++) = value;

+		}

+		if (diff) {

+		    value = 0;

+		    for (count = 0; count < diff; count++) {

+			if (pixels[*(iptr++)] & 1)

+			    value |= (1 << count);

+		    }

+		    *(data_ptr) = value;

+		}

+		data += bpl;

+	    }

+

+#endif /* WITHOUT_SPEEDUPS */

+    }

+}

+

+int

+XpmCreatePixmapFromXpmImage(

+    Display		*display,

+    Drawable		 d,

+    XpmImage		*image,

+    Pixmap		*pixmap_return,

+    Pixmap		*shapemask_return,

+    XpmAttributes	*attributes)

+{

+    XImage *ximage, *shapeimage;

+    int ErrorStatus;

+

+    /* initialize return values */

+    if (pixmap_return)

+	*pixmap_return = 0;

+    if (shapemask_return)

+	*shapemask_return = 0;

+

+    /* create the ximages */

+    ErrorStatus = XpmCreateImageFromXpmImage(display, image,

+					     (pixmap_return ? &ximage : NULL),

+					     (shapemask_return ?

+					      &shapeimage : NULL),

+					     attributes);

+    if (ErrorStatus < 0)

+	return (ErrorStatus);

+

+    /* create the pixmaps and destroy images */

+    if (pixmap_return && ximage) {

+	xpmCreatePixmapFromImage(display, d, ximage, pixmap_return);

+	XDestroyImage(ximage);

+    }

+    if (shapemask_return && shapeimage) {

+	xpmCreatePixmapFromImage(display, d, shapeimage, shapemask_return);

+	XDestroyImage(shapeimage);

+    }

+    return (ErrorStatus);

+}

+

+# else /* AMIGA */

+

+static void

+APutImagePixels (

+    XImage        *image,

+    unsigned int   width,

+    unsigned int   height,

+    unsigned int  *pixelindex,

+    Pixel         *pixels)

+{

+    unsigned int   *data = pixelindex;

+    unsigned int    x, y;

+    unsigned char  *array;

+    XImage         *tmp_img;

+    BOOL            success = FALSE;

+    

+    array = XpmMalloc ((((width+15)>>4)<<4)*sizeof (*array));

+    if (array != NULL)

+    {

+	tmp_img = AllocXImage ((((width+15)>>4)<<4), 1,

+			       image->rp->BitMap->Depth);

+	if (tmp_img != NULL)

+	{

+	    for (y = 0; y < height; ++y)

+	    {

+		for (x = 0; x < width; ++x)

+		    array[x] = pixels[*(data++)];

+		WritePixelLine8 (image->rp, 0, y, width, array, tmp_img->rp);

+	    }

+	    FreeXImage (tmp_img);

+	    success = TRUE;

+	}

+	XpmFree (array);

+    }

+    

+    if (!success)

+    {

+	for (y = 0; y < height; ++y)

+	    for (x = 0; x < width; ++x)

+		XPutPixel (image, x, y, pixels[*(data++)]);

+    }

+}

+

+# endif/* AMIGA */

+#else  /* FOR_MSW part follows */

+static void

+MSWPutImagePixels(

+    Display		*dc,

+    XImage		*image,

+    unsigned int	 width,

+    unsigned int	 height,

+    unsigned int	*pixelindex,

+    Pixel		*pixels)

+{

+    unsigned int *data = pixelindex;

+    unsigned int x, y;

+    HBITMAP obm;

+

+    obm = SelectObject(*dc, image->bitmap);

+    for (y = 0; y < height; y++) {

+	for (x = 0; x < width; x++) {

+	    SetPixel(*dc, x, y, pixels[*(data++)]); /* data is [x+y*width] */

+	}

+    }

+    SelectObject(*dc, obm);

+}

+

+#endif /* FOR_MSW */

+

+

+

+#if !defined(FOR_MSW) && !defined(AMIGA)

+

+static int

+PutPixel1(

+    register XImage	*ximage,

+    int			 x,

+    int			 y,

+    unsigned long	 pixel)

+{

+    register char *src;

+    register char *dst;

+    register int i;

+    Pixel px;

+    int nbytes;

+

+    if(x < 0 || y < 0)

+    	return 0;

+

+    for (i=0, px=pixel; i<sizeof(unsigned long); i++, px>>=8)

+	((unsigned char *)&pixel)[i] = px;

+    src = &ximage->data[XYINDEX(x, y, ximage)];

+    dst = (char *)&px;

+    px = 0;

+    nbytes = ximage->bitmap_unit >> 3;

+    for (i = nbytes; --i >= 0; ) *dst++ = *src++;

+    XYNORMALIZE(&px, ximage);

+    i = ((x + ximage->xoffset) % ximage->bitmap_unit);

+    _putbits ((char *)&pixel, i, 1, (char *)&px);

+    XYNORMALIZE(&px, ximage);

+    src = (char *) &px;

+    dst = &ximage->data[XYINDEX(x, y, ximage)];

+    for (i = nbytes; --i >= 0; )

+	*dst++ = *src++;

+

+    return 1;

+}

+

+static int

+PutPixel(

+    register XImage	*ximage,

+    int			 x,

+    int			 y,

+    unsigned long	 pixel)

+{

+    register char *src;

+    register char *dst;

+    register int i;

+    Pixel px;

+    unsigned int nbytes, ibpp;

+

+    if(x < 0 || y < 0)

+    	return 0;

+

+    ibpp = ximage->bits_per_pixel;

+    if (ximage->depth == 4)

+	pixel &= 0xf;

+    for (i = 0, px = pixel; i < sizeof(unsigned long); i++, px >>= 8)

+	((unsigned char *) &pixel)[i] = px;

+    src = &ximage->data[ZINDEX(x, y, ximage)];

+    dst = (char *) &px;

+    px = 0;

+    nbytes = (ibpp + 7) >> 3;

+    for (i = nbytes; --i >= 0;)

+	*dst++ = *src++;

+    ZNORMALIZE(&px, ximage);

+    _putbits((char *) &pixel, (x * ibpp) & 7, ibpp, (char *) &px);

+    ZNORMALIZE(&px, ximage);

+    src = (char *) &px;

+    dst = &ximage->data[ZINDEX(x, y, ximage)];

+    for (i = nbytes; --i >= 0;)

+	*dst++ = *src++;

+

+    return 1;

+}

+

+#if !defined(WORD64) && !defined(LONG64)

+static int

+PutPixel32(

+    register XImage	*ximage,

+    int			 x,

+    int			 y,

+    unsigned long	 pixel)

+{

+    unsigned char *addr;

+

+    if(x < 0 || y < 0)

+    	return 0;

+

+    addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)];

+    *((unsigned long *)addr) = pixel;

+    return 1;

+}

+#endif

+

+static int

+PutPixel32MSB(

+    register XImage	*ximage,

+    int			 x,

+    int			 y,

+    unsigned long	 pixel)

+{

+    unsigned char *addr;

+

+    if(x < 0 || y < 0)

+    	return 0;

+

+    addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)];

+    addr[0] = pixel >> 24;

+    addr[1] = pixel >> 16;

+    addr[2] = pixel >> 8;

+    addr[3] = pixel;

+    return 1;

+}

+

+static int

+PutPixel32LSB(

+    register XImage	*ximage,

+    int			 x,

+    int			 y,

+    unsigned long	 pixel)

+{

+    unsigned char *addr;

+

+    if(x < 0 || y < 0)

+    	return 0;

+

+    addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)];

+    addr[3] = pixel >> 24;

+    addr[2] = pixel >> 16;

+    addr[1] = pixel >> 8;

+    addr[0] = pixel;

+    return 1;

+}

+

+static int

+PutPixel16MSB(

+    register XImage	*ximage,

+    int			 x,

+    int			 y,

+    unsigned long	 pixel)

+{

+    unsigned char *addr;

+    

+    if(x < 0 || y < 0)

+    	return 0;

+

+    addr = &((unsigned char *)ximage->data) [ZINDEX16(x, y, ximage)];

+    addr[0] = pixel >> 8;

+    addr[1] = pixel;

+    return 1;

+}

+

+static int

+PutPixel16LSB(

+    register XImage	*ximage,

+    int			 x,

+    int			 y,

+    unsigned long	 pixel)

+{

+    unsigned char *addr;

+    

+    if(x < 0 || y < 0)

+    	return 0;

+

+    addr = &((unsigned char *)ximage->data) [ZINDEX16(x, y, ximage)];

+    addr[1] = pixel >> 8;

+    addr[0] = pixel;

+    return 1;

+}

+

+static int

+PutPixel8(

+    register XImage	*ximage,

+    int			 x,

+    int			 y,

+    unsigned long	 pixel)

+{

+    if(x < 0 || y < 0)

+    	return 0;

+

+    ximage->data[ZINDEX8(x, y, ximage)] = pixel;

+    return 1;

+}

+

+static int

+PutPixel1MSB(

+    register XImage	*ximage,

+    int			 x,

+    int			 y,

+    unsigned long	 pixel)

+{

+    if(x < 0 || y < 0)

+    	return 0;

+

+    if (pixel & 1)

+	ximage->data[ZINDEX1(x, y, ximage)] |= 0x80 >> (x & 7);

+    else

+	ximage->data[ZINDEX1(x, y, ximage)] &= ~(0x80 >> (x & 7));

+    return 1;

+}

+

+static int

+PutPixel1LSB(

+    register XImage	*ximage,

+    int			 x,

+    int			 y,

+    unsigned long	 pixel)

+{

+    if(x < 0 || y < 0)

+    	return 0;

+

+    if (pixel & 1)

+	ximage->data[ZINDEX1(x, y, ximage)] |= 1 << (x & 7);

+    else

+	ximage->data[ZINDEX1(x, y, ximage)] &= ~(1 << (x & 7));

+    return 1;

+}

+

+#endif /* not FOR_MSW && not AMIGA */

+

+/*

+ * This function parses an Xpm file or data and directly create an XImage

+ */

+int

+xpmParseDataAndCreate(

+    Display		 *display,

+    xpmData		 *data,

+    XImage		**image_return,

+    XImage		**shapeimage_return,

+    XpmImage		 *image,

+    XpmInfo		 *info,

+    XpmAttributes	 *attributes)

+{

+    /* variables stored in the XpmAttributes structure */

+    Visual *visual;

+    Colormap colormap;

+    unsigned int depth;

+    int bitmap_format;

+    XpmFreeColorsFunc freeColors;

+

+    /* variables to return */

+    XImage *ximage = NULL;

+    XImage *shapeimage = NULL;

+    unsigned int mask_pixel_index = XpmUndefPixel;

+

+    /* calculation variables */

+    Pixel *image_pixels = NULL;

+    Pixel *mask_pixels = NULL;

+    Pixel *alloc_pixels = NULL;

+    Pixel *used_pixels = NULL;

+    unsigned int nalloc_pixels = 0;

+    unsigned int nused_pixels = 0;

+    unsigned int width, height, ncolors, cpp;

+    unsigned int x_hotspot, y_hotspot, hotspot = 0, extensions = 0;

+    XpmColor *colorTable = NULL;

+    char *hints_cmt = NULL;

+    char *colors_cmt = NULL;

+    char *pixels_cmt = NULL;

+

+    unsigned int cmts;

+    int ErrorStatus;

+    xpmHashTable hashtable;

+

+

+    /* initialize return values */

+    if (image_return)

+	*image_return = NULL;

+    if (shapeimage_return)

+	*shapeimage_return = NULL;

+

+

+    /* retrieve information from the XpmAttributes */

+    if (attributes && (attributes->valuemask & XpmVisual))

+	visual = attributes->visual;

+    else

+	visual = XDefaultVisual(display, XDefaultScreen(display));

+

+    if (attributes && (attributes->valuemask & XpmColormap))

+	colormap = attributes->colormap;

+    else

+	colormap = XDefaultColormap(display, XDefaultScreen(display));

+

+    if (attributes && (attributes->valuemask & XpmDepth))

+	depth = attributes->depth;

+    else

+	depth = XDefaultDepth(display, XDefaultScreen(display));

+

+    if (attributes && (attributes->valuemask & XpmBitmapFormat))

+	bitmap_format = attributes->bitmap_format;

+    else

+	bitmap_format = ZPixmap;

+

+    if (attributes && (attributes->valuemask & XpmFreeColors))

+	freeColors = attributes->free_colors;

+    else

+	freeColors = FreeColors;

+

+    cmts = info && (info->valuemask & XpmReturnComments);

+

+    /*

+     * parse the header

+     */

+    ErrorStatus = xpmParseHeader(data);

+    if (ErrorStatus != XpmSuccess)

+	return (ErrorStatus);

+

+    /*

+     * read values

+     */

+    ErrorStatus = xpmParseValues(data, &width, &height, &ncolors, &cpp,

+				 &x_hotspot, &y_hotspot, &hotspot,

+				 &extensions);

+    if (ErrorStatus != XpmSuccess)

+	return (ErrorStatus);

+

+    /*

+     * store the hints comment line

+     */

+    if (cmts)

+	xpmGetCmt(data, &hints_cmt);

+

+    /*

+     * init the hashtable

+     */

+    if (USE_HASHTABLE) {

+	ErrorStatus = xpmHashTableInit(&hashtable);

+	if (ErrorStatus != XpmSuccess)

+	    RETURN(ErrorStatus);

+    }

+

+    /*

+     * read colors

+     */

+    ErrorStatus = xpmParseColors(data, ncolors, cpp, &colorTable, &hashtable);

+    if (ErrorStatus != XpmSuccess)

+	RETURN(ErrorStatus);

+

+    /*

+     * store the colors comment line

+     */

+    if (cmts)

+	xpmGetCmt(data, &colors_cmt);

+

+    /* malloc pixels index tables */

+    if (ncolors >= UINT_MAX / sizeof(Pixel)) 

+	RETURN(XpmNoMemory);

+

+    image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);

+    if (!image_pixels)

+	RETURN(XpmNoMemory);

+

+    mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);

+    if (!mask_pixels)

+	RETURN(XpmNoMemory);

+

+    /* maximum of allocated pixels will be the number of colors */

+    alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);

+    if (!alloc_pixels)

+	RETURN(XpmNoMemory);

+

+    /* maximum of allocated pixels will be the number of colors */

+    used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);

+    if (!used_pixels)

+	RETURN(XpmNoMemory);

+

+    /* get pixel colors, store them in index tables */

+    ErrorStatus = CreateColors(display, attributes, colorTable, ncolors,

+			       image_pixels, mask_pixels, &mask_pixel_index,

+			       alloc_pixels, &nalloc_pixels, used_pixels,

+			       &nused_pixels);

+

+    if (ErrorStatus != XpmSuccess

+	&& (ErrorStatus < 0 || (attributes

+				&& (attributes->valuemask & XpmExactColors)

+				&& attributes->exactColors)))

+	RETURN(ErrorStatus);

+

+    /* now create the ximage */

+    if (image_return) {

+	ErrorStatus = CreateXImage(display, visual, depth,

+				   (depth == 1 ? bitmap_format : ZPixmap),

+				   width, height, &ximage);

+	if (ErrorStatus != XpmSuccess)

+	    RETURN(ErrorStatus);

+

+#if !defined(FOR_MSW) && !defined(AMIGA)

+

+	/*

+	 * set the XImage pointer function, to be used with XPutPixel,

+	 * to an internal optimized function

+	 */

+

+	if (ximage->bits_per_pixel == 8)

+	    ximage->f.put_pixel = PutPixel8;

+	else if (((ximage->bits_per_pixel | ximage->depth) == 1) &&

+		 (ximage->byte_order == ximage->bitmap_bit_order))

+	    if (ximage->bitmap_bit_order == MSBFirst)

+		ximage->f.put_pixel = PutPixel1MSB;

+	    else

+		ximage->f.put_pixel = PutPixel1LSB;

+	else if (ximage->bits_per_pixel == 16)

+	    if (ximage->bitmap_bit_order == MSBFirst)

+		ximage->f.put_pixel = PutPixel16MSB;

+	    else

+		ximage->f.put_pixel = PutPixel16LSB;

+	else if (ximage->bits_per_pixel == 32)

+#if !defined(WORD64) && !defined(LONG64)

+	    if (*((char *)&byteorderpixel) == ximage->byte_order)

+		ximage->f.put_pixel = PutPixel32;

+	    else

+#endif

+		if (ximage->bitmap_bit_order == MSBFirst)

+		    ximage->f.put_pixel = PutPixel32MSB;

+		else

+		    ximage->f.put_pixel = PutPixel32LSB;

+	else if ((ximage->bits_per_pixel | ximage->depth) == 1)

+	    ximage->f.put_pixel = PutPixel1;

+	else

+	    ximage->f.put_pixel = PutPixel;

+#endif /* not FOR_MSW && not AMIGA */

+    }

+

+    /* create the shape mask image */

+    if (mask_pixel_index != XpmUndefPixel && shapeimage_return) {

+	ErrorStatus = CreateXImage(display, visual, 1, bitmap_format,

+				   width, height, &shapeimage);

+	if (ErrorStatus != XpmSuccess)

+	    RETURN(ErrorStatus);

+

+#if !defined(FOR_MSW) && !defined(AMIGA)

+	if (shapeimage->bitmap_bit_order == MSBFirst)

+	    shapeimage->f.put_pixel = PutPixel1MSB;

+	else

+	    shapeimage->f.put_pixel = PutPixel1LSB;

+#endif

+    }

+

+    /*

+     * read pixels and put them in the XImage

+     */

+    ErrorStatus = ParseAndPutPixels(

+#ifdef FOR_MSW

+				    display,

+#endif

+				    data, width, height, ncolors, cpp,

+				    colorTable, &hashtable,

+				    ximage, image_pixels,

+				    shapeimage, mask_pixels);

+    XpmFree(image_pixels);

+    image_pixels = NULL;

+    XpmFree(mask_pixels);

+    mask_pixels = NULL;

+

+    /*

+     * free the hastable

+     */

+    if (ErrorStatus != XpmSuccess)

+	RETURN(ErrorStatus);

+    else if (USE_HASHTABLE)

+	xpmHashTableFree(&hashtable);

+

+    /*

+     * store the pixels comment line

+     */

+    if (cmts)

+	xpmGetCmt(data, &pixels_cmt);

+

+    /*

+     * parse extensions

+     */

+    if (info && (info->valuemask & XpmReturnExtensions)) {

+	if (extensions) {

+	    ErrorStatus = xpmParseExtensions(data, &info->extensions,

+					     &info->nextensions);

+	    if (ErrorStatus != XpmSuccess)

+		RETURN(ErrorStatus);

+	} else {

+	    info->extensions = NULL;

+	    info->nextensions = 0;

+	}

+    }

+    /*

+     * store found informations in the XpmImage structure

+     */

+    image->width = width;

+    image->height = height;

+    image->cpp = cpp;

+    image->ncolors = ncolors;

+    image->colorTable = colorTable;

+    image->data = NULL;

+

+    if (info) {

+	if (cmts) {

+	    info->hints_cmt = hints_cmt;

+	    info->colors_cmt = colors_cmt;

+	    info->pixels_cmt = pixels_cmt;

+	}

+	if (hotspot) {

+	    info->x_hotspot = x_hotspot;

+	    info->y_hotspot = y_hotspot;

+	    info->valuemask |= XpmHotspot;

+	}

+    }

+    /* if requested return used pixels in the XpmAttributes structure */

+    if (attributes && (attributes->valuemask & XpmReturnPixels ||

+/* 3.2 backward compatibility code */

+	attributes->valuemask & XpmReturnInfos)) {

+/* end 3.2 bc */

+	attributes->pixels = used_pixels;

+	attributes->npixels = nused_pixels;

+	attributes->mask_pixel = mask_pixel_index;

+    } else

+	XpmFree(used_pixels);

+

+    /* if requested return alloc'ed pixels in the XpmAttributes structure */

+    if (attributes && (attributes->valuemask & XpmReturnAllocPixels)) {

+	attributes->alloc_pixels = alloc_pixels;

+	attributes->nalloc_pixels = nalloc_pixels;

+    } else

+	XpmFree(alloc_pixels);

+

+    /* return created images */

+    if (image_return)

+	*image_return = ximage;

+    if (shapeimage_return)

+	*shapeimage_return = shapeimage;

+

+    return (XpmSuccess);

+

+/* exit point in case of error, free only locally allocated variables */

+error:

+    if (USE_HASHTABLE)

+	xpmHashTableFree(&hashtable);

+    if (colorTable)

+	xpmFreeColorTable(colorTable, ncolors);

+    if (hints_cmt)

+	XpmFree(hints_cmt);

+    if (colors_cmt)

+	XpmFree(colors_cmt);

+    if (pixels_cmt)

+	XpmFree(pixels_cmt);

+    if (ximage)

+	XDestroyImage(ximage);

+    if (shapeimage)

+	XDestroyImage(shapeimage);

+    if (image_pixels)

+	XpmFree(image_pixels);

+    if (mask_pixels)

+	XpmFree(mask_pixels);

+    if (nalloc_pixels)

+	(*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL);

+    if (alloc_pixels)

+	XpmFree(alloc_pixels);

+    if (used_pixels)

+	XpmFree(used_pixels);

+

+    return (ErrorStatus);

+}

+

+static int

+ParseAndPutPixels(

+#ifdef FOR_MSW

+    Display		*dc,

+#endif

+    xpmData		*data,

+    unsigned int	 width,

+    unsigned int	 height,

+    unsigned int	 ncolors,

+    unsigned int	 cpp,

+    XpmColor		*colorTable,

+    xpmHashTable	*hashtable,

+    XImage		*image,

+    Pixel		*image_pixels,

+    XImage		*shapeimage,

+    Pixel		*shape_pixels)

+{

+    unsigned int a, x, y;

+

+    switch (cpp) {

+

+    case (1):				/* Optimize for single character

+					 * colors */

+	{

+	    unsigned short colidx[256];

+#ifdef FOR_MSW

+	    HDC shapedc;

+	    HBITMAP obm, sobm;

+

+	    if ( shapeimage ) {

+		shapedc = CreateCompatibleDC(*dc);

+		sobm = SelectObject(shapedc, shapeimage->bitmap);

+	    } else {

+	        shapedc = NULL;

+	    }

+	    obm = SelectObject(*dc, image->bitmap);

+#endif

+	    if (ncolors > 256)

+		return (XpmFileInvalid);

+

+	    bzero((char *)colidx, 256 * sizeof(short));

+	    for (a = 0; a < ncolors; a++)

+		colidx[(unsigned char)colorTable[a].string[0]] = a + 1;

+

+	    for (y = 0; y < height; y++) {

+		xpmNextString(data);

+		for (x = 0; x < width; x++) {

+		    int c = xpmGetC(data);

+

+		    if (c > 0 && c < 256 && colidx[c] != 0) {

+#ifndef FOR_MSW

+			XPutPixel(image, x, y, image_pixels[colidx[c] - 1]);

+			if (shapeimage)

+			    XPutPixel(shapeimage, x, y,

+				      shape_pixels[colidx[c] - 1]);

+#else

+			SetPixel(*dc, x, y, image_pixels[colidx[c] - 1]);

+			if (shapedc) {

+			    SetPixel(shapedc, x, y, shape_pixels[colidx[c] - 1]);

+			}

+#endif

+		    } else

+			return (XpmFileInvalid);

+		}

+	    }

+#ifdef FOR_MSW

+	    if ( shapedc ) {

+	        SelectObject(shapedc, sobm);

+		DeleteDC(shapedc);

+	    }

+	    SelectObject(*dc, obm);

+#endif

+	}

+	break;

+

+    case (2):				/* Optimize for double character

+					 * colors */

+	{

+

+/* free all allocated pointers at all exits */

+#define FREE_CIDX {int f; for (f = 0; f < 256; f++) \

+if (cidx[f]) XpmFree(cidx[f]);}

+

+	    /* array of pointers malloced by need */

+	    unsigned short *cidx[256];

+	    unsigned int char1;

+

+	    bzero((char *)cidx, 256 * sizeof(unsigned short *)); /* init */

+	    for (a = 0; a < ncolors; a++) {

+		char1 = (unsigned char) colorTable[a].string[0];

+		if (cidx[char1] == NULL) { /* get new memory */

+		    cidx[char1] = (unsigned short *)

+			XpmCalloc(256, sizeof(unsigned short));

+		    if (cidx[char1] == NULL) { /* new block failed */

+			FREE_CIDX;

+			return (XpmNoMemory);

+		    }

+		}

+		cidx[char1][(unsigned char)colorTable[a].string[1]] = a + 1;

+	    }

+

+	    for (y = 0; y < height; y++) {

+		xpmNextString(data);

+		for (x = 0; x < width; x++) {

+		    int cc1 = xpmGetC(data);

+		    if (cc1 > 0 && cc1 < 256) {

+			int cc2 = xpmGetC(data);

+			if (cc2 > 0 && cc2 < 256 &&

+			    cidx[cc1] && cidx[cc1][cc2] != 0) {

+#ifndef FOR_MSW

+			    XPutPixel(image, x, y,

+				      image_pixels[cidx[cc1][cc2] - 1]);

+			    if (shapeimage)

+				XPutPixel(shapeimage, x, y,

+					  shape_pixels[cidx[cc1][cc2] - 1]);

+#else

+			SelectObject(*dc, image->bitmap);

+			SetPixel(*dc, x, y, image_pixels[cidx[cc1][cc2] - 1]);

+			if (shapeimage) {

+			    SelectObject(*dc, shapeimage->bitmap);

+			    SetPixel(*dc, x, y,

+				     shape_pixels[cidx[cc1][cc2] - 1]);

+			}

+#endif

+			} else {

+			    FREE_CIDX;

+			    return (XpmFileInvalid);

+			}

+		    } else {

+			FREE_CIDX;

+			return (XpmFileInvalid);

+		    }

+		}

+	    }

+	    FREE_CIDX;

+	}

+	break;

+

+    default:				/* Non-optimized case of long color

+					 * names */

+	{

+	    char *s;

+	    char buf[BUFSIZ];

+

+	    if (cpp >= sizeof(buf))

+		return (XpmFileInvalid);

+

+	    buf[cpp] = '\0';

+	    if (USE_HASHTABLE) {

+		xpmHashAtom *slot;

+

+		for (y = 0; y < height; y++) {

+		    xpmNextString(data);

+		    for (x = 0; x < width; x++) {

+			for (a = 0, s = buf; a < cpp; a++, s++)

+			    *s = xpmGetC(data);

+			slot = xpmHashSlot(hashtable, buf);

+			if (!*slot)	/* no color matches */

+			    return (XpmFileInvalid);

+#ifndef FOR_MSW

+			XPutPixel(image, x, y,

+				  image_pixels[HashColorIndex(slot)]);

+			if (shapeimage)

+			    XPutPixel(shapeimage, x, y,

+				      shape_pixels[HashColorIndex(slot)]);

+#else

+			SelectObject(*dc, image->bitmap);

+			SetPixel(*dc, x, y,

+				 image_pixels[HashColorIndex(slot)]);

+			if (shapeimage) {

+			    SelectObject(*dc, shapeimage->bitmap);

+			    SetPixel(*dc, x, y,

+				     shape_pixels[HashColorIndex(slot)]);

+			}

+#endif

+		    }

+		}

+	    } else {

+		for (y = 0; y < height; y++) {

+		    xpmNextString(data);

+		    for (x = 0; x < width; x++) {

+			for (a = 0, s = buf; a < cpp; a++, s++)

+			    *s = xpmGetC(data);

+			for (a = 0; a < ncolors; a++)

+			    if (!strcmp(colorTable[a].string, buf))

+				break;

+			if (a == ncolors)	/* no color matches */

+			    return (XpmFileInvalid);

+#ifndef FOR_MSW

+			XPutPixel(image, x, y, image_pixels[a]);

+			if (shapeimage)

+			    XPutPixel(shapeimage, x, y, shape_pixels[a]);

+#else

+			SelectObject(*dc, image->bitmap);

+			SetPixel(*dc, x, y, image_pixels[a]);

+			if (shapeimage) {

+			    SelectObject(*dc, shapeimage->bitmap);

+			    SetPixel(*dc, x, y, shape_pixels[a]);

+			}

+#endif

+		    }

+		}

+	    }

+	}

+	break;

+    }

+    return (XpmSuccess);

+}

diff --git a/libXpm/src/data.c b/libXpm/src/data.c
index 347aa46a2..904e60b6b 100644
--- a/libXpm/src/data.c
+++ b/libXpm/src/data.c
@@ -1,479 +1,479 @@
-/*
- * Copyright (C) 1989-95 GROUPE BULL
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of GROUPE BULL shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from GROUPE BULL.
- */
-
-/*****************************************************************************\
-* data.c:                                                                     *
-*                                                                             *
-*  XPM library                                                                *
-*  IO utilities                                                               *
-*                                                                             *
-*  Developed by Arnaud Le Hors                                                *
-\*****************************************************************************/
-
-/* October 2004, source code review by Thomas Biege <thomas@suse.de> */
-
-#ifndef CXPMPROG
-#if 0
-/* Official version number */
-static char *RCS_Version = "$XpmVersion: 3.4k $";
-
-/* Internal version number */
-static char *RCS_Id = "Id: xpm.shar,v 3.71 1998/03/19 19:47:14 lehors Exp $";
-#endif
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "XpmI.h"
-#endif
-#include <ctype.h>
-
-#ifndef CXPMPROG
-#define Getc(data, file) getc(file)
-#define Ungetc(data, c, file) ungetc(c, file)
-#endif
-
-static int
-ParseComment(xpmData *data)
-{
-    if (data->type == XPMBUFFER) {
-	register char c;
-	register unsigned int n = 0;
-	unsigned int notend;
-	char *s, *s2;
-
-	s = data->Comment;
-	*s = data->Bcmt[0];
-
-	/* skip the string beginning comment */
-	s2 = data->Bcmt;
-	do {
-	    c = *data->cptr++;
-	    *++s = c;
-	    n++;
-	    s2++;
-	} while (c == *s2 && *s2 != '\0' && c);
-
-	if (*s2 != '\0') {
-	    /* this wasn't the beginning of a comment */
-	    data->cptr -= n;
-	    return 0;
-	}
-	/* store comment */
-	data->Comment[0] = *s;
-	s = data->Comment;
-	notend = 1;
-	n = 0;
-	while (notend) {
-	    s2 = data->Ecmt;
-	    while (*s != *s2 && c) {
-		c = *data->cptr++;
-		if (n == XPMMAXCMTLEN - 1)  { /* forget it */
-		    s = data->Comment;
-		    n = 0;
-		}
-		*++s = c;
-		n++;
-	    }
-	    data->CommentLength = n;
-	    do {
-		c = *data->cptr++;
-		if (n == XPMMAXCMTLEN - 1)  { /* forget it */
-		    s = data->Comment;
-		    n = 0;
-		}
-		*++s = c;
-		n++;
-		s2++;
-	    } while (c == *s2 && *s2 != '\0' && c);
-	    if (*s2 == '\0') {
-		/* this is the end of the comment */
-		notend = 0;
-		data->cptr--;
-	    }
-	}
-	return 0;
-    } else {
-	FILE *file = data->stream.file;
-	register int c;
-	register unsigned int n = 0, a;
-	unsigned int notend;
-	char *s, *s2;
-
-	s = data->Comment;
-	*s = data->Bcmt[0];
-
-	/* skip the string beginning comment */
-	s2 = data->Bcmt;
-	do {
-	    c = Getc(data, file);
-	    *++s = c;
-	    n++;
-	    s2++;
-	} while (c == *s2 && *s2 != '\0' && c != EOF);
-
-	if (*s2 != '\0') {
-	    /* this wasn't the beginning of a comment */
-	    /* put characters back in the order that we got them */
-	    for (a = n; a > 0; a--, s--)
-		Ungetc(data, *s, file);
-	    return 0;
-	}
-	/* store comment */
-	data->Comment[0] = *s;
-	s = data->Comment;
-	notend = 1;
-	n = 0;
-	while (notend) {
-	    s2 = data->Ecmt;
-	    while (*s != *s2 && c != EOF) {
-		c = Getc(data, file);
-		if (n == XPMMAXCMTLEN - 1)  { /* forget it */
-		    s = data->Comment;
-		    n = 0;
-		}
-		*++s = c;
-		n++;
-	    }
-	    data->CommentLength = n;
-	    do {
-		c = Getc(data, file);
-		if (n == XPMMAXCMTLEN - 1)  { /* forget it */
-		    s = data->Comment;
-		    n = 0;
-		}
-		*++s = c;
-		n++;
-		s2++;
-	    } while (c == *s2 && *s2 != '\0' && c != EOF);
-	    if (*s2 == '\0') {
-		/* this is the end of the comment */
-		notend = 0;
-		Ungetc(data, *s, file);
-	    }
-	}
-	return 0;
-    }
-}
-
-/*
- * skip to the end of the current string and the beginning of the next one
- */
-int
-xpmNextString(xpmData *data)
-{
-    if (!data->type)
-	data->cptr = (data->stream.data)[++data->line];
-    else if (data->type == XPMBUFFER) {
-	register char c;
-
-	/* get to the end of the current string */
-	if (data->Eos)
-	    while ((c = *data->cptr++) && c != data->Eos);
-
-	/*
-	 * then get to the beginning of the next string looking for possible
-	 * comment
-	 */
-	if (data->Bos) {
-	    while ((c = *data->cptr++) && c != data->Bos)
-		if (data->Bcmt && c == data->Bcmt[0])
-		    ParseComment(data);
-	} else if (data->Bcmt) {	/* XPM2 natural */
-	    while ((c = *data->cptr++) == data->Bcmt[0])
-		ParseComment(data);
-	    data->cptr--;
-	}
-    } else {
-	register int c;
-	FILE *file = data->stream.file;
-
-	/* get to the end of the current string */
-	if (data->Eos)
-	    while ((c = Getc(data, file)) != data->Eos && c != EOF);
-
-	/*
-	 * then get to the beginning of the next string looking for possible
-	 * comment
-	 */
-	if (data->Bos) {
-	    while ((c = Getc(data, file)) != data->Bos && c != EOF)
-		if (data->Bcmt && c == data->Bcmt[0])
-		    ParseComment(data);
-
-	} else if (data->Bcmt) {	/* XPM2 natural */
-	    while ((c = Getc(data, file)) == data->Bcmt[0])
-		ParseComment(data);
-	    Ungetc(data, c, file);
-	}
-    }
-    return 0;
-}
-
-
-/*
- * skip whitespace and return the following word
- */
-unsigned int
-xpmNextWord(
-    xpmData		*data,
-    char		*buf,
-    unsigned int	 buflen)
-{
-    register unsigned int n = 0;
-    int c;
-
-    if (!data->type || data->type == XPMBUFFER) {
-	while (isspace(c = *data->cptr) && c != data->Eos)
-	    data->cptr++;
-	do {
-	    c = *data->cptr++;
-	    *buf++ = c;
-	    n++;
-	} while (!isspace(c) && c != data->Eos && n < buflen);
-	n--;
-	data->cptr--;
-    } else {
-	FILE *file = data->stream.file;
-
-	while ((c = Getc(data, file)) != EOF && isspace(c) && c != data->Eos);
-	while (!isspace(c) && c != data->Eos && c != EOF && n < buflen) {
-	    *buf++ = c;
-	    n++;
-	    c = Getc(data, file);
-	}
-	Ungetc(data, c, file);
-    }
-    return (n); /* this returns bytes read + 1 */
-}
-
-/*
- * skip whitespace and compute the following unsigned int,
- * returns 1 if one is found and 0 if not
- */
-int
-xpmNextUI(
-    xpmData		*data,
-    unsigned int	*ui_return)
-{
-    char buf[BUFSIZ];
-    int l;
-
-    l = xpmNextWord(data, buf, BUFSIZ);
-    return xpmatoui(buf, l, ui_return);
-}
-
-/*
- * return end of string - WARNING: malloc!
- */
-int
-xpmGetString(
-    xpmData		 *data,
-    char		**sptr,
-    unsigned int	 *l)
-{
-    unsigned int i, n = 0;
-    int c;
-    char *p = NULL, *q, buf[BUFSIZ];
-
-    if (!data->type || data->type == XPMBUFFER) {
-	if (data->cptr) {
-	    char *start = data->cptr;
-	    while ((c = *data->cptr) && c != data->Eos)
-		data->cptr++;
-	    n = data->cptr - start + 1;
-	    p = (char *) XpmMalloc(n);
-	    if (!p)
-		return (XpmNoMemory);
-	    strncpy(p, start, n);
-	    if (data->type)		/* XPMBUFFER */
-		p[n - 1] = '\0';
-	}
-    } else {
-	FILE *file = data->stream.file;
-
-	if ((c = Getc(data, file)) == EOF)
-	    return (XpmFileInvalid);
-
-	i = 0;
-	q = buf;
-	p = (char *) XpmMalloc(1);
-	while (c != data->Eos && c != EOF) {
-	    if (i == BUFSIZ) {
-		/* get to the end of the buffer */
-		/* malloc needed memory */
-		q = (char *) XpmRealloc(p, n + i);
-		if (!q) {
-		    XpmFree(p);
-		    return (XpmNoMemory);
-		}
-		p = q;
-		q += n;
-		/* and copy what we already have */
-		strncpy(q, buf, i);
-		n += i;
-		i = 0;
-		q = buf;
-	    }
-	    *q++ = c;
-	    i++;
-	    c = Getc(data, file);
-	}
-	if (c == EOF) {
-	    XpmFree(p);
-	    return (XpmFileInvalid);
-	}
-	if (n + i != 0) {
-	    /* malloc needed memory */
-	    q = (char *) XpmRealloc(p, n + i + 1);
-	    if (!q) {
-		XpmFree(p);
-		return (XpmNoMemory);
-	    }
-	    p = q;
-	    q += n;
-	    /* and copy the buffer */
-	    strncpy(q, buf, i);
-	    n += i;
-	    p[n++] = '\0';
-	} else {
-	    *p = '\0';
-	    n = 1;
-	}
-	Ungetc(data, c, file);
-    }
-    *sptr = p;
-    *l = n;
-    return (XpmSuccess);
-}
-
-/*
- * get the current comment line
- */
-int
-xpmGetCmt(
-    xpmData	 *data,
-    char	**cmt)
-{
-    if (!data->type)
-	*cmt = NULL;
-    else if (data->CommentLength != 0 && data->CommentLength < UINT_MAX - 1) {
-	if( (*cmt = (char *) XpmMalloc(data->CommentLength + 1)) == NULL)
-		return XpmNoMemory;
-	strncpy(*cmt, data->Comment, data->CommentLength);
-	(*cmt)[data->CommentLength] = '\0';
-	data->CommentLength = 0;
-    } else
-	*cmt = NULL;
-    return 0;
-}
-
-xpmDataType xpmDataTypes[] =
-{
-    {"", "!", "\n", '\0', '\n', "", "", "", ""},	/* Natural type */
-    {"C", "/*", "*/", '"', '"', ",\n", "static char *", "[] = {\n", "};\n"},
-    {"Lisp", ";", "\n", '"', '"', "\n", "(setq ", " '(\n", "))\n"},
-    {NULL, NULL, NULL, 0, 0, NULL, NULL, NULL, NULL}
-};
-
-/*
- * parse xpm header
- */
-int
-xpmParseHeader(xpmData *data)
-{
-    char buf[BUFSIZ+1] = {0};
-    int l, n = 0;
-
-    if (data->type) {
-	data->Bos = '\0';
-	data->Eos = '\n';
-	data->Bcmt = data->Ecmt = NULL;
-	l = xpmNextWord(data, buf, BUFSIZ);
-	if (l == 7 && !strncmp("#define", buf, 7)) {
-	    /* this maybe an XPM 1 file */
-	    char *ptr;
-
-	    l = xpmNextWord(data, buf, BUFSIZ);
-	    if (!l)
-		return (XpmFileInvalid);
-	    buf[l] = '\0';
-	    ptr = strrchr(buf, '_');
-	    if (!ptr || strncmp("_format", ptr, l - (ptr - buf)))
-		return XpmFileInvalid;
-	    /* this is definitely an XPM 1 file */
-	    data->format = 1;
-	    n = 1;			/* handle XPM1 as mainly XPM2 C */
-	} else {
-
-	    /*
-	     * skip the first word, get the second one, and see if this is
-	     * XPM 2 or 3
-	     */
-	    l = xpmNextWord(data, buf, BUFSIZ);
-	    if ((l == 3 && !strncmp("XPM", buf, 3)) ||
-		(l == 4 && !strncmp("XPM2", buf, 4))) {
-		if (l == 3)
-		    n = 1;		/* handle XPM as XPM2 C */
-		else {
-		    /* get the type key word */
-		    l = xpmNextWord(data, buf, BUFSIZ);
-
-		    /*
-		     * get infos about this type
-		     */
-		    while (xpmDataTypes[n].type
-			   && strncmp(xpmDataTypes[n].type, buf, l))
-			n++;
-		}
-		data->format = 0;
-	    } else
-		/* nope this is not an XPM file */
-		return XpmFileInvalid;
-	}
-	if (xpmDataTypes[n].type) {
-	    if (n == 0) {		/* natural type */
-		data->Bcmt = xpmDataTypes[n].Bcmt;
-		data->Ecmt = xpmDataTypes[n].Ecmt;
-		xpmNextString(data);	/* skip the end of the headerline */
-		data->Bos = xpmDataTypes[n].Bos;
-		data->Eos = xpmDataTypes[n].Eos;
-	    } else {
-		data->Bcmt = xpmDataTypes[n].Bcmt;
-		data->Ecmt = xpmDataTypes[n].Ecmt;
-		if (!data->format) {	/* XPM 2 or 3 */
-		    data->Bos = xpmDataTypes[n].Bos;
-		    data->Eos = '\0';
-		    /* get to the beginning of the first string */
-		    xpmNextString(data);
-		    data->Eos = xpmDataTypes[n].Eos;
-		} else			/* XPM 1 skip end of line */
-		    xpmNextString(data);
-	    }
-	} else
-	    /* we don't know about that type of XPM file... */
-	    return XpmFileInvalid;
-    }
-    return XpmSuccess;
-}
+/*

+ * Copyright (C) 1989-95 GROUPE BULL

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to

+ * deal in the Software without restriction, including without limitation the

+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

+ * sell copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of GROUPE BULL shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from GROUPE BULL.

+ */

+

+/*****************************************************************************\

+* data.c:                                                                     *

+*                                                                             *

+*  XPM library                                                                *

+*  IO utilities                                                               *

+*                                                                             *

+*  Developed by Arnaud Le Hors                                                *

+\*****************************************************************************/

+

+/* October 2004, source code review by Thomas Biege <thomas@suse.de> */

+

+#ifndef CXPMPROG

+#if 0

+/* Official version number */

+static char *RCS_Version = "$XpmVersion: 3.4k $";

+

+/* Internal version number */

+static char *RCS_Id = "Id: xpm.shar,v 3.71 1998/03/19 19:47:14 lehors Exp $";

+#endif

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include "XpmI.h"

+#endif

+#include <ctype.h>

+

+#ifndef CXPMPROG

+#define Getc(data, file) getc(file)

+#define Ungetc(data, c, file) ungetc(c, file)

+#endif

+

+static int

+ParseComment(xpmData *data)

+{

+    if (data->type == XPMBUFFER) {

+	register char c;

+	register unsigned int n = 0;

+	unsigned int notend;

+	char *s, *s2;

+

+	s = data->Comment;

+	*s = data->Bcmt[0];

+

+	/* skip the string beginning comment */

+	s2 = data->Bcmt;

+	do {

+	    c = *data->cptr++;

+	    *++s = c;

+	    n++;

+	    s2++;

+	} while (c == *s2 && *s2 != '\0' && c);

+

+	if (*s2 != '\0') {

+	    /* this wasn't the beginning of a comment */

+	    data->cptr -= n;

+	    return 0;

+	}

+	/* store comment */

+	data->Comment[0] = *s;

+	s = data->Comment;

+	notend = 1;

+	n = 0;

+	while (notend) {

+	    s2 = data->Ecmt;

+	    while (*s != *s2 && c) {

+		c = *data->cptr++;

+		if (n == XPMMAXCMTLEN - 1)  { /* forget it */

+		    s = data->Comment;

+		    n = 0;

+		}

+		*++s = c;

+		n++;

+	    }

+	    data->CommentLength = n;

+	    do {

+		c = *data->cptr++;

+		if (n == XPMMAXCMTLEN - 1)  { /* forget it */

+		    s = data->Comment;

+		    n = 0;

+		}

+		*++s = c;

+		n++;

+		s2++;

+	    } while (c == *s2 && *s2 != '\0' && c);

+	    if (*s2 == '\0') {

+		/* this is the end of the comment */

+		notend = 0;

+		data->cptr--;

+	    }

+	}

+	return 0;

+    } else {

+	FILE *file = data->stream.file;

+	register int c;

+	register unsigned int n = 0, a;

+	unsigned int notend;

+	char *s, *s2;

+

+	s = data->Comment;

+	*s = data->Bcmt[0];

+

+	/* skip the string beginning comment */

+	s2 = data->Bcmt;

+	do {

+	    c = Getc(data, file);

+	    *++s = c;

+	    n++;

+	    s2++;

+	} while (c == *s2 && *s2 != '\0' && c != EOF);

+

+	if (*s2 != '\0') {

+	    /* this wasn't the beginning of a comment */

+	    /* put characters back in the order that we got them */

+	    for (a = n; a > 0; a--, s--)

+		Ungetc(data, *s, file);

+	    return 0;

+	}

+	/* store comment */

+	data->Comment[0] = *s;

+	s = data->Comment;

+	notend = 1;

+	n = 0;

+	while (notend) {

+	    s2 = data->Ecmt;

+	    while (*s != *s2 && c != EOF) {

+		c = Getc(data, file);

+		if (n == XPMMAXCMTLEN - 1)  { /* forget it */

+		    s = data->Comment;

+		    n = 0;

+		}

+		*++s = c;

+		n++;

+	    }

+	    data->CommentLength = n;

+	    do {

+		c = Getc(data, file);

+		if (n == XPMMAXCMTLEN - 1)  { /* forget it */

+		    s = data->Comment;

+		    n = 0;

+		}

+		*++s = c;

+		n++;

+		s2++;

+	    } while (c == *s2 && *s2 != '\0' && c != EOF);

+	    if (*s2 == '\0') {

+		/* this is the end of the comment */

+		notend = 0;

+		Ungetc(data, *s, file);

+	    }

+	}

+	return 0;

+    }

+}

+

+/*

+ * skip to the end of the current string and the beginning of the next one

+ */

+int

+xpmNextString(xpmData *data)

+{

+    if (!data->type)

+	data->cptr = (data->stream.data)[++data->line];

+    else if (data->type == XPMBUFFER) {

+	register char c;

+

+	/* get to the end of the current string */

+	if (data->Eos)

+	    while ((c = *data->cptr++) && c != data->Eos);

+

+	/*

+	 * then get to the beginning of the next string looking for possible

+	 * comment

+	 */

+	if (data->Bos) {

+	    while ((c = *data->cptr++) && c != data->Bos)

+		if (data->Bcmt && c == data->Bcmt[0])

+		    ParseComment(data);

+	} else if (data->Bcmt) {	/* XPM2 natural */

+	    while ((c = *data->cptr++) == data->Bcmt[0])

+		ParseComment(data);

+	    data->cptr--;

+	}

+    } else {

+	register int c;

+	FILE *file = data->stream.file;

+

+	/* get to the end of the current string */

+	if (data->Eos)

+	    while ((c = Getc(data, file)) != data->Eos && c != EOF);

+

+	/*

+	 * then get to the beginning of the next string looking for possible

+	 * comment

+	 */

+	if (data->Bos) {

+	    while ((c = Getc(data, file)) != data->Bos && c != EOF)

+		if (data->Bcmt && c == data->Bcmt[0])

+		    ParseComment(data);

+

+	} else if (data->Bcmt) {	/* XPM2 natural */

+	    while ((c = Getc(data, file)) == data->Bcmt[0])

+		ParseComment(data);

+	    Ungetc(data, c, file);

+	}

+    }

+    return 0;

+}

+

+

+/*

+ * skip whitespace and return the following word

+ */

+unsigned int

+xpmNextWord(

+    xpmData		*data,

+    char		*buf,

+    unsigned int	 buflen)

+{

+    register unsigned int n = 0;

+    int c;

+

+    if (!data->type || data->type == XPMBUFFER) {

+	while (isspace(c = *data->cptr) && c != data->Eos)

+	    data->cptr++;

+	do {

+	    c = *data->cptr++;

+	    *buf++ = c;

+	    n++;

+	} while (!isspace(c) && c != data->Eos && n < buflen);

+	n--;

+	data->cptr--;

+    } else {

+	FILE *file = data->stream.file;

+

+	while ((c = Getc(data, file)) != EOF && isspace(c) && c != data->Eos);

+	while (!isspace(c) && c != data->Eos && c != EOF && n < buflen) {

+	    *buf++ = c;

+	    n++;

+	    c = Getc(data, file);

+	}

+	Ungetc(data, c, file);

+    }

+    return (n); /* this returns bytes read + 1 */

+}

+

+/*

+ * skip whitespace and compute the following unsigned int,

+ * returns 1 if one is found and 0 if not

+ */

+int

+xpmNextUI(

+    xpmData		*data,

+    unsigned int	*ui_return)

+{

+    char buf[BUFSIZ];

+    int l;

+

+    l = xpmNextWord(data, buf, BUFSIZ);

+    return xpmatoui(buf, l, ui_return);

+}

+

+/*

+ * return end of string - WARNING: malloc!

+ */

+int

+xpmGetString(

+    xpmData		 *data,

+    char		**sptr,

+    unsigned int	 *l)

+{

+    unsigned int i, n = 0;

+    int c;

+    char *p = NULL, *q, buf[BUFSIZ];

+

+    if (!data->type || data->type == XPMBUFFER) {

+	if (data->cptr) {

+	    char *start = data->cptr;

+	    while ((c = *data->cptr) && c != data->Eos)

+		data->cptr++;

+	    n = data->cptr - start + 1;

+	    p = (char *) XpmMalloc(n);

+	    if (!p)

+		return (XpmNoMemory);

+	    strncpy(p, start, n);

+	    if (data->type)		/* XPMBUFFER */

+		p[n - 1] = '\0';

+	}

+    } else {

+	FILE *file = data->stream.file;

+

+	if ((c = Getc(data, file)) == EOF)

+	    return (XpmFileInvalid);

+

+	i = 0;

+	q = buf;

+	p = (char *) XpmMalloc(1);

+	while (c != data->Eos && c != EOF) {

+	    if (i == BUFSIZ) {

+		/* get to the end of the buffer */

+		/* malloc needed memory */

+		q = (char *) XpmRealloc(p, n + i);

+		if (!q) {

+		    XpmFree(p);

+		    return (XpmNoMemory);

+		}

+		p = q;

+		q += n;

+		/* and copy what we already have */

+		strncpy(q, buf, i);

+		n += i;

+		i = 0;

+		q = buf;

+	    }

+	    *q++ = c;

+	    i++;

+	    c = Getc(data, file);

+	}

+	if (c == EOF) {

+	    XpmFree(p);

+	    return (XpmFileInvalid);

+	}

+	if (n + i != 0) {

+	    /* malloc needed memory */

+	    q = (char *) XpmRealloc(p, n + i + 1);

+	    if (!q) {

+		XpmFree(p);

+		return (XpmNoMemory);

+	    }

+	    p = q;

+	    q += n;

+	    /* and copy the buffer */

+	    strncpy(q, buf, i);

+	    n += i;

+	    p[n++] = '\0';

+	} else {

+	    *p = '\0';

+	    n = 1;

+	}

+	Ungetc(data, c, file);

+    }

+    *sptr = p;

+    *l = n;

+    return (XpmSuccess);

+}

+

+/*

+ * get the current comment line

+ */

+int

+xpmGetCmt(

+    xpmData	 *data,

+    char	**cmt)

+{

+    if (!data->type)

+	*cmt = NULL;

+    else if (data->CommentLength != 0 && data->CommentLength < UINT_MAX - 1) {

+	if( (*cmt = (char *) XpmMalloc(data->CommentLength + 1)) == NULL)

+		return XpmNoMemory;

+	strncpy(*cmt, data->Comment, data->CommentLength);

+	(*cmt)[data->CommentLength] = '\0';

+	data->CommentLength = 0;

+    } else

+	*cmt = NULL;

+    return 0;

+}

+

+xpmDataType xpmDataTypes[] =

+{

+    {"", "!", "\n", '\0', '\n', "", "", "", ""},	/* Natural type */

+    {"C", "/*", "*/", '"', '"', ",\n", "static char *", "[] = {\n", "};\n"},

+    {"Lisp", ";", "\n", '"', '"', "\n", "(setq ", " '(\n", "))\n"},

+    {NULL, NULL, NULL, 0, 0, NULL, NULL, NULL, NULL}

+};

+

+/*

+ * parse xpm header

+ */

+int

+xpmParseHeader(xpmData *data)

+{

+    char buf[BUFSIZ+1] = {0};

+    int l, n = 0;

+

+    if (data->type) {

+	data->Bos = '\0';

+	data->Eos = '\n';

+	data->Bcmt = data->Ecmt = NULL;

+	l = xpmNextWord(data, buf, BUFSIZ);

+	if (l == 7 && !strncmp("#define", buf, 7)) {

+	    /* this maybe an XPM 1 file */

+	    char *ptr;

+

+	    l = xpmNextWord(data, buf, BUFSIZ);

+	    if (!l)

+		return (XpmFileInvalid);

+	    buf[l] = '\0';

+	    ptr = strrchr(buf, '_');

+	    if (!ptr || strncmp("_format", ptr, l - (ptr - buf)))

+		return XpmFileInvalid;

+	    /* this is definitely an XPM 1 file */

+	    data->format = 1;

+	    n = 1;			/* handle XPM1 as mainly XPM2 C */

+	} else {

+

+	    /*

+	     * skip the first word, get the second one, and see if this is

+	     * XPM 2 or 3

+	     */

+	    l = xpmNextWord(data, buf, BUFSIZ);

+	    if ((l == 3 && !strncmp("XPM", buf, 3)) ||

+		(l == 4 && !strncmp("XPM2", buf, 4))) {

+		if (l == 3)

+		    n = 1;		/* handle XPM as XPM2 C */

+		else {

+		    /* get the type key word */

+		    l = xpmNextWord(data, buf, BUFSIZ);

+

+		    /*

+		     * get infos about this type

+		     */

+		    while (xpmDataTypes[n].type

+			   && strncmp(xpmDataTypes[n].type, buf, l))

+			n++;

+		}

+		data->format = 0;

+	    } else

+		/* nope this is not an XPM file */

+		return XpmFileInvalid;

+	}

+	if (xpmDataTypes[n].type) {

+	    if (n == 0) {		/* natural type */

+		data->Bcmt = xpmDataTypes[n].Bcmt;

+		data->Ecmt = xpmDataTypes[n].Ecmt;

+		xpmNextString(data);	/* skip the end of the headerline */

+		data->Bos = xpmDataTypes[n].Bos;

+		data->Eos = xpmDataTypes[n].Eos;

+	    } else {

+		data->Bcmt = xpmDataTypes[n].Bcmt;

+		data->Ecmt = xpmDataTypes[n].Ecmt;

+		if (!data->format) {	/* XPM 2 or 3 */

+		    data->Bos = xpmDataTypes[n].Bos;

+		    data->Eos = '\0';

+		    /* get to the beginning of the first string */

+		    xpmNextString(data);

+		    data->Eos = xpmDataTypes[n].Eos;

+		} else			/* XPM 1 skip end of line */

+		    xpmNextString(data);

+	    }

+	} else

+	    /* we don't know about that type of XPM file... */

+	    return XpmFileInvalid;

+    }

+    return XpmSuccess;

+}

diff --git a/libXpm/src/makefile b/libXpm/src/makefile
new file mode 100644
index 000000000..cfd21c66b
--- /dev/null
+++ b/libXpm/src/makefile
@@ -0,0 +1,34 @@
+LIBRARY=libXpm
+
+INCLUDES += ..\include\X11
+
+CSRCS =					\
+	Attrib.c					\
+	CrBufFrI.c					\
+	CrBufFrP.c					\
+	CrDatFrI.c					\
+	CrDatFrP.c					\
+	CrIFrBuf.c					\
+	CrIFrDat.c					\
+	CrIFrP.c					\
+	CrPFrBuf.c					\
+	CrPFrDat.c					\
+	CrPFrI.c					\
+	Image.c						\
+	Info.c						\
+	RdFToBuf.c					\
+	RdFToDat.c					\
+	RdFToI.c					\
+	RdFToP.c					\
+	WrFFrBuf.c					\
+	WrFFrDat.c					\
+	WrFFrI.c					\
+	WrFFrP.c					\
+	create.c					\
+	data.c						\
+	hashtab.c					\
+	misc.c						\
+	parse.c						\
+	rgb.c						\
+	scan.c
+
diff --git a/libXpm/src/parse.c b/libXpm/src/parse.c
index 5c7915f78..1d3ef5f9d 100644
--- a/libXpm/src/parse.c
+++ b/libXpm/src/parse.c
@@ -1,804 +1,804 @@
-/*
- * Copyright (C) 1989-95 GROUPE BULL
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of GROUPE BULL shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from GROUPE BULL.
- */
-
-/*****************************************************************************\
-* parse.c:                                                                    *
-*                                                                             *
-*  XPM library                                                                *
-*  Parse an XPM file or array and store the found informations                *
-*  in the given XpmImage structure.                                           *
-*                                                                             *
-*  Developed by Arnaud Le Hors                                                *
-\*****************************************************************************/
-
-/*
- * The code related to FOR_MSW has been added by
- * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
- */
-
-/* October 2004, source code review by Thomas Biege <thomas@suse.de> */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "XpmI.h"
-#include <ctype.h>
-#include <string.h>
-
-#if defined(HAS_STRLCAT) || defined(HAVE_STRLCAT)
-# define STRLCAT(dst, src, dstsize) do { \
-  	if (strlcat(dst, src, dstsize) >= (dstsize)) \
-	    return (XpmFileInvalid); } while(0)
-# define STRLCPY(dst, src, dstsize) do { \
-  	if (strlcpy(dst, src, dstsize) >= (dstsize)) \
-	    return (XpmFileInvalid); } while(0)
-#else
-# define STRLCAT(dst, src, dstsize) do { \
-	if ((strlen(dst) + strlen(src)) < (dstsize)) \
- 	    strcat(dst, src); \
-	else return (XpmFileInvalid); } while(0)
-# define STRLCPY(dst, src, dstsize) do { \
-	if (strlen(src) < (dstsize)) \
- 	    strcpy(dst, src); \
-	else return (XpmFileInvalid); } while(0)
-#endif
-
-LFUNC(ParsePixels, int, (xpmData *data, unsigned int width,
-			 unsigned int height, unsigned int ncolors,
-			 unsigned int cpp, XpmColor *colorTable,
-			 xpmHashTable *hashtable, unsigned int **pixels));
-
-char *xpmColorKeys[] = {
-    "s",				/* key #1: symbol */
-    "m",				/* key #2: mono visual */
-    "g4",				/* key #3: 4 grays visual */
-    "g",				/* key #4: gray visual */
-    "c",				/* key #5: color visual */
-};
-
-int
-xpmParseValues(
-    xpmData		*data,
-    unsigned int	*width,
-    unsigned int	*height,
-    unsigned int	*ncolors,
-    unsigned int	*cpp,
-    unsigned int	*x_hotspot,
-    unsigned int	*y_hotspot,
-    unsigned int	*hotspot,
-    unsigned int	*extensions)
-{
-    unsigned int l;
-    char buf[BUFSIZ + 1];
-
-    if (!data->format) {		/* XPM 2 or 3 */
-
-	/*
-	 * read values: width, height, ncolors, chars_per_pixel
-	 */
-	if (!(xpmNextUI(data, width) && xpmNextUI(data, height)
-	      && xpmNextUI(data, ncolors) && xpmNextUI(data, cpp)))
-	    return (XpmFileInvalid);
-
-	/*
-	 * read optional information (hotspot and/or XPMEXT) if any
-	 */
-	l = xpmNextWord(data, buf, BUFSIZ);
-	if (l) {
-	    *extensions = (l == 6 && !strncmp("XPMEXT", buf, 6));
-	    if (*extensions)
-		*hotspot = (xpmNextUI(data, x_hotspot)
-			    && xpmNextUI(data, y_hotspot));
-	    else {
-		*hotspot = (xpmatoui(buf, l, x_hotspot)
-			    && xpmNextUI(data, y_hotspot));
-		l = xpmNextWord(data, buf, BUFSIZ);
-		*extensions = (l == 6 && !strncmp("XPMEXT", buf, 6));
-	    }
-	}
-    } else {
-
-	/*
-	 * XPM 1 file read values: width, height, ncolors, chars_per_pixel
-	 */
-	int i;
-	char *ptr;
-	Bool got_one, saw_width = False, saw_height = False;
-	Bool saw_ncolors = False, saw_chars_per_pixel = False;
-
-	for (i = 0; i < 4; i++) {
-	    l = xpmNextWord(data, buf, BUFSIZ);
-	    if (l != 7 || strncmp("#define", buf, 7))
-		return (XpmFileInvalid);
-	    l = xpmNextWord(data, buf, BUFSIZ);
-	    if (!l)
-		return (XpmFileInvalid);
-	    buf[l] = '\0';
-	    ptr = buf;
-	    got_one = False;
-	    while (!got_one) {
-		ptr = strchr(ptr, '_');
-		if (!ptr)
-		    return (XpmFileInvalid);
-		switch (l - (ptr - buf)) {
-		case 6:
-		    if (saw_width || strncmp("_width", ptr, 6)
-			|| !xpmNextUI(data, width))
-			return (XpmFileInvalid);
-		    else
-			saw_width = True;
-		    got_one = True;
-		    break;
-		case 7:
-		    if (saw_height || strncmp("_height", ptr, 7)
-			|| !xpmNextUI(data, height))
-			return (XpmFileInvalid);
-		    else
-			saw_height = True;
-		    got_one = True;
-		    break;
-		case 8:
-		    if (saw_ncolors || strncmp("_ncolors", ptr, 8)
-			|| !xpmNextUI(data, ncolors))
-			return (XpmFileInvalid);
-		    else
-			saw_ncolors = True;
-		    got_one = True;
-		    break;
-		case 16:
-		    if (saw_chars_per_pixel
-			|| strncmp("_chars_per_pixel", ptr, 16)
-			|| !xpmNextUI(data, cpp))
-			return (XpmFileInvalid);
-		    else
-			saw_chars_per_pixel = True;
-		    got_one = True;
-		    break;
-		default:
-		    ptr++;
-		}
-	    }
-	    /* skip the end of line */
-	    xpmNextString(data);
-	}
-	if (!saw_width || !saw_height || !saw_ncolors || !saw_chars_per_pixel)
-	  return (XpmFileInvalid);
-
-	*hotspot = 0;
-	*extensions = 0;
-    }
-    return (XpmSuccess);
-}
-
-int
-xpmParseColors(
-    xpmData		 *data,
-    unsigned int	  ncolors,
-    unsigned int	  cpp,
-    XpmColor		**colorTablePtr,
-    xpmHashTable	 *hashtable)
-{
-    unsigned int key = 0, l, a, b, len;
-    unsigned int curkey;		/* current color key */
-    unsigned int lastwaskey;		/* key read */
-    char buf[BUFSIZ+1];
-    char curbuf[BUFSIZ];		/* current buffer */
-    char **sptr, *s;
-    XpmColor *color;
-    XpmColor *colorTable;
-    char **defaults;
-    int ErrorStatus;
-
-    if (ncolors >= UINT_MAX / sizeof(XpmColor))
-	return (XpmNoMemory);
-    colorTable = (XpmColor *) XpmCalloc(ncolors, sizeof(XpmColor));
-    if (!colorTable)
-	return (XpmNoMemory);
-
-    if (!data->format) {		/* XPM 2 or 3 */
-	for (a = 0, color = colorTable; a < ncolors; a++, color++) {
-	    xpmNextString(data);	/* skip the line */
-
-	    /*
-	     * read pixel value
-	     */
-	    if (cpp >= UINT_MAX - 1) {
-		xpmFreeColorTable(colorTable, ncolors);
-		return (XpmNoMemory);
-	    }
-	    color->string = (char *) XpmMalloc(cpp + 1);
-	    if (!color->string) {
-		xpmFreeColorTable(colorTable, ncolors);
-		return (XpmNoMemory);
-	    }
-	    for (b = 0, s = color->string; b < cpp; b++, s++)
-		*s = xpmGetC(data);
-	    *s = '\0';
-
-	    /*
-	     * store the string in the hashtable with its color index number
-	     */
-	    if (USE_HASHTABLE) {
-		ErrorStatus =
-		    xpmHashIntern(hashtable, color->string, HashAtomData(a));
-		if (ErrorStatus != XpmSuccess) {
-		    xpmFreeColorTable(colorTable, ncolors);
-		    return (ErrorStatus);
-		}
-	    }
-
-	    /*
-	     * read color keys and values
-	     */
-	    defaults = (char **) color;
-	    curkey = 0;
-	    lastwaskey = 0;
-	    *curbuf = '\0';		/* init curbuf */
-	    while ((l = xpmNextWord(data, buf, BUFSIZ))) {
-		if (!lastwaskey) {
-		    for (key = 0, sptr = xpmColorKeys; key < NKEYS; key++,
-			 sptr++)
-			if ((strlen(*sptr) == l) && (!strncmp(*sptr, buf, l)))
-			    break;
-		}
-		if (!lastwaskey && key < NKEYS) {	/* open new key */
-		    if (curkey) {	/* flush string */
-			len = strlen(curbuf) + 1;
-			s = (char *) XpmMalloc(len);
-			if (!s) {
-			    xpmFreeColorTable(colorTable, ncolors);
-			    return (XpmNoMemory);
-			}
-			defaults[curkey] = s;
-			memcpy(s, curbuf, len);
-		    }
-		    curkey = key + 1;	/* set new key  */
-		    *curbuf = '\0';	/* reset curbuf */
-		    lastwaskey = 1;
-		} else {
-		    if (!curkey) {	/* key without value */
-			xpmFreeColorTable(colorTable, ncolors);
-			return (XpmFileInvalid);
-		    }
-		    if (!lastwaskey)
-			STRLCAT(curbuf, " ", sizeof(curbuf));/* append space */
-		    buf[l] = '\0';
-		    STRLCAT(curbuf, buf, sizeof(curbuf)); /* append buf */
-		    lastwaskey = 0;
-		}
-	    }
-	    if (!curkey) {		/* key without value */
-		xpmFreeColorTable(colorTable, ncolors);
-		return (XpmFileInvalid);
-	    }
-	    len = strlen(curbuf) + 1; /* integer overflow just theoretically possible */
-	    s = defaults[curkey] = (char *) XpmMalloc(len);
-	    if (!s) {
-		xpmFreeColorTable(colorTable, ncolors);
-		return (XpmNoMemory);
-	    }
-	    memcpy(s, curbuf, len);
-	}
-    } else {				/* XPM 1 */
-	/* get to the beginning of the first string */
-	data->Bos = '"';
-	data->Eos = '\0';
-	xpmNextString(data);
-	data->Eos = '"';
-	for (a = 0, color = colorTable; a < ncolors; a++, color++) {
-
-	    /*
-	     * read pixel value
-	     */
-	    if (cpp >= UINT_MAX - 1) {
-		xpmFreeColorTable(colorTable, ncolors);
-		return (XpmNoMemory);
-	    }
-	    color->string = (char *) XpmMalloc(cpp + 1);
-	    if (!color->string) {
-		xpmFreeColorTable(colorTable, ncolors);
-		return (XpmNoMemory);
-	    }
-	    for (b = 0, s = color->string; b < cpp; b++, s++)
-		*s = xpmGetC(data);
-	    *s = '\0';
-
-	    /*
-	     * store the string in the hashtable with its color index number
-	     */
-	    if (USE_HASHTABLE) {
-		ErrorStatus =
-		    xpmHashIntern(hashtable, color->string, HashAtomData(a));
-		if (ErrorStatus != XpmSuccess) {
-		    xpmFreeColorTable(colorTable, ncolors);
-		    return (ErrorStatus);
-		}
-	    }
-
-	    /*
-	     * read color values
-	     */
-	    xpmNextString(data);	/* get to the next string */
-	    *curbuf = '\0';		/* init curbuf */
-	    while ((l = xpmNextWord(data, buf, BUFSIZ))) {
-		if (*curbuf != '\0')
-		    STRLCAT(curbuf, " ", sizeof(curbuf));/* append space */
-		buf[l] = '\0';
-		STRLCAT(curbuf, buf, sizeof(curbuf));	/* append buf */
-	    }
-	    len = strlen(curbuf) + 1;
-	    s = (char *) XpmMalloc(len);
-	    if (!s) {
-		xpmFreeColorTable(colorTable, ncolors);
-		return (XpmNoMemory);
-	    }
-	    memcpy(s, curbuf, len);
-	    color->c_color = s;
-	    *curbuf = '\0';		/* reset curbuf */
-	    if (a < ncolors - 1)	/* can we trust ncolors -> leave data's bounds */
-		xpmNextString(data);	/* get to the next string */
-	}
-    }
-    *colorTablePtr = colorTable;
-    return (XpmSuccess);
-}
-
-static int
-ParsePixels(
-    xpmData		 *data,
-    unsigned int	  width,
-    unsigned int	  height,
-    unsigned int	  ncolors,
-    unsigned int	  cpp,
-    XpmColor		 *colorTable,
-    xpmHashTable	 *hashtable,
-    unsigned int	**pixels)
-{
-    unsigned int *iptr, *iptr2 = NULL; /* found by Egbert Eich */
-    unsigned int a, x, y;
-
-    if ((height > 0 && width >= UINT_MAX / height) ||
-	width * height >= UINT_MAX / sizeof(unsigned int)) 
-	return XpmNoMemory;
-#ifndef FOR_MSW
-    iptr2 = (unsigned int *) XpmMalloc(sizeof(unsigned int) * width * height);
-#else
-
-    /*
-     * special treatment to trick DOS malloc(size_t) where size_t is 16 bit!!
-     * XpmMalloc is defined to longMalloc(long) and checks the 16 bit boundary
-     */
-    iptr2 = (unsigned int *)
-	XpmMalloc((long) sizeof(unsigned int) * (long) width * (long) height);
-#endif
-    if (!iptr2)
-	return (XpmNoMemory);
-
-    iptr = iptr2;
-
-    switch (cpp) {
-
-    case (1):				/* Optimize for single character
-					 * colors */
-	{
-	    unsigned short colidx[256];
-
-	    if (ncolors > 256) {
-		XpmFree(iptr2); /* found by Egbert Eich */
-		return (XpmFileInvalid);
-	    }
-
-	    bzero((char *)colidx, 256 * sizeof(short));
-	    for (a = 0; a < ncolors; a++)
-		colidx[(unsigned char)colorTable[a].string[0]] = a + 1;
-
-	    for (y = 0; y < height; y++) {
-		xpmNextString(data);
-		for (x = 0; x < width; x++, iptr++) {
-		    int c = xpmGetC(data);
-
-		    if (c > 0 && c < 256 && colidx[c] != 0)
-			*iptr = colidx[c] - 1;
-		    else {
-			XpmFree(iptr2);
-			return (XpmFileInvalid);
-		    }
-		}
-	    }
-	}
-	break;
-
-    case (2):				/* Optimize for double character
-					 * colors */
-	{
-
-/* free all allocated pointers at all exits */
-#define FREE_CIDX \
-do \
-{ \
-	int f; for (f = 0; f < 256; f++) \
-	if (cidx[f]) XpmFree(cidx[f]); \
-} while(0)
-
-	    /* array of pointers malloced by need */
-	    unsigned short *cidx[256];
-	    unsigned int char1;
-
-	    bzero((char *)cidx, 256 * sizeof(unsigned short *)); /* init */
-	    for (a = 0; a < ncolors; a++) {
-		char1 = (unsigned char) colorTable[a].string[0];
-		if (cidx[char1] == NULL) { /* get new memory */
-		    cidx[char1] = (unsigned short *)
-			XpmCalloc(256, sizeof(unsigned short));
-		    if (cidx[char1] == NULL) { /* new block failed */
-			FREE_CIDX;
-			XpmFree(iptr2);
-			return (XpmNoMemory);
-		    }
-		}
-		cidx[char1][(unsigned char)colorTable[a].string[1]] = a + 1;
-	    }
-
-	    for (y = 0; y < height; y++) {
-		xpmNextString(data);
-		for (x = 0; x < width; x++, iptr++) {
-		    int cc1 = xpmGetC(data);
-		    if (cc1 > 0 && cc1 < 256) {
-			int cc2 = xpmGetC(data);
-			if (cc2 > 0 && cc2 < 256 &&
-			    cidx[cc1] && cidx[cc1][cc2] != 0)
-			    *iptr = cidx[cc1][cc2] - 1;
-			else {
-			    FREE_CIDX;
-			    XpmFree(iptr2);
-			    return (XpmFileInvalid);
-			}
-		    } else {
-			FREE_CIDX;
-			XpmFree(iptr2);
-			return (XpmFileInvalid);
-		    }
-		}
-	    }
-	    FREE_CIDX;
-	}
-	break;
-
-    default:				/* Non-optimized case of long color
-					 * names */
-	{
-	    char *s;
-	    char buf[BUFSIZ];
-
-	    if (cpp >= sizeof(buf)) {
-		XpmFree(iptr2); /* found by Egbert Eich */
-		return (XpmFileInvalid);
-	    }
-
-	    buf[cpp] = '\0';
-	    if (USE_HASHTABLE) {
-		xpmHashAtom *slot;
-
-		for (y = 0; y < height; y++) {
-		    xpmNextString(data);
-		    for (x = 0; x < width; x++, iptr++) {
-			for (a = 0, s = buf; a < cpp; a++, s++)
-			    *s = xpmGetC(data); /* int assigned to char, not a problem here */
-			slot = xpmHashSlot(hashtable, buf);
-			if (!*slot) {	/* no color matches */
-			    XpmFree(iptr2);
-			    return (XpmFileInvalid);
-			}
-			*iptr = HashColorIndex(slot);
-		    }
-		}
-	    } else {
-		for (y = 0; y < height; y++) {
-		    xpmNextString(data);
-		    for (x = 0; x < width; x++, iptr++) {
-			for (a = 0, s = buf; a < cpp; a++, s++)
-			    *s = xpmGetC(data); /* int assigned to char, not a problem here */
-			for (a = 0; a < ncolors; a++)
-			    if (!strcmp(colorTable[a].string, buf))
-				break;
-			if (a == ncolors) {	/* no color matches */
-			    XpmFree(iptr2);
-			    return (XpmFileInvalid);
-			}
-			*iptr = a;
-		    }
-		}
-	    }
-	}
-	break;
-    }
-    *pixels = iptr2;
-    return (XpmSuccess);
-}
-
-int
-xpmParseExtensions(
-    xpmData		 *data,
-    XpmExtension	**extensions,
-    unsigned int	 *nextensions)
-{
-    XpmExtension *exts = NULL, *ext;
-    unsigned int num = 0;
-    unsigned int nlines, a, l, notstart, notend = 0;
-    int status;
-    char *string, *s, *s2, **sp;
-
-    xpmNextString(data);
-    exts = (XpmExtension *) XpmMalloc(sizeof(XpmExtension));
-    /* get the whole string */
-    status = xpmGetString(data, &string, &l);
-    if (status != XpmSuccess) {
-	XpmFree(exts);
-	return (status);
-    }
-    /* look for the key word XPMEXT, skip lines before this */
-    while ((notstart = strncmp("XPMEXT", string, 6))
-	   && (notend = strncmp("XPMENDEXT", string, 9))) {
-	XpmFree(string);
-	xpmNextString(data);
-	status = xpmGetString(data, &string, &l);
-	if (status != XpmSuccess) {
-	    XpmFree(exts);
-	    return (status);
-	}
-    }
-    if (!notstart)
-	notend = strncmp("XPMENDEXT", string, 9);
-    while (!notstart && notend) {
-	/* there starts an extension */
-	ext = (XpmExtension *)
-	    XpmRealloc(exts, (num + 1) * sizeof(XpmExtension)); /* can the loop be forced to iterate often enough to make "(num + 1) * sizeof(XpmExtension)" wrapping? */
-	if (!ext) {
-	    XpmFree(string);
-	    XpmFreeExtensions(exts, num);
-	    return (XpmNoMemory);
-	}
-	exts = ext;
-	ext += num;
-	/* skip whitespace and store its name */
-	s2 = s = string + 6;
-	while (isspace(*s2))
-	    s2++;
-	a = s2 - s;
-	ext->name = (char *) XpmMalloc(l - a - 6);
-	if (!ext->name) {
-	    XpmFree(string);
-	    ext->lines = NULL;
-	    ext->nlines = 0;
-	    XpmFreeExtensions(exts, num + 1);
-	    return (XpmNoMemory);
-	}
-	strncpy(ext->name, s + a, l - a - 6);
-	XpmFree(string);
-	/* now store the related lines */
-	xpmNextString(data);
-	status = xpmGetString(data, &string, &l);
-	if (status != XpmSuccess) {
-	    ext->lines = NULL;
-	    ext->nlines = 0;
-	    XpmFreeExtensions(exts, num + 1);
-	    return (status);
-	}
-	ext->lines = (char **) XpmMalloc(sizeof(char *));
-	nlines = 0;
-	while ((notstart = strncmp("XPMEXT", string, 6))
-	       && (notend = strncmp("XPMENDEXT", string, 9))) {
-	    sp = (char **)
-		XpmRealloc(ext->lines, (nlines + 1) * sizeof(char *)); /* can we iterate enough for a wrapping? */
-	    if (!sp) {
-		XpmFree(string);
-		ext->nlines = nlines;
-		XpmFreeExtensions(exts, num + 1);
-		return (XpmNoMemory);
-	    }
-	    ext->lines = sp;
-	    ext->lines[nlines] = string;
-	    nlines++;
-	    xpmNextString(data);
-	    status = xpmGetString(data, &string, &l);
-	    if (status != XpmSuccess) {
-		ext->nlines = nlines;
-		XpmFreeExtensions(exts, num + 1);
-		return (status);
-	    }
-	}
-	if (!nlines) {
-	    XpmFree(ext->lines);
-	    ext->lines = NULL;
-	}
-	ext->nlines = nlines;
-	num++;
-    }
-    if (!num) {
-	XpmFree(string);
-	XpmFree(exts);
-	exts = NULL;
-    } else if (!notend)
-	XpmFree(string);
-    *nextensions = num;
-    *extensions = exts;
-    return (XpmSuccess);
-}
-
-
-/* function call in case of error */
-#undef RETURN
-#define RETURN(status) \
-do { \
-      goto error; \
-} while(0)
-
-/*
- * This function parses an Xpm file or data and store the found informations
- * in an an XpmImage structure which is returned.
- */
-int
-xpmParseData(
-    xpmData	*data,
-    XpmImage	*image,
-    XpmInfo	*info)
-{
-    /* variables to return */
-    unsigned int width, height, ncolors, cpp;
-    unsigned int x_hotspot, y_hotspot, hotspot = 0, extensions = 0;
-    XpmColor *colorTable = NULL;
-    unsigned int *pixelindex = NULL;
-    char *hints_cmt = NULL;
-    char *colors_cmt = NULL;
-    char *pixels_cmt = NULL;
-
-    unsigned int cmts;
-    int ErrorStatus;
-    xpmHashTable hashtable;
-
-    cmts = info && (info->valuemask & XpmReturnComments);
-
-    /*
-     * parse the header
-     */
-    ErrorStatus = xpmParseHeader(data);
-    if (ErrorStatus != XpmSuccess)
-	return (ErrorStatus);
-
-    /*
-     * read values
-     */
-    ErrorStatus = xpmParseValues(data, &width, &height, &ncolors, &cpp,
-				 &x_hotspot, &y_hotspot, &hotspot,
-				 &extensions);
-    if (ErrorStatus != XpmSuccess)
-	return (ErrorStatus);
-
-    /*
-     * store the hints comment line
-     */
-    if (cmts)
-	xpmGetCmt(data, &hints_cmt);
-
-    /*
-     * init the hashtable
-     */
-    if (USE_HASHTABLE) {
-	ErrorStatus = xpmHashTableInit(&hashtable);
-	if (ErrorStatus != XpmSuccess)
-	    RETURN(ErrorStatus);
-    }
-
-    /*
-     * read colors
-     */
-    ErrorStatus = xpmParseColors(data, ncolors, cpp, &colorTable, &hashtable);
-    if (ErrorStatus != XpmSuccess) {
-	if (USE_HASHTABLE)
-	    xpmHashTableFree(&hashtable);
-	RETURN(ErrorStatus);
-    }
-
-    /*
-     * store the colors comment line
-     */
-    if (cmts)
-	xpmGetCmt(data, &colors_cmt);
-
-    /*
-     * read pixels and index them on color number
-     */
-    ErrorStatus = ParsePixels(data, width, height, ncolors, cpp, colorTable,
-			      &hashtable, &pixelindex);
-
-    /*
-     * free the hastable
-     */
-    if (USE_HASHTABLE)
-	xpmHashTableFree(&hashtable);
-
-    if (ErrorStatus != XpmSuccess)
-	RETURN(ErrorStatus);
-
-    /*
-     * store the pixels comment line
-     */
-    if (cmts)
-	xpmGetCmt(data, &pixels_cmt);
-
-    /*
-     * parse extensions
-     */
-    if (info && (info->valuemask & XpmReturnExtensions)) {
-	if (extensions) {
-	    ErrorStatus = xpmParseExtensions(data, &info->extensions,
-					     &info->nextensions);
-	    if (ErrorStatus != XpmSuccess)
-		RETURN(ErrorStatus);
-	} else {
-	    info->extensions = NULL;
-	    info->nextensions = 0;
-	}
-    }
-
-    /*
-     * store found informations in the XpmImage structure
-     */
-    image->width = width;
-    image->height = height;
-    image->cpp = cpp;
-    image->ncolors = ncolors;
-    image->colorTable = colorTable;
-    image->data = pixelindex;
-
-    if (info) {
-	if (cmts) {
-	    info->hints_cmt = hints_cmt;
-	    info->colors_cmt = colors_cmt;
-	    info->pixels_cmt = pixels_cmt;
-	}
-	if (hotspot) {
-	    info->x_hotspot = x_hotspot;
-	    info->y_hotspot = y_hotspot;
-	    info->valuemask |= XpmHotspot;
-	}
-    }
-    return (XpmSuccess);
-
-/* exit point in case of error, free only locally allocated variables */
-error:
-    if (colorTable)
-	xpmFreeColorTable(colorTable, ncolors);
-    if (pixelindex)
-	XpmFree(pixelindex);
-    if (hints_cmt)
-	XpmFree(hints_cmt);
-    if (colors_cmt)
-	XpmFree(colors_cmt);
-    if (pixels_cmt)
-	XpmFree(pixels_cmt);
-
-    return(ErrorStatus);
-}
+/*

+ * Copyright (C) 1989-95 GROUPE BULL

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to

+ * deal in the Software without restriction, including without limitation the

+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

+ * sell copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of GROUPE BULL shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from GROUPE BULL.

+ */

+

+/*****************************************************************************\

+* parse.c:                                                                    *

+*                                                                             *

+*  XPM library                                                                *

+*  Parse an XPM file or array and store the found informations                *

+*  in the given XpmImage structure.                                           *

+*                                                                             *

+*  Developed by Arnaud Le Hors                                                *

+\*****************************************************************************/

+

+/*

+ * The code related to FOR_MSW has been added by

+ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94

+ */

+

+/* October 2004, source code review by Thomas Biege <thomas@suse.de> */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include "XpmI.h"

+#include <ctype.h>

+#include <string.h>

+

+#if defined(HAS_STRLCAT) || defined(HAVE_STRLCAT)

+# define STRLCAT(dst, src, dstsize) do { \

+  	if (strlcat(dst, src, dstsize) >= (dstsize)) \

+	    return (XpmFileInvalid); } while(0)

+# define STRLCPY(dst, src, dstsize) do { \

+  	if (strlcpy(dst, src, dstsize) >= (dstsize)) \

+	    return (XpmFileInvalid); } while(0)

+#else

+# define STRLCAT(dst, src, dstsize) do { \

+	if ((strlen(dst) + strlen(src)) < (dstsize)) \

+ 	    strcat(dst, src); \

+	else return (XpmFileInvalid); } while(0)

+# define STRLCPY(dst, src, dstsize) do { \

+	if (strlen(src) < (dstsize)) \

+ 	    strcpy(dst, src); \

+	else return (XpmFileInvalid); } while(0)

+#endif

+

+LFUNC(ParsePixels, int, (xpmData *data, unsigned int width,

+			 unsigned int height, unsigned int ncolors,

+			 unsigned int cpp, XpmColor *colorTable,

+			 xpmHashTable *hashtable, unsigned int **pixels));

+

+char *xpmColorKeys[] = {

+    "s",				/* key #1: symbol */

+    "m",				/* key #2: mono visual */

+    "g4",				/* key #3: 4 grays visual */

+    "g",				/* key #4: gray visual */

+    "c",				/* key #5: color visual */

+};

+

+int

+xpmParseValues(

+    xpmData		*data,

+    unsigned int	*width,

+    unsigned int	*height,

+    unsigned int	*ncolors,

+    unsigned int	*cpp,

+    unsigned int	*x_hotspot,

+    unsigned int	*y_hotspot,

+    unsigned int	*hotspot,

+    unsigned int	*extensions)

+{

+    unsigned int l;

+    char buf[BUFSIZ + 1];

+

+    if (!data->format) {		/* XPM 2 or 3 */

+

+	/*

+	 * read values: width, height, ncolors, chars_per_pixel

+	 */

+	if (!(xpmNextUI(data, width) && xpmNextUI(data, height)

+	      && xpmNextUI(data, ncolors) && xpmNextUI(data, cpp)))

+	    return (XpmFileInvalid);

+

+	/*

+	 * read optional information (hotspot and/or XPMEXT) if any

+	 */

+	l = xpmNextWord(data, buf, BUFSIZ);

+	if (l) {

+	    *extensions = (l == 6 && !strncmp("XPMEXT", buf, 6));

+	    if (*extensions)

+		*hotspot = (xpmNextUI(data, x_hotspot)

+			    && xpmNextUI(data, y_hotspot));

+	    else {

+		*hotspot = (xpmatoui(buf, l, x_hotspot)

+			    && xpmNextUI(data, y_hotspot));

+		l = xpmNextWord(data, buf, BUFSIZ);

+		*extensions = (l == 6 && !strncmp("XPMEXT", buf, 6));

+	    }

+	}

+    } else {

+

+	/*

+	 * XPM 1 file read values: width, height, ncolors, chars_per_pixel

+	 */

+	int i;

+	char *ptr;

+	Bool got_one, saw_width = False, saw_height = False;

+	Bool saw_ncolors = False, saw_chars_per_pixel = False;

+

+	for (i = 0; i < 4; i++) {

+	    l = xpmNextWord(data, buf, BUFSIZ);

+	    if (l != 7 || strncmp("#define", buf, 7))

+		return (XpmFileInvalid);

+	    l = xpmNextWord(data, buf, BUFSIZ);

+	    if (!l)

+		return (XpmFileInvalid);

+	    buf[l] = '\0';

+	    ptr = buf;

+	    got_one = False;

+	    while (!got_one) {

+		ptr = strchr(ptr, '_');

+		if (!ptr)

+		    return (XpmFileInvalid);

+		switch (l - (ptr - buf)) {

+		case 6:

+		    if (saw_width || strncmp("_width", ptr, 6)

+			|| !xpmNextUI(data, width))

+			return (XpmFileInvalid);

+		    else

+			saw_width = True;

+		    got_one = True;

+		    break;

+		case 7:

+		    if (saw_height || strncmp("_height", ptr, 7)

+			|| !xpmNextUI(data, height))

+			return (XpmFileInvalid);

+		    else

+			saw_height = True;

+		    got_one = True;

+		    break;

+		case 8:

+		    if (saw_ncolors || strncmp("_ncolors", ptr, 8)

+			|| !xpmNextUI(data, ncolors))

+			return (XpmFileInvalid);

+		    else

+			saw_ncolors = True;

+		    got_one = True;

+		    break;

+		case 16:

+		    if (saw_chars_per_pixel

+			|| strncmp("_chars_per_pixel", ptr, 16)

+			|| !xpmNextUI(data, cpp))

+			return (XpmFileInvalid);

+		    else

+			saw_chars_per_pixel = True;

+		    got_one = True;

+		    break;

+		default:

+		    ptr++;

+		}

+	    }

+	    /* skip the end of line */

+	    xpmNextString(data);

+	}

+	if (!saw_width || !saw_height || !saw_ncolors || !saw_chars_per_pixel)

+	  return (XpmFileInvalid);

+

+	*hotspot = 0;

+	*extensions = 0;

+    }

+    return (XpmSuccess);

+}

+

+int

+xpmParseColors(

+    xpmData		 *data,

+    unsigned int	  ncolors,

+    unsigned int	  cpp,

+    XpmColor		**colorTablePtr,

+    xpmHashTable	 *hashtable)

+{

+    unsigned int key = 0, l, a, b, len;

+    unsigned int curkey;		/* current color key */

+    unsigned int lastwaskey;		/* key read */

+    char buf[BUFSIZ+1];

+    char curbuf[BUFSIZ];		/* current buffer */

+    char **sptr, *s;

+    XpmColor *color;

+    XpmColor *colorTable;

+    char **defaults;

+    int ErrorStatus;

+

+    if (ncolors >= UINT_MAX / sizeof(XpmColor))

+	return (XpmNoMemory);

+    colorTable = (XpmColor *) XpmCalloc(ncolors, sizeof(XpmColor));

+    if (!colorTable)

+	return (XpmNoMemory);

+

+    if (!data->format) {		/* XPM 2 or 3 */

+	for (a = 0, color = colorTable; a < ncolors; a++, color++) {

+	    xpmNextString(data);	/* skip the line */

+

+	    /*

+	     * read pixel value

+	     */

+	    if (cpp >= UINT_MAX - 1) {

+		xpmFreeColorTable(colorTable, ncolors);

+		return (XpmNoMemory);

+	    }

+	    color->string = (char *) XpmMalloc(cpp + 1);

+	    if (!color->string) {

+		xpmFreeColorTable(colorTable, ncolors);

+		return (XpmNoMemory);

+	    }

+	    for (b = 0, s = color->string; b < cpp; b++, s++)

+		*s = xpmGetC(data);

+	    *s = '\0';

+

+	    /*

+	     * store the string in the hashtable with its color index number

+	     */

+	    if (USE_HASHTABLE) {

+		ErrorStatus =

+		    xpmHashIntern(hashtable, color->string, HashAtomData(a));

+		if (ErrorStatus != XpmSuccess) {

+		    xpmFreeColorTable(colorTable, ncolors);

+		    return (ErrorStatus);

+		}

+	    }

+

+	    /*

+	     * read color keys and values

+	     */

+	    defaults = (char **) color;

+	    curkey = 0;

+	    lastwaskey = 0;

+	    *curbuf = '\0';		/* init curbuf */

+	    while ((l = xpmNextWord(data, buf, BUFSIZ))) {

+		if (!lastwaskey) {

+		    for (key = 0, sptr = xpmColorKeys; key < NKEYS; key++,

+			 sptr++)

+			if ((strlen(*sptr) == l) && (!strncmp(*sptr, buf, l)))

+			    break;

+		}

+		if (!lastwaskey && key < NKEYS) {	/* open new key */

+		    if (curkey) {	/* flush string */

+			len = strlen(curbuf) + 1;

+			s = (char *) XpmMalloc(len);

+			if (!s) {

+			    xpmFreeColorTable(colorTable, ncolors);

+			    return (XpmNoMemory);

+			}

+			defaults[curkey] = s;

+			memcpy(s, curbuf, len);

+		    }

+		    curkey = key + 1;	/* set new key  */

+		    *curbuf = '\0';	/* reset curbuf */

+		    lastwaskey = 1;

+		} else {

+		    if (!curkey) {	/* key without value */

+			xpmFreeColorTable(colorTable, ncolors);

+			return (XpmFileInvalid);

+		    }

+		    if (!lastwaskey)

+			STRLCAT(curbuf, " ", sizeof(curbuf));/* append space */

+		    buf[l] = '\0';

+		    STRLCAT(curbuf, buf, sizeof(curbuf)); /* append buf */

+		    lastwaskey = 0;

+		}

+	    }

+	    if (!curkey) {		/* key without value */

+		xpmFreeColorTable(colorTable, ncolors);

+		return (XpmFileInvalid);

+	    }

+	    len = strlen(curbuf) + 1; /* integer overflow just theoretically possible */

+	    s = defaults[curkey] = (char *) XpmMalloc(len);

+	    if (!s) {

+		xpmFreeColorTable(colorTable, ncolors);

+		return (XpmNoMemory);

+	    }

+	    memcpy(s, curbuf, len);

+	}

+    } else {				/* XPM 1 */

+	/* get to the beginning of the first string */

+	data->Bos = '"';

+	data->Eos = '\0';

+	xpmNextString(data);

+	data->Eos = '"';

+	for (a = 0, color = colorTable; a < ncolors; a++, color++) {

+

+	    /*

+	     * read pixel value

+	     */

+	    if (cpp >= UINT_MAX - 1) {

+		xpmFreeColorTable(colorTable, ncolors);

+		return (XpmNoMemory);

+	    }

+	    color->string = (char *) XpmMalloc(cpp + 1);

+	    if (!color->string) {

+		xpmFreeColorTable(colorTable, ncolors);

+		return (XpmNoMemory);

+	    }

+	    for (b = 0, s = color->string; b < cpp; b++, s++)

+		*s = xpmGetC(data);

+	    *s = '\0';

+

+	    /*

+	     * store the string in the hashtable with its color index number

+	     */

+	    if (USE_HASHTABLE) {

+		ErrorStatus =

+		    xpmHashIntern(hashtable, color->string, HashAtomData(a));

+		if (ErrorStatus != XpmSuccess) {

+		    xpmFreeColorTable(colorTable, ncolors);

+		    return (ErrorStatus);

+		}

+	    }

+

+	    /*

+	     * read color values

+	     */

+	    xpmNextString(data);	/* get to the next string */

+	    *curbuf = '\0';		/* init curbuf */

+	    while ((l = xpmNextWord(data, buf, BUFSIZ))) {

+		if (*curbuf != '\0')

+		    STRLCAT(curbuf, " ", sizeof(curbuf));/* append space */

+		buf[l] = '\0';

+		STRLCAT(curbuf, buf, sizeof(curbuf));	/* append buf */

+	    }

+	    len = strlen(curbuf) + 1;

+	    s = (char *) XpmMalloc(len);

+	    if (!s) {

+		xpmFreeColorTable(colorTable, ncolors);

+		return (XpmNoMemory);

+	    }

+	    memcpy(s, curbuf, len);

+	    color->c_color = s;

+	    *curbuf = '\0';		/* reset curbuf */

+	    if (a < ncolors - 1)	/* can we trust ncolors -> leave data's bounds */

+		xpmNextString(data);	/* get to the next string */

+	}

+    }

+    *colorTablePtr = colorTable;

+    return (XpmSuccess);

+}

+

+static int

+ParsePixels(

+    xpmData		 *data,

+    unsigned int	  width,

+    unsigned int	  height,

+    unsigned int	  ncolors,

+    unsigned int	  cpp,

+    XpmColor		 *colorTable,

+    xpmHashTable	 *hashtable,

+    unsigned int	**pixels)

+{

+    unsigned int *iptr, *iptr2 = NULL; /* found by Egbert Eich */

+    unsigned int a, x, y;

+

+    if ((height > 0 && width >= UINT_MAX / height) ||

+	width * height >= UINT_MAX / sizeof(unsigned int)) 

+	return XpmNoMemory;

+#ifndef FOR_MSW

+    iptr2 = (unsigned int *) XpmMalloc(sizeof(unsigned int) * width * height);

+#else

+

+    /*

+     * special treatment to trick DOS malloc(size_t) where size_t is 16 bit!!

+     * XpmMalloc is defined to longMalloc(long) and checks the 16 bit boundary

+     */

+    iptr2 = (unsigned int *)

+	XpmMalloc((long) sizeof(unsigned int) * (long) width * (long) height);

+#endif

+    if (!iptr2)

+	return (XpmNoMemory);

+

+    iptr = iptr2;

+

+    switch (cpp) {

+

+    case (1):				/* Optimize for single character

+					 * colors */

+	{

+	    unsigned short colidx[256];

+

+	    if (ncolors > 256) {

+		XpmFree(iptr2); /* found by Egbert Eich */

+		return (XpmFileInvalid);

+	    }

+

+	    bzero((char *)colidx, 256 * sizeof(short));

+	    for (a = 0; a < ncolors; a++)

+		colidx[(unsigned char)colorTable[a].string[0]] = a + 1;

+

+	    for (y = 0; y < height; y++) {

+		xpmNextString(data);

+		for (x = 0; x < width; x++, iptr++) {

+		    int c = xpmGetC(data);

+

+		    if (c > 0 && c < 256 && colidx[c] != 0)

+			*iptr = colidx[c] - 1;

+		    else {

+			XpmFree(iptr2);

+			return (XpmFileInvalid);

+		    }

+		}

+	    }

+	}

+	break;

+

+    case (2):				/* Optimize for double character

+					 * colors */

+	{

+

+/* free all allocated pointers at all exits */

+#define FREE_CIDX \

+do \

+{ \

+	int f; for (f = 0; f < 256; f++) \

+	if (cidx[f]) XpmFree(cidx[f]); \

+} while(0)

+

+	    /* array of pointers malloced by need */

+	    unsigned short *cidx[256];

+	    unsigned int char1;

+

+	    bzero((char *)cidx, 256 * sizeof(unsigned short *)); /* init */

+	    for (a = 0; a < ncolors; a++) {

+		char1 = (unsigned char) colorTable[a].string[0];

+		if (cidx[char1] == NULL) { /* get new memory */

+		    cidx[char1] = (unsigned short *)

+			XpmCalloc(256, sizeof(unsigned short));

+		    if (cidx[char1] == NULL) { /* new block failed */

+			FREE_CIDX;

+			XpmFree(iptr2);

+			return (XpmNoMemory);

+		    }

+		}

+		cidx[char1][(unsigned char)colorTable[a].string[1]] = a + 1;

+	    }

+

+	    for (y = 0; y < height; y++) {

+		xpmNextString(data);

+		for (x = 0; x < width; x++, iptr++) {

+		    int cc1 = xpmGetC(data);

+		    if (cc1 > 0 && cc1 < 256) {

+			int cc2 = xpmGetC(data);

+			if (cc2 > 0 && cc2 < 256 &&

+			    cidx[cc1] && cidx[cc1][cc2] != 0)

+			    *iptr = cidx[cc1][cc2] - 1;

+			else {

+			    FREE_CIDX;

+			    XpmFree(iptr2);

+			    return (XpmFileInvalid);

+			}

+		    } else {

+			FREE_CIDX;

+			XpmFree(iptr2);

+			return (XpmFileInvalid);

+		    }

+		}

+	    }

+	    FREE_CIDX;

+	}

+	break;

+

+    default:				/* Non-optimized case of long color

+					 * names */

+	{

+	    char *s;

+	    char buf[BUFSIZ];

+

+	    if (cpp >= sizeof(buf)) {

+		XpmFree(iptr2); /* found by Egbert Eich */

+		return (XpmFileInvalid);

+	    }

+

+	    buf[cpp] = '\0';

+	    if (USE_HASHTABLE) {

+		xpmHashAtom *slot;

+

+		for (y = 0; y < height; y++) {

+		    xpmNextString(data);

+		    for (x = 0; x < width; x++, iptr++) {

+			for (a = 0, s = buf; a < cpp; a++, s++)

+			    *s = xpmGetC(data); /* int assigned to char, not a problem here */

+			slot = xpmHashSlot(hashtable, buf);

+			if (!*slot) {	/* no color matches */

+			    XpmFree(iptr2);

+			    return (XpmFileInvalid);

+			}

+			*iptr = HashColorIndex(slot);

+		    }

+		}

+	    } else {

+		for (y = 0; y < height; y++) {

+		    xpmNextString(data);

+		    for (x = 0; x < width; x++, iptr++) {

+			for (a = 0, s = buf; a < cpp; a++, s++)

+			    *s = xpmGetC(data); /* int assigned to char, not a problem here */

+			for (a = 0; a < ncolors; a++)

+			    if (!strcmp(colorTable[a].string, buf))

+				break;

+			if (a == ncolors) {	/* no color matches */

+			    XpmFree(iptr2);

+			    return (XpmFileInvalid);

+			}

+			*iptr = a;

+		    }

+		}

+	    }

+	}

+	break;

+    }

+    *pixels = iptr2;

+    return (XpmSuccess);

+}

+

+int

+xpmParseExtensions(

+    xpmData		 *data,

+    XpmExtension	**extensions,

+    unsigned int	 *nextensions)

+{

+    XpmExtension *exts = NULL, *ext;

+    unsigned int num = 0;

+    unsigned int nlines, a, l, notstart, notend = 0;

+    int status;

+    char *string, *s, *s2, **sp;

+

+    xpmNextString(data);

+    exts = (XpmExtension *) XpmMalloc(sizeof(XpmExtension));

+    /* get the whole string */

+    status = xpmGetString(data, &string, &l);

+    if (status != XpmSuccess) {

+	XpmFree(exts);

+	return (status);

+    }

+    /* look for the key word XPMEXT, skip lines before this */

+    while ((notstart = strncmp("XPMEXT", string, 6))

+	   && (notend = strncmp("XPMENDEXT", string, 9))) {

+	XpmFree(string);

+	xpmNextString(data);

+	status = xpmGetString(data, &string, &l);

+	if (status != XpmSuccess) {

+	    XpmFree(exts);

+	    return (status);

+	}

+    }

+    if (!notstart)

+	notend = strncmp("XPMENDEXT", string, 9);

+    while (!notstart && notend) {

+	/* there starts an extension */

+	ext = (XpmExtension *)

+	    XpmRealloc(exts, (num + 1) * sizeof(XpmExtension)); /* can the loop be forced to iterate often enough to make "(num + 1) * sizeof(XpmExtension)" wrapping? */

+	if (!ext) {

+	    XpmFree(string);

+	    XpmFreeExtensions(exts, num);

+	    return (XpmNoMemory);

+	}

+	exts = ext;

+	ext += num;

+	/* skip whitespace and store its name */

+	s2 = s = string + 6;

+	while (isspace(*s2))

+	    s2++;

+	a = s2 - s;

+	ext->name = (char *) XpmMalloc(l - a - 6);

+	if (!ext->name) {

+	    XpmFree(string);

+	    ext->lines = NULL;

+	    ext->nlines = 0;

+	    XpmFreeExtensions(exts, num + 1);

+	    return (XpmNoMemory);

+	}

+	strncpy(ext->name, s + a, l - a - 6);

+	XpmFree(string);

+	/* now store the related lines */

+	xpmNextString(data);

+	status = xpmGetString(data, &string, &l);

+	if (status != XpmSuccess) {

+	    ext->lines = NULL;

+	    ext->nlines = 0;

+	    XpmFreeExtensions(exts, num + 1);

+	    return (status);

+	}

+	ext->lines = (char **) XpmMalloc(sizeof(char *));

+	nlines = 0;

+	while ((notstart = strncmp("XPMEXT", string, 6))

+	       && (notend = strncmp("XPMENDEXT", string, 9))) {

+	    sp = (char **)

+		XpmRealloc(ext->lines, (nlines + 1) * sizeof(char *)); /* can we iterate enough for a wrapping? */

+	    if (!sp) {

+		XpmFree(string);

+		ext->nlines = nlines;

+		XpmFreeExtensions(exts, num + 1);

+		return (XpmNoMemory);

+	    }

+	    ext->lines = sp;

+	    ext->lines[nlines] = string;

+	    nlines++;

+	    xpmNextString(data);

+	    status = xpmGetString(data, &string, &l);

+	    if (status != XpmSuccess) {

+		ext->nlines = nlines;

+		XpmFreeExtensions(exts, num + 1);

+		return (status);

+	    }

+	}

+	if (!nlines) {

+	    XpmFree(ext->lines);

+	    ext->lines = NULL;

+	}

+	ext->nlines = nlines;

+	num++;

+    }

+    if (!num) {

+	XpmFree(string);

+	XpmFree(exts);

+	exts = NULL;

+    } else if (!notend)

+	XpmFree(string);

+    *nextensions = num;

+    *extensions = exts;

+    return (XpmSuccess);

+}

+

+

+/* function call in case of error */

+#undef RETURN

+#define RETURN(status) \

+do { \

+      goto error; \

+} while(0)

+

+/*

+ * This function parses an Xpm file or data and store the found informations

+ * in an an XpmImage structure which is returned.

+ */

+int

+xpmParseData(

+    xpmData	*data,

+    XpmImage	*image,

+    XpmInfo	*info)

+{

+    /* variables to return */

+    unsigned int width, height, ncolors, cpp;

+    unsigned int x_hotspot, y_hotspot, hotspot = 0, extensions = 0;

+    XpmColor *colorTable = NULL;

+    unsigned int *pixelindex = NULL;

+    char *hints_cmt = NULL;

+    char *colors_cmt = NULL;

+    char *pixels_cmt = NULL;

+

+    unsigned int cmts;

+    int ErrorStatus;

+    xpmHashTable hashtable;

+

+    cmts = info && (info->valuemask & XpmReturnComments);

+

+    /*

+     * parse the header

+     */

+    ErrorStatus = xpmParseHeader(data);

+    if (ErrorStatus != XpmSuccess)

+	return (ErrorStatus);

+

+    /*

+     * read values

+     */

+    ErrorStatus = xpmParseValues(data, &width, &height, &ncolors, &cpp,

+				 &x_hotspot, &y_hotspot, &hotspot,

+				 &extensions);

+    if (ErrorStatus != XpmSuccess)

+	return (ErrorStatus);

+

+    /*

+     * store the hints comment line

+     */

+    if (cmts)

+	xpmGetCmt(data, &hints_cmt);

+

+    /*

+     * init the hashtable

+     */

+    if (USE_HASHTABLE) {

+	ErrorStatus = xpmHashTableInit(&hashtable);

+	if (ErrorStatus != XpmSuccess)

+	    RETURN(ErrorStatus);

+    }

+

+    /*

+     * read colors

+     */

+    ErrorStatus = xpmParseColors(data, ncolors, cpp, &colorTable, &hashtable);

+    if (ErrorStatus != XpmSuccess) {

+	if (USE_HASHTABLE)

+	    xpmHashTableFree(&hashtable);

+	RETURN(ErrorStatus);

+    }

+

+    /*

+     * store the colors comment line

+     */

+    if (cmts)

+	xpmGetCmt(data, &colors_cmt);

+

+    /*

+     * read pixels and index them on color number

+     */

+    ErrorStatus = ParsePixels(data, width, height, ncolors, cpp, colorTable,

+			      &hashtable, &pixelindex);

+

+    /*

+     * free the hastable

+     */

+    if (USE_HASHTABLE)

+	xpmHashTableFree(&hashtable);

+

+    if (ErrorStatus != XpmSuccess)

+	RETURN(ErrorStatus);

+

+    /*

+     * store the pixels comment line

+     */

+    if (cmts)

+	xpmGetCmt(data, &pixels_cmt);

+

+    /*

+     * parse extensions

+     */

+    if (info && (info->valuemask & XpmReturnExtensions)) {

+	if (extensions) {

+	    ErrorStatus = xpmParseExtensions(data, &info->extensions,

+					     &info->nextensions);

+	    if (ErrorStatus != XpmSuccess)

+		RETURN(ErrorStatus);

+	} else {

+	    info->extensions = NULL;

+	    info->nextensions = 0;

+	}

+    }

+

+    /*

+     * store found informations in the XpmImage structure

+     */

+    image->width = width;

+    image->height = height;

+    image->cpp = cpp;

+    image->ncolors = ncolors;

+    image->colorTable = colorTable;

+    image->data = pixelindex;

+

+    if (info) {

+	if (cmts) {

+	    info->hints_cmt = hints_cmt;

+	    info->colors_cmt = colors_cmt;

+	    info->pixels_cmt = pixels_cmt;

+	}

+	if (hotspot) {

+	    info->x_hotspot = x_hotspot;

+	    info->y_hotspot = y_hotspot;

+	    info->valuemask |= XpmHotspot;

+	}

+    }

+    return (XpmSuccess);

+

+/* exit point in case of error, free only locally allocated variables */

+error:

+    if (colorTable)

+	xpmFreeColorTable(colorTable, ncolors);

+    if (pixelindex)

+	XpmFree(pixelindex);

+    if (hints_cmt)

+	XpmFree(hints_cmt);

+    if (colors_cmt)

+	XpmFree(colors_cmt);

+    if (pixels_cmt)

+	XpmFree(pixels_cmt);

+

+    return(ErrorStatus);

+}

diff --git a/libXpm/src/scan.c b/libXpm/src/scan.c
index d2780a1ee..13c30759b 100644
--- a/libXpm/src/scan.c
+++ b/libXpm/src/scan.c
@@ -1,1024 +1,1024 @@
-/*
- * Copyright (C) 1989-95 GROUPE BULL
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of GROUPE BULL shall not be
- * used in advertising or otherwise to promote the sale, use or other dealings
- * in this Software without prior written authorization from GROUPE BULL.
- */
-
-/*****************************************************************************\
-* scan.c:                                                                     *
-*                                                                             *
-*  XPM library                                                                *
-*  Scanning utility for XPM file format                                       *
-*                                                                             *
-*  Developed by Arnaud Le Hors                                                *
-\*****************************************************************************/
-
-/*
- * The code related to FOR_MSW has been added by
- * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
- */
-
-/*
- * The code related to AMIGA has been added by
- * Lorens Younes (d93-hyo@nada.kth.se) 4/96
- */
-
-/* October 2004, source code review by Thomas Biege <thomas@suse.de> */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "XpmI.h"
-
-#define MAXPRINTABLE 92			/* number of printable ascii chars
-					 * minus \ and " for string compat
-					 * and ? to avoid ANSI trigraphs. */
-
-static char *printable =
-" .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjklzxcvbnmMNBVCZ\
-ASDFGHJKLPIUYTREWQ!~^/()_`'][{}|";
-
-/*
- * printable begin with a space, so in most case, due to my algorithm, when
- * the number of different colors is less than MAXPRINTABLE, it will give a
- * char follow by "nothing" (a space) in the readable xpm file
- */
-
-
-typedef struct {
-    Pixel *pixels;
-    unsigned int *pixelindex;
-    unsigned int size;
-    unsigned int ncolors;
-    unsigned int mask_pixel;		/* whether there is or not */
-}      PixelsMap;
-
-LFUNC(storePixel, int, (Pixel pixel, PixelsMap *pmap,
-			unsigned int *index_return));
-
-LFUNC(storeMaskPixel, int, (Pixel pixel, PixelsMap *pmap,
-			    unsigned int *index_return));
-
-typedef int (*storeFuncPtr)(Pixel pixel, PixelsMap *pmap,
-			    unsigned int *index_return);
-
-#ifndef FOR_MSW
-# ifndef AMIGA
-LFUNC(GetImagePixels, int, (XImage *image, unsigned int width,
-			    unsigned int height, PixelsMap *pmap));
-
-LFUNC(GetImagePixels32, int, (XImage *image, unsigned int width,
-			      unsigned int height, PixelsMap *pmap));
-
-LFUNC(GetImagePixels16, int, (XImage *image, unsigned int width,
-			      unsigned int height, PixelsMap *pmap));
-
-LFUNC(GetImagePixels8, int, (XImage *image, unsigned int width,
-			     unsigned int height, PixelsMap *pmap));
-
-LFUNC(GetImagePixels1, int, (XImage *image, unsigned int width,
-			     unsigned int height, PixelsMap *pmap,
-			     storeFuncPtr storeFunc));
-# else /* AMIGA */
-LFUNC(AGetImagePixels, int, (XImage *image, unsigned int width,
-			     unsigned int height, PixelsMap *pmap,
-			     storeFuncPtr storeFunc));
-# endif/* AMIGA */
-#else  /* ndef FOR_MSW */
-LFUNC(MSWGetImagePixels, int, (Display *d, XImage *image, unsigned int width,
-			       unsigned int height, PixelsMap *pmap,
-			       storeFuncPtr storeFunc));
-#endif
-LFUNC(ScanTransparentColor, int, (XpmColor *color, unsigned int cpp,
-				  XpmAttributes *attributes));
-
-LFUNC(ScanOtherColors, int, (Display *display, XpmColor *colors, 
-			     unsigned int ncolors, 
-			     Pixel *pixels, unsigned int mask,
-			     unsigned int cpp, XpmAttributes *attributes));
-
-/*
- * This function stores the given pixel in the given arrays which are grown
- * if not large enough.
- */
-static int
-storePixel(
-    Pixel		 pixel,
-    PixelsMap		*pmap,
-    unsigned int	*index_return)
-{
-    unsigned int i;
-    Pixel *p;
-    unsigned int ncolors;
-
-    if (*index_return) {		/* this is a transparent pixel! */
-	*index_return = 0;
-	return 0;
-    }
-    ncolors = pmap->ncolors;
-    p = pmap->pixels + pmap->mask_pixel;
-    for (i = pmap->mask_pixel; i < ncolors; i++, p++)
-	if (*p == pixel)
-	    break;
-    if (i == ncolors) {
-	if (ncolors >= pmap->size) {
-	    pmap->size *= 2;
-	    p = (Pixel *) XpmRealloc(pmap->pixels, sizeof(Pixel) * pmap->size);
-	    if (!p)
-		return (1);
-	    pmap->pixels = p;
-
-	}
-	(pmap->pixels)[ncolors] = pixel;
-	pmap->ncolors++;
-    }
-    *index_return = i;
-    return 0;
-}
-
-static int
-storeMaskPixel(
-    Pixel		 pixel,
-    PixelsMap		*pmap,
-    unsigned int	*index_return)
-{
-    if (!pixel) {
-	if (!pmap->ncolors) {
-	    pmap->ncolors = 1;
-	    (pmap->pixels)[0] = 0;
-	    pmap->mask_pixel = 1;
-	}
-	*index_return = 1;
-    } else
-	*index_return = 0;
-    return 0;
-}
-
-/* function call in case of error */
-#undef RETURN
-#define RETURN(status) \
-do { \
-      ErrorStatus = status; \
-      goto error; \
-} while(0)
-
-/*
- * This function scans the given image and stores the found informations in
- * the given XpmImage structure.
- */
-int
-XpmCreateXpmImageFromImage(
-    Display		*display,
-    XImage		*image,
-    XImage		*shapeimage,
-    XpmImage		*xpmimage,
-    XpmAttributes	*attributes)
-{
-    /* variables stored in the XpmAttributes structure */
-    unsigned int cpp;
-
-    /* variables to return */
-    PixelsMap pmap;
-    XpmColor *colorTable = NULL;
-    int ErrorStatus = 0;
-
-    /* calculation variables */
-    unsigned int width = 0;
-    unsigned int height = 0;
-    unsigned int cppm;			/* minimum chars per pixel */
-    unsigned int c;
-
-    /* initialize pmap */
-    pmap.pixels = NULL;
-    pmap.pixelindex = NULL;
-    pmap.size = 256;			/* should be enough most of the time */
-    pmap.ncolors = 0;
-    pmap.mask_pixel = 0;
-
-    /*
-     * get geometry
-     */
-    if (image) {
-	width = image->width;
-	height = image->height;
-    } else if (shapeimage) {
-	width = shapeimage->width;
-	height = shapeimage->height;
-    }
-
-    /*
-     * retrieve information from the XpmAttributes
-     */
-    if (attributes && (attributes->valuemask & XpmCharsPerPixel
-/* 3.2 backward compatibility code */
-		       || attributes->valuemask & XpmInfos))
-/* end 3.2 bc */
-	cpp = attributes->cpp;
-    else
-	cpp = 0;
-
-    if ((height > 0 && width >= UINT_MAX / height) ||
-	width * height >= UINT_MAX / sizeof(unsigned int))
-	RETURN(XpmNoMemory);
-    pmap.pixelindex =
-	(unsigned int *) XpmCalloc(width * height, sizeof(unsigned int));
-    if (!pmap.pixelindex)
-	RETURN(XpmNoMemory);
-
-    if (pmap.size >= UINT_MAX / sizeof(Pixel)) 
-	RETURN(XpmNoMemory);
-
-    pmap.pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * pmap.size);
-    if (!pmap.pixels)
-	RETURN(XpmNoMemory);
-
-    /*
-     * scan shape mask if any
-     */
-    if (shapeimage) {
-#ifndef FOR_MSW
-# ifndef AMIGA
-	ErrorStatus = GetImagePixels1(shapeimage, width, height, &pmap,
-				      storeMaskPixel);
-# else
-	ErrorStatus = AGetImagePixels(shapeimage, width, height, &pmap,
-				      storeMaskPixel);
-# endif
-#else
-	ErrorStatus = MSWGetImagePixels(display, shapeimage, width, height,
-					&pmap, storeMaskPixel);
-#endif
-	if (ErrorStatus != XpmSuccess)
-	    RETURN(ErrorStatus);
-    }
-
-    /*
-     * scan the image data
-     * 
-     * In case depth is 1 or bits_per_pixel is 4, 6, 8, 24 or 32 use optimized
-     * functions, otherwise use slower but sure general one.
-     * 
-     */
-
-    if (image) {
-#ifndef FOR_MSW
-# ifndef AMIGA
-	if (((image->bits_per_pixel | image->depth) == 1)  &&
-	    (image->byte_order == image->bitmap_bit_order))
-	    ErrorStatus = GetImagePixels1(image, width, height, &pmap,
-					  storePixel);
-	else if (image->format == ZPixmap) {
-	    if (image->bits_per_pixel == 8)
-		ErrorStatus = GetImagePixels8(image, width, height, &pmap);
-	    else if (image->bits_per_pixel == 16)
-		ErrorStatus = GetImagePixels16(image, width, height, &pmap);
-	    else if (image->bits_per_pixel == 32)
-		ErrorStatus = GetImagePixels32(image, width, height, &pmap);
-	} else
-	    ErrorStatus = GetImagePixels(image, width, height, &pmap);
-# else
-	ErrorStatus = AGetImagePixels(image, width, height, &pmap,
-				      storePixel);
-# endif
-#else
-	ErrorStatus = MSWGetImagePixels(display, image, width, height, &pmap,
-					storePixel);
-#endif
-	if (ErrorStatus != XpmSuccess)
-	    RETURN(ErrorStatus);
-    }
-
-    /*
-     * get rgb values and a string of char, and possibly a name for each
-     * color
-     */
-    if (pmap.ncolors >= UINT_MAX / sizeof(XpmColor))
-	RETURN(XpmNoMemory);
-    colorTable = (XpmColor *) XpmCalloc(pmap.ncolors, sizeof(XpmColor));
-    if (!colorTable)
-	RETURN(XpmNoMemory);
-
-    /* compute the minimal cpp */
-    for (cppm = 1, c = MAXPRINTABLE; pmap.ncolors > c; cppm++)
-	c *= MAXPRINTABLE;
-    if (cpp < cppm)
-	cpp = cppm;
-
-    if (pmap.mask_pixel) {
-	ErrorStatus = ScanTransparentColor(colorTable, cpp, attributes);
-	if (ErrorStatus != XpmSuccess)
-	    RETURN(ErrorStatus);
-    }
-
-    ErrorStatus = ScanOtherColors(display, colorTable, pmap.ncolors,
-				  pmap.pixels, pmap.mask_pixel, cpp,
-				  attributes);
-    if (ErrorStatus != XpmSuccess)
-	RETURN(ErrorStatus);
-
-    /*
-     * store found informations in the XpmImage structure
-     */
-    xpmimage->width = width;
-    xpmimage->height = height;
-    xpmimage->cpp = cpp;
-    xpmimage->ncolors = pmap.ncolors;
-    xpmimage->colorTable = colorTable;
-    xpmimage->data = pmap.pixelindex;
-
-    XpmFree(pmap.pixels);
-    return (XpmSuccess);
-
-/* exit point in case of error, free only locally allocated variables */
-error:
-    if (pmap.pixelindex)
-	XpmFree(pmap.pixelindex);
-    if (pmap.pixels)
-	XpmFree(pmap.pixels);
-    if (colorTable)
-	xpmFreeColorTable(colorTable, pmap.ncolors);
-
-    return (ErrorStatus);
-}
-
-static int
-ScanTransparentColor(
-    XpmColor		*color,
-    unsigned int	 cpp,
-    XpmAttributes	*attributes)
-{
-    char *s;
-    unsigned int a, b, c;
-
-    /* first get a character string */
-    a = 0;
-    if (cpp >= UINT_MAX - 1)
-	return (XpmNoMemory);
-    if (!(s = color->string = (char *) XpmMalloc(cpp + 1)))
-	return (XpmNoMemory);
-    *s++ = printable[c = a % MAXPRINTABLE];
-    for (b = 1; b < cpp; b++, s++)
-	*s = printable[c = ((a - c) / MAXPRINTABLE) % MAXPRINTABLE];
-    *s = '\0';
-
-    /* then retreive related info from the attributes if any */
-    if (attributes && (attributes->valuemask & XpmColorTable
-/* 3.2 backward compatibility code */
-		       || attributes->valuemask & XpmInfos)
-/* end 3.2 bc */
-	&& attributes->mask_pixel != XpmUndefPixel) {
-
-	unsigned int key;
-	char **defaults = (char **) color;
-	char **mask_defaults;
-
-/* 3.2 backward compatibility code */
-	if (attributes->valuemask & XpmColorTable)
-/* end 3.2 bc */
-	    mask_defaults = (char **) (
-		attributes->colorTable + attributes->mask_pixel);
-/* 3.2 backward compatibility code */
-	else
-	    mask_defaults = (char **)
-		((XpmColor **) attributes->colorTable)[attributes->mask_pixel];
-/* end 3.2 bc */
-	for (key = 1; key <= NKEYS; key++) {
-	    if ((s = mask_defaults[key])) {
-		defaults[key] = (char *) xpmstrdup(s);
-		if (!defaults[key])
-		    return (XpmNoMemory);
-	    }
-	}
-    } else {
-	color->c_color = (char *) xpmstrdup(TRANSPARENT_COLOR);
-	if (!color->c_color)
-	    return (XpmNoMemory);
-    }
-    return (XpmSuccess);
-}
-
-static int
-ScanOtherColors(
-    Display		*display,
-    XpmColor		*colors,
-    unsigned int	 ncolors,
-    Pixel		*pixels,
-    unsigned int	 mask,
-    unsigned int	 cpp,
-    XpmAttributes	*attributes)
-{
-    /* variables stored in the XpmAttributes structure */
-    Colormap colormap;
-    char *rgb_fname;
-
-#ifndef FOR_MSW
-    xpmRgbName rgbn[MAX_RGBNAMES];
-#else
-    xpmRgbName *rgbn = NULL; 
-#endif    
-    int rgbn_max = 0;
-    unsigned int i, j, c, i2;
-    XpmColor *color;
-    XColor *xcolors = NULL, *xcolor;
-    char *colorname, *s;
-    XpmColor *colorTable = NULL, **oldColorTable = NULL;
-    unsigned int ancolors = 0;
-    Pixel *apixels = NULL;
-    unsigned int mask_pixel = 0;
-    Bool found;
-
-    /* retrieve information from the XpmAttributes */
-    if (attributes && (attributes->valuemask & XpmColormap))
-	colormap = attributes->colormap;
-    else
-	colormap = XDefaultColormap(display, XDefaultScreen(display));
-    if (attributes && (attributes->valuemask & XpmRgbFilename))
-	rgb_fname = attributes->rgb_fname;
-    else
-	rgb_fname = NULL;
-
-    /* start from the right element */
-    if (mask) {
-	colors++;
-	ncolors--;
-	pixels++;
-    }
-
-    /* first get character strings and rgb values */
-    if (ncolors >= UINT_MAX / sizeof(XColor) || cpp >= UINT_MAX - 1)
-	return (XpmNoMemory);
-    xcolors = (XColor *) XpmMalloc(sizeof(XColor) * ncolors);
-    if (!xcolors)
-	return (XpmNoMemory);
-
-    for (i = 0, i2 = mask, color = colors, xcolor = xcolors;
-	 i < ncolors; i++, i2++, color++, xcolor++, pixels++) {
-
-	if (!(s = color->string = (char *) XpmMalloc(cpp + 1))) {
-	    XpmFree(xcolors);
-	    return (XpmNoMemory);
-	}
-	*s++ = printable[c = i2 % MAXPRINTABLE];
-	for (j = 1; j < cpp; j++, s++)
-	    *s = printable[c = ((i2 - c) / MAXPRINTABLE) % MAXPRINTABLE];
-	*s = '\0';
-
-	xcolor->pixel = *pixels;
-    }
-    XQueryColors(display, colormap, xcolors, ncolors);
-
-#ifndef FOR_MSW
-    /* read the rgb file if any was specified */
-    if (rgb_fname)
-	rgbn_max = xpmReadRgbNames(attributes->rgb_fname, rgbn);
-#else
-    /* FOR_MSW: rgb names and values are hardcoded in rgbtab.h */
-    rgbn_max = xpmReadRgbNames(NULL, NULL);
-#endif
-
-    if (attributes && attributes->valuemask & XpmColorTable) {
-	colorTable = attributes->colorTable;
-	ancolors = attributes->ncolors;
-	apixels = attributes->pixels;
-	mask_pixel = attributes->mask_pixel;
-    }
-/* 3.2 backward compatibility code */
-    else if (attributes && attributes->valuemask & XpmInfos) {
-	oldColorTable = (XpmColor **) attributes->colorTable;
-	ancolors = attributes->ncolors;
-	apixels = attributes->pixels;
-	mask_pixel = attributes->mask_pixel;
-    }
-/* end 3.2 bc */
-
-    for (i = 0, color = colors, xcolor = xcolors; i < ncolors;
-						  i++, color++, xcolor++) {
-
-	/* look for related info from the attributes if any */
-	found = False;
-	if (ancolors) {
-	    unsigned int offset = 0;
-
-	    for (j = 0; j < ancolors; j++) {
-		if (j == mask_pixel) {
-		    offset = 1;
-		    continue;
-		}
-		if (apixels[j - offset] == xcolor->pixel)
-		    break;
-	    }
-	    if (j != ancolors) {
-		unsigned int key;
-		char **defaults = (char **) color;
-		char **adefaults;
-
-/* 3.2 backward compatibility code */
-		if (oldColorTable)
-		    adefaults = (char **) oldColorTable[j];
-		else
-/* end 3.2 bc */
-		    adefaults = (char **) (colorTable + j);
-
-		found = True;
-		for (key = 1; key <= NKEYS; key++) {
-		    if ((s = adefaults[key]))
-			defaults[key] = (char *) xpmstrdup(s);
-		}
-	    }
-	}
-	if (!found) {
-	    /* if nothing found look for a color name */
-	    colorname = NULL;
-	    if (rgbn_max)
-		colorname = xpmGetRgbName(rgbn, rgbn_max, xcolor->red,
-					  xcolor->green, xcolor->blue);
-	    if (colorname)
-		color->c_color = (char *) xpmstrdup(colorname);
-	    else {
-		/* at last store the rgb value */
-		char buf[BUFSIZ];
-#ifndef FOR_MSW
-		sprintf(buf, "#%04X%04X%04X",
-			xcolor->red, xcolor->green, xcolor->blue);
-#else   
-		sprintf(buf, "#%02x%02x%02x",
-			xcolor->red, xcolor->green, xcolor->blue);
-#endif			
-		color->c_color = (char *) xpmstrdup(buf);
-	    }
-	    if (!color->c_color) {
-		XpmFree(xcolors);
-		xpmFreeRgbNames(rgbn, rgbn_max);
-		return (XpmNoMemory);
-	    }
-	}
-    }
-
-    XpmFree(xcolors);
-    xpmFreeRgbNames(rgbn, rgbn_max);
-    return (XpmSuccess);
-}
-
-#ifndef FOR_MSW
-# ifndef AMIGA
-/*
- * The functions below are written from X11R5 MIT's code (XImUtil.c)
- *
- * The idea is to have faster functions than the standard XGetPixel function
- * to scan the image data. Indeed we can speed up things by suppressing tests
- * performed for each pixel. We do exactly the same tests but at the image
- * level.
- */
-
-static unsigned long Const low_bits_table[] = {
-    0x00000000, 0x00000001, 0x00000003, 0x00000007,
-    0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
-    0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
-    0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
-    0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
-    0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
-    0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
-    0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
-    0xffffffff
-};
-
-/*
- * Default method to scan pixels of an image data structure.
- * The algorithm used is:
- *
- *	copy the source bitmap_unit or Zpixel into temp
- *	normalize temp if needed
- *	extract the pixel bits into return value
- *
- */
-
-static int
-GetImagePixels(
-    XImage		*image,
-    unsigned int	 width,
-    unsigned int	 height,
-    PixelsMap		*pmap)
-{
-    char *src;
-    char *dst;
-    unsigned int *iptr;
-    char *data;
-    unsigned int x, y;
-    int bits, depth, ibu, ibpp, offset, i;
-    unsigned long lbt;
-    Pixel pixel, px;
-
-    data = image->data;
-    iptr = pmap->pixelindex;
-    depth = image->depth;
-    lbt = low_bits_table[depth];
-    ibpp = image->bits_per_pixel;
-    offset = image->xoffset;
-
-    if (image->bitmap_unit < 0)
-	    return (XpmNoMemory);
-
-    if ((image->bits_per_pixel | image->depth) == 1) {
-	ibu = image->bitmap_unit;
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		src = &data[XYINDEX(x, y, image)];
-		dst = (char *) &pixel;
-		pixel = 0;
-		for (i = ibu >> 3; --i >= 0;)
-		    *dst++ = *src++;
-		XYNORMALIZE(&pixel, image);
-		bits = (x + offset) % ibu;
-		pixel = ((((char *) &pixel)[bits >> 3]) >> (bits & 7)) & 1;
-		if (ibpp != depth)
-		    pixel &= lbt;
-		if (storePixel(pixel, pmap, iptr))
-		    return (XpmNoMemory);
-	    }
-    } else if (image->format == XYPixmap) {
-	int nbytes, bpl, j;
-	long plane = 0;
-	ibu = image->bitmap_unit;
-	nbytes = ibu >> 3;
-	bpl = image->bytes_per_line;
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		pixel = 0;
-		plane = 0;
-		for (i = depth; --i >= 0;) {
-		    src = &data[XYINDEX(x, y, image) + plane];
-		    dst = (char *) &px;
-		    px = 0;
-		    for (j = nbytes; --j >= 0;)
-			*dst++ = *src++;
-		    XYNORMALIZE(&px, image);
-		    bits = (x + offset) % ibu;
-		    pixel = (pixel << 1) |
-			    (((((char *) &px)[bits >> 3]) >> (bits & 7)) & 1);
-		    plane = plane + (bpl * height);
-		}
-		if (ibpp != depth)
-		    pixel &= lbt;
-		if (storePixel(pixel, pmap, iptr))
-		    return (XpmNoMemory);
-	    }
-    } else if (image->format == ZPixmap) {
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		src = &data[ZINDEX(x, y, image)];
-		dst = (char *) &px;
-		px = 0;
-		for (i = (ibpp + 7) >> 3; --i >= 0;)
-		    *dst++ = *src++;
-		ZNORMALIZE(&px, image);
-		pixel = 0;
-		for (i = sizeof(unsigned long); --i >= 0;)
-		    pixel = (pixel << 8) | ((unsigned char *) &px)[i];
-		if (ibpp == 4) {
-		    if (x & 1)
-			pixel >>= 4;
-		    else
-			pixel &= 0xf;
-		}
-		if (ibpp != depth)
-		    pixel &= lbt;
-		if (storePixel(pixel, pmap, iptr))
-		    return (XpmNoMemory);
-	    }
-    } else
-	return (XpmColorError); /* actually a bad image */
-    return (XpmSuccess);
-}
-
-/*
- * scan pixels of a 32-bits Z image data structure
- */
-
-#if !defined(WORD64) && !defined(LONG64)
-static unsigned long byteorderpixel = MSBFirst << 24;
-#endif
-
-static int
-GetImagePixels32(
-    XImage		 *image,
-    unsigned int	 width,
-    unsigned int	 height,
-    PixelsMap		*pmap)
-{
-    unsigned char *addr;
-    unsigned char *data;
-    unsigned int *iptr;
-    unsigned int x, y;
-    unsigned long lbt;
-    Pixel pixel;
-    int depth;
-
-    data = (unsigned char *) image->data;
-    iptr = pmap->pixelindex;
-    depth = image->depth;
-    lbt = low_bits_table[depth];
-#if !defined(WORD64) && !defined(LONG64)
-    if (*((char *) &byteorderpixel) == image->byte_order) {
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		addr = &data[ZINDEX32(x, y, image)];
-		pixel = *((unsigned long *) addr);
-		if (depth != 32)
-		    pixel &= lbt;
-		if (storePixel(pixel, pmap, iptr))
-		    return (XpmNoMemory);
-	    }
-    } else
-#endif
-    if (image->byte_order == MSBFirst)
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		addr = &data[ZINDEX32(x, y, image)];
-		pixel = ((unsigned long) addr[0] << 24 |
-			 (unsigned long) addr[1] << 16 |
-			 (unsigned long) addr[2] << 8 |
-			 addr[3]);
-		if (depth != 32)
-		    pixel &= lbt;
-		if (storePixel(pixel, pmap, iptr))
-		    return (XpmNoMemory);
-	    }
-    else
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		addr = &data[ZINDEX32(x, y, image)];
-		pixel = (addr[0] |
-			 (unsigned long) addr[1] << 8 |
-			 (unsigned long) addr[2] << 16 |
-			 (unsigned long) addr[3] << 24);
-		if (depth != 32)
-		    pixel &= lbt;
-		if (storePixel(pixel, pmap, iptr))
-		    return (XpmNoMemory);
-	    }
-    return (XpmSuccess);
-}
-
-/*
- * scan pixels of a 16-bits Z image data structure
- */
-
-static int
-GetImagePixels16(
-    XImage		*image,
-    unsigned int	 width,
-    unsigned int	 height,
-    PixelsMap		*pmap)
-{
-    unsigned char *addr;
-    unsigned char *data;
-    unsigned int *iptr;
-    unsigned int x, y;
-    unsigned long lbt;
-    Pixel pixel;
-    int depth;
-
-    data = (unsigned char *) image->data;
-    iptr = pmap->pixelindex;
-    depth = image->depth;
-    lbt = low_bits_table[depth];
-    if (image->byte_order == MSBFirst)
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		addr = &data[ZINDEX16(x, y, image)];
-		pixel = addr[0] << 8 | addr[1];
-		if (depth != 16)
-		    pixel &= lbt;
-		if (storePixel(pixel, pmap, iptr))
-		    return (XpmNoMemory);
-	    }
-    else
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		addr = &data[ZINDEX16(x, y, image)];
-		pixel = addr[0] | addr[1] << 8;
-		if (depth != 16)
-		    pixel &= lbt;
-		if (storePixel(pixel, pmap, iptr))
-		    return (XpmNoMemory);
-	    }
-    return (XpmSuccess);
-}
-
-/*
- * scan pixels of a 8-bits Z image data structure
- */
-
-static int
-GetImagePixels8(
-    XImage		*image,
-    unsigned int	 width,
-    unsigned int	 height,
-    PixelsMap		*pmap)
-{
-    unsigned int *iptr;
-    unsigned char *data;
-    unsigned int x, y;
-    unsigned long lbt;
-    Pixel pixel;
-    int depth;
-
-    data = (unsigned char *) image->data;
-    iptr = pmap->pixelindex;
-    depth = image->depth;
-    lbt = low_bits_table[depth];
-    for (y = 0; y < height; y++)
-	for (x = 0; x < width; x++, iptr++) {
-	    pixel = data[ZINDEX8(x, y, image)];
-	    if (depth != 8)
-		pixel &= lbt;
-	    if (storePixel(pixel, pmap, iptr))
-		return (XpmNoMemory);
-	}
-    return (XpmSuccess);
-}
-
-/*
- * scan pixels of a 1-bit depth Z image data structure
- */
-
-static int
-GetImagePixels1(
-    XImage		*image,
-    unsigned int	 width,
-    unsigned int	 height,
-    PixelsMap		 *pmap,
-    storeFuncPtr	 storeFunc)
-{
-    unsigned int *iptr;
-    unsigned int x, y;
-    char *data;
-    Pixel pixel;
-    int xoff, yoff, offset, bpl;
-
-    data = image->data;
-    iptr = pmap->pixelindex;
-    offset = image->xoffset;
-    bpl = image->bytes_per_line;
-
-    if (image->bitmap_bit_order == MSBFirst)
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		xoff = x + offset;
-		yoff = y * bpl + (xoff >> 3);
-		xoff &= 7;
-		pixel = (data[yoff] & (0x80 >> xoff)) ? 1 : 0;
-		if ((*storeFunc) (pixel, pmap, iptr))
-		    return (XpmNoMemory);
-	    }
-    else
-	for (y = 0; y < height; y++)
-	    for (x = 0; x < width; x++, iptr++) {
-		xoff = x + offset;
-		yoff = y * bpl + (xoff >> 3);
-		xoff &= 7;
-		pixel = (data[yoff] & (1 << xoff)) ? 1 : 0;
-		if ((*storeFunc) (pixel, pmap, iptr))
-		    return (XpmNoMemory);
-	    }
-    return (XpmSuccess);
-}
-
-# else /* AMIGA */
-
-#define CLEAN_UP(status) \
-do {\
-    if (pixels) XpmFree (pixels);\
-    if (tmp_img) FreeXImage (tmp_img);\
-    return (status);\
-} while(0)
-
-static int
-AGetImagePixels (
-    XImage        *image,
-    unsigned int   width,
-    unsigned int   height,
-    PixelsMap     *pmap,
-    int          (*storeFunc) (Pixel, PixelsMap *, unsigned int *))
-{
-    unsigned int   *iptr;
-    unsigned int    x, y;
-    unsigned char  *pixels;
-    XImage         *tmp_img;
-    
-    pixels = XpmMalloc ((((width+15)>>4)<<4)*sizeof (*pixels));
-    if (pixels == NULL)
-	return XpmNoMemory;
-    
-    tmp_img = AllocXImage ((((width+15)>>4)<<4), 1, image->rp->BitMap->Depth);
-    if (tmp_img == NULL)
-	CLEAN_UP (XpmNoMemory);
-    
-    iptr = pmap->pixelindex;
-    for (y = 0; y < height; ++y)
-    {
-	ReadPixelLine8 (image->rp, 0, y, width, pixels, tmp_img->rp);
-	for (x = 0; x < width; ++x, ++iptr)
-	{
-	    if ((*storeFunc) (pixels[x], pmap, iptr))
-		CLEAN_UP (XpmNoMemory);
-	}
-    }
-    
-    CLEAN_UP (XpmSuccess);
-}
-
-#undef CLEAN_UP
-
-# endif/* AMIGA */
-#else  /* ndef FOR_MSW */
-static int
-MSWGetImagePixels(
-    Display	 *display,
-    XImage	 *image,
-    unsigned int  width,
-    unsigned int  height,
-    PixelsMap	 *pmap,
-    int		(*storeFunc) (Pixel, PixelsMap*, unsigned int *))
-{
-    unsigned int *iptr;
-    unsigned int x, y;
-    Pixel pixel;
-
-    iptr = pmap->pixelindex;
-
-    SelectObject(*display, image->bitmap);
-    for (y = 0; y < height; y++) {
-	for (x = 0; x < width; x++, iptr++) {
-	    pixel = GetPixel(*display, x, y);
-	    if ((*storeFunc) (pixel, pmap, iptr))
-		return (XpmNoMemory);
-	}
-    }
-    return (XpmSuccess);
-}
-
-#endif
-
-#ifndef FOR_MSW
-# ifndef AMIGA
-int
-XpmCreateXpmImageFromPixmap(
-    Display		*display,
-    Pixmap		 pixmap,
-    Pixmap		 shapemask,
-    XpmImage		*xpmimage,
-    XpmAttributes	*attributes)
-{
-    XImage *ximage = NULL;
-    XImage *shapeimage = NULL;
-    unsigned int width = 0;
-    unsigned int height = 0;
-    int ErrorStatus;
-
-    /* get geometry */
-    if (attributes && attributes->valuemask & XpmSize) {
-	width = attributes->width;
-	height = attributes->height;
-    }
-    /* get the ximages */
-    if (pixmap)
-	xpmCreateImageFromPixmap(display, pixmap, &ximage, &width, &height);
-    if (shapemask)
-	xpmCreateImageFromPixmap(display, shapemask, &shapeimage,
-				 &width, &height);
-
-    /* create the related XpmImage */
-    ErrorStatus = XpmCreateXpmImageFromImage(display, ximage, shapeimage,
-					     xpmimage, attributes);
-
-    /* destroy the ximages */
-    if (ximage)
-	XDestroyImage(ximage);
-    if (shapeimage)
-	XDestroyImage(shapeimage);
-
-    return (ErrorStatus);
-}
-
-# endif/* not AMIGA */
-#endif /* ndef FOR_MSW */
+/*

+ * Copyright (C) 1989-95 GROUPE BULL

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to

+ * deal in the Software without restriction, including without limitation the

+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

+ * sell copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * Except as contained in this notice, the name of GROUPE BULL shall not be

+ * used in advertising or otherwise to promote the sale, use or other dealings

+ * in this Software without prior written authorization from GROUPE BULL.

+ */

+

+/*****************************************************************************\

+* scan.c:                                                                     *

+*                                                                             *

+*  XPM library                                                                *

+*  Scanning utility for XPM file format                                       *

+*                                                                             *

+*  Developed by Arnaud Le Hors                                                *

+\*****************************************************************************/

+

+/*

+ * The code related to FOR_MSW has been added by

+ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94

+ */

+

+/*

+ * The code related to AMIGA has been added by

+ * Lorens Younes (d93-hyo@nada.kth.se) 4/96

+ */

+

+/* October 2004, source code review by Thomas Biege <thomas@suse.de> */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include "XpmI.h"

+

+#define MAXPRINTABLE 92			/* number of printable ascii chars

+					 * minus \ and " for string compat

+					 * and ? to avoid ANSI trigraphs. */

+

+static char *printable =

+" .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjklzxcvbnmMNBVCZ\

+ASDFGHJKLPIUYTREWQ!~^/()_`'][{}|";

+

+/*

+ * printable begin with a space, so in most case, due to my algorithm, when

+ * the number of different colors is less than MAXPRINTABLE, it will give a

+ * char follow by "nothing" (a space) in the readable xpm file

+ */

+

+

+typedef struct {

+    Pixel *pixels;

+    unsigned int *pixelindex;

+    unsigned int size;

+    unsigned int ncolors;

+    unsigned int mask_pixel;		/* whether there is or not */

+}      PixelsMap;

+

+LFUNC(storePixel, int, (Pixel pixel, PixelsMap *pmap,

+			unsigned int *index_return));

+

+LFUNC(storeMaskPixel, int, (Pixel pixel, PixelsMap *pmap,

+			    unsigned int *index_return));

+

+typedef int (*storeFuncPtr)(Pixel pixel, PixelsMap *pmap,

+			    unsigned int *index_return);

+

+#ifndef FOR_MSW

+# ifndef AMIGA

+LFUNC(GetImagePixels, int, (XImage *image, unsigned int width,

+			    unsigned int height, PixelsMap *pmap));

+

+LFUNC(GetImagePixels32, int, (XImage *image, unsigned int width,

+			      unsigned int height, PixelsMap *pmap));

+

+LFUNC(GetImagePixels16, int, (XImage *image, unsigned int width,

+			      unsigned int height, PixelsMap *pmap));

+

+LFUNC(GetImagePixels8, int, (XImage *image, unsigned int width,

+			     unsigned int height, PixelsMap *pmap));

+

+LFUNC(GetImagePixels1, int, (XImage *image, unsigned int width,

+			     unsigned int height, PixelsMap *pmap,

+			     storeFuncPtr storeFunc));

+# else /* AMIGA */

+LFUNC(AGetImagePixels, int, (XImage *image, unsigned int width,

+			     unsigned int height, PixelsMap *pmap,

+			     storeFuncPtr storeFunc));

+# endif/* AMIGA */

+#else  /* ndef FOR_MSW */

+LFUNC(MSWGetImagePixels, int, (Display *d, XImage *image, unsigned int width,

+			       unsigned int height, PixelsMap *pmap,

+			       storeFuncPtr storeFunc));

+#endif

+LFUNC(ScanTransparentColor, int, (XpmColor *color, unsigned int cpp,

+				  XpmAttributes *attributes));

+

+LFUNC(ScanOtherColors, int, (Display *display, XpmColor *colors, 

+			     unsigned int ncolors, 

+			     Pixel *pixels, unsigned int mask,

+			     unsigned int cpp, XpmAttributes *attributes));

+

+/*

+ * This function stores the given pixel in the given arrays which are grown

+ * if not large enough.

+ */

+static int

+storePixel(

+    Pixel		 pixel,

+    PixelsMap		*pmap,

+    unsigned int	*index_return)

+{

+    unsigned int i;

+    Pixel *p;

+    unsigned int ncolors;

+

+    if (*index_return) {		/* this is a transparent pixel! */

+	*index_return = 0;

+	return 0;

+    }

+    ncolors = pmap->ncolors;

+    p = pmap->pixels + pmap->mask_pixel;

+    for (i = pmap->mask_pixel; i < ncolors; i++, p++)

+	if (*p == pixel)

+	    break;

+    if (i == ncolors) {

+	if (ncolors >= pmap->size) {

+	    pmap->size *= 2;

+	    p = (Pixel *) XpmRealloc(pmap->pixels, sizeof(Pixel) * pmap->size);

+	    if (!p)

+		return (1);

+	    pmap->pixels = p;

+

+	}

+	(pmap->pixels)[ncolors] = pixel;

+	pmap->ncolors++;

+    }

+    *index_return = i;

+    return 0;

+}

+

+static int

+storeMaskPixel(

+    Pixel		 pixel,

+    PixelsMap		*pmap,

+    unsigned int	*index_return)

+{

+    if (!pixel) {

+	if (!pmap->ncolors) {

+	    pmap->ncolors = 1;

+	    (pmap->pixels)[0] = 0;

+	    pmap->mask_pixel = 1;

+	}

+	*index_return = 1;

+    } else

+	*index_return = 0;

+    return 0;

+}

+

+/* function call in case of error */

+#undef RETURN

+#define RETURN(status) \

+do { \

+      ErrorStatus = status; \

+      goto error; \

+} while(0)

+

+/*

+ * This function scans the given image and stores the found informations in

+ * the given XpmImage structure.

+ */

+int

+XpmCreateXpmImageFromImage(

+    Display		*display,

+    XImage		*image,

+    XImage		*shapeimage,

+    XpmImage		*xpmimage,

+    XpmAttributes	*attributes)

+{

+    /* variables stored in the XpmAttributes structure */

+    unsigned int cpp;

+

+    /* variables to return */

+    PixelsMap pmap;

+    XpmColor *colorTable = NULL;

+    int ErrorStatus = 0;

+

+    /* calculation variables */

+    unsigned int width = 0;

+    unsigned int height = 0;

+    unsigned int cppm;			/* minimum chars per pixel */

+    unsigned int c;

+

+    /* initialize pmap */

+    pmap.pixels = NULL;

+    pmap.pixelindex = NULL;

+    pmap.size = 256;			/* should be enough most of the time */

+    pmap.ncolors = 0;

+    pmap.mask_pixel = 0;

+

+    /*

+     * get geometry

+     */

+    if (image) {

+	width = image->width;

+	height = image->height;

+    } else if (shapeimage) {

+	width = shapeimage->width;

+	height = shapeimage->height;

+    }

+

+    /*

+     * retrieve information from the XpmAttributes

+     */

+    if (attributes && (attributes->valuemask & XpmCharsPerPixel

+/* 3.2 backward compatibility code */

+		       || attributes->valuemask & XpmInfos))

+/* end 3.2 bc */

+	cpp = attributes->cpp;

+    else

+	cpp = 0;

+

+    if ((height > 0 && width >= UINT_MAX / height) ||

+	width * height >= UINT_MAX / sizeof(unsigned int))

+	RETURN(XpmNoMemory);

+    pmap.pixelindex =

+	(unsigned int *) XpmCalloc(width * height, sizeof(unsigned int));

+    if (!pmap.pixelindex)

+	RETURN(XpmNoMemory);

+

+    if (pmap.size >= UINT_MAX / sizeof(Pixel)) 

+	RETURN(XpmNoMemory);

+

+    pmap.pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * pmap.size);

+    if (!pmap.pixels)

+	RETURN(XpmNoMemory);

+

+    /*

+     * scan shape mask if any

+     */

+    if (shapeimage) {

+#ifndef FOR_MSW

+# ifndef AMIGA

+	ErrorStatus = GetImagePixels1(shapeimage, width, height, &pmap,

+				      storeMaskPixel);

+# else

+	ErrorStatus = AGetImagePixels(shapeimage, width, height, &pmap,

+				      storeMaskPixel);

+# endif

+#else

+	ErrorStatus = MSWGetImagePixels(display, shapeimage, width, height,

+					&pmap, storeMaskPixel);

+#endif

+	if (ErrorStatus != XpmSuccess)

+	    RETURN(ErrorStatus);

+    }

+

+    /*

+     * scan the image data

+     * 

+     * In case depth is 1 or bits_per_pixel is 4, 6, 8, 24 or 32 use optimized

+     * functions, otherwise use slower but sure general one.

+     * 

+     */

+

+    if (image) {

+#ifndef FOR_MSW

+# ifndef AMIGA

+	if (((image->bits_per_pixel | image->depth) == 1)  &&

+	    (image->byte_order == image->bitmap_bit_order))

+	    ErrorStatus = GetImagePixels1(image, width, height, &pmap,

+					  storePixel);

+	else if (image->format == ZPixmap) {

+	    if (image->bits_per_pixel == 8)

+		ErrorStatus = GetImagePixels8(image, width, height, &pmap);

+	    else if (image->bits_per_pixel == 16)

+		ErrorStatus = GetImagePixels16(image, width, height, &pmap);

+	    else if (image->bits_per_pixel == 32)

+		ErrorStatus = GetImagePixels32(image, width, height, &pmap);

+	} else

+	    ErrorStatus = GetImagePixels(image, width, height, &pmap);

+# else

+	ErrorStatus = AGetImagePixels(image, width, height, &pmap,

+				      storePixel);

+# endif

+#else

+	ErrorStatus = MSWGetImagePixels(display, image, width, height, &pmap,

+					storePixel);

+#endif

+	if (ErrorStatus != XpmSuccess)

+	    RETURN(ErrorStatus);

+    }

+

+    /*

+     * get rgb values and a string of char, and possibly a name for each

+     * color

+     */

+    if (pmap.ncolors >= UINT_MAX / sizeof(XpmColor))

+	RETURN(XpmNoMemory);

+    colorTable = (XpmColor *) XpmCalloc(pmap.ncolors, sizeof(XpmColor));

+    if (!colorTable)

+	RETURN(XpmNoMemory);

+

+    /* compute the minimal cpp */

+    for (cppm = 1, c = MAXPRINTABLE; pmap.ncolors > c; cppm++)

+	c *= MAXPRINTABLE;

+    if (cpp < cppm)

+	cpp = cppm;

+

+    if (pmap.mask_pixel) {

+	ErrorStatus = ScanTransparentColor(colorTable, cpp, attributes);

+	if (ErrorStatus != XpmSuccess)

+	    RETURN(ErrorStatus);

+    }

+

+    ErrorStatus = ScanOtherColors(display, colorTable, pmap.ncolors,

+				  pmap.pixels, pmap.mask_pixel, cpp,

+				  attributes);

+    if (ErrorStatus != XpmSuccess)

+	RETURN(ErrorStatus);

+

+    /*

+     * store found informations in the XpmImage structure

+     */

+    xpmimage->width = width;

+    xpmimage->height = height;

+    xpmimage->cpp = cpp;

+    xpmimage->ncolors = pmap.ncolors;

+    xpmimage->colorTable = colorTable;

+    xpmimage->data = pmap.pixelindex;

+

+    XpmFree(pmap.pixels);

+    return (XpmSuccess);

+

+/* exit point in case of error, free only locally allocated variables */

+error:

+    if (pmap.pixelindex)

+	XpmFree(pmap.pixelindex);

+    if (pmap.pixels)

+	XpmFree(pmap.pixels);

+    if (colorTable)

+	xpmFreeColorTable(colorTable, pmap.ncolors);

+

+    return (ErrorStatus);

+}

+

+static int

+ScanTransparentColor(

+    XpmColor		*color,

+    unsigned int	 cpp,

+    XpmAttributes	*attributes)

+{

+    char *s;

+    unsigned int a, b, c;

+

+    /* first get a character string */

+    a = 0;

+    if (cpp >= UINT_MAX - 1)

+	return (XpmNoMemory);

+    if (!(s = color->string = (char *) XpmMalloc(cpp + 1)))

+	return (XpmNoMemory);

+    *s++ = printable[c = a % MAXPRINTABLE];

+    for (b = 1; b < cpp; b++, s++)

+	*s = printable[c = ((a - c) / MAXPRINTABLE) % MAXPRINTABLE];

+    *s = '\0';

+

+    /* then retreive related info from the attributes if any */

+    if (attributes && (attributes->valuemask & XpmColorTable

+/* 3.2 backward compatibility code */

+		       || attributes->valuemask & XpmInfos)

+/* end 3.2 bc */

+	&& attributes->mask_pixel != XpmUndefPixel) {

+

+	unsigned int key;

+	char **defaults = (char **) color;

+	char **mask_defaults;

+

+/* 3.2 backward compatibility code */

+	if (attributes->valuemask & XpmColorTable)

+/* end 3.2 bc */

+	    mask_defaults = (char **) (

+		attributes->colorTable + attributes->mask_pixel);

+/* 3.2 backward compatibility code */

+	else

+	    mask_defaults = (char **)

+		((XpmColor **) attributes->colorTable)[attributes->mask_pixel];

+/* end 3.2 bc */

+	for (key = 1; key <= NKEYS; key++) {

+	    if ((s = mask_defaults[key])) {

+		defaults[key] = (char *) xpmstrdup(s);

+		if (!defaults[key])

+		    return (XpmNoMemory);

+	    }

+	}

+    } else {

+	color->c_color = (char *) xpmstrdup(TRANSPARENT_COLOR);

+	if (!color->c_color)

+	    return (XpmNoMemory);

+    }

+    return (XpmSuccess);

+}

+

+static int

+ScanOtherColors(

+    Display		*display,

+    XpmColor		*colors,

+    unsigned int	 ncolors,

+    Pixel		*pixels,

+    unsigned int	 mask,

+    unsigned int	 cpp,

+    XpmAttributes	*attributes)

+{

+    /* variables stored in the XpmAttributes structure */

+    Colormap colormap;

+    char *rgb_fname;

+

+#ifndef FOR_MSW

+    xpmRgbName rgbn[MAX_RGBNAMES];

+#else

+    xpmRgbName *rgbn = NULL; 

+#endif    

+    int rgbn_max = 0;

+    unsigned int i, j, c, i2;

+    XpmColor *color;

+    XColor *xcolors = NULL, *xcolor;

+    char *colorname, *s;

+    XpmColor *colorTable = NULL, **oldColorTable = NULL;

+    unsigned int ancolors = 0;

+    Pixel *apixels = NULL;

+    unsigned int mask_pixel = 0;

+    Bool found;

+

+    /* retrieve information from the XpmAttributes */

+    if (attributes && (attributes->valuemask & XpmColormap))

+	colormap = attributes->colormap;

+    else

+	colormap = XDefaultColormap(display, XDefaultScreen(display));

+    if (attributes && (attributes->valuemask & XpmRgbFilename))

+	rgb_fname = attributes->rgb_fname;

+    else

+	rgb_fname = NULL;

+

+    /* start from the right element */

+    if (mask) {

+	colors++;

+	ncolors--;

+	pixels++;

+    }

+

+    /* first get character strings and rgb values */

+    if (ncolors >= UINT_MAX / sizeof(XColor) || cpp >= UINT_MAX - 1)

+	return (XpmNoMemory);

+    xcolors = (XColor *) XpmMalloc(sizeof(XColor) * ncolors);

+    if (!xcolors)

+	return (XpmNoMemory);

+

+    for (i = 0, i2 = mask, color = colors, xcolor = xcolors;

+	 i < ncolors; i++, i2++, color++, xcolor++, pixels++) {

+

+	if (!(s = color->string = (char *) XpmMalloc(cpp + 1))) {

+	    XpmFree(xcolors);

+	    return (XpmNoMemory);

+	}

+	*s++ = printable[c = i2 % MAXPRINTABLE];

+	for (j = 1; j < cpp; j++, s++)

+	    *s = printable[c = ((i2 - c) / MAXPRINTABLE) % MAXPRINTABLE];

+	*s = '\0';

+

+	xcolor->pixel = *pixels;

+    }

+    XQueryColors(display, colormap, xcolors, ncolors);

+

+#ifndef FOR_MSW

+    /* read the rgb file if any was specified */

+    if (rgb_fname)

+	rgbn_max = xpmReadRgbNames(attributes->rgb_fname, rgbn);

+#else

+    /* FOR_MSW: rgb names and values are hardcoded in rgbtab.h */

+    rgbn_max = xpmReadRgbNames(NULL, NULL);

+#endif

+

+    if (attributes && attributes->valuemask & XpmColorTable) {

+	colorTable = attributes->colorTable;

+	ancolors = attributes->ncolors;

+	apixels = attributes->pixels;

+	mask_pixel = attributes->mask_pixel;

+    }

+/* 3.2 backward compatibility code */

+    else if (attributes && attributes->valuemask & XpmInfos) {

+	oldColorTable = (XpmColor **) attributes->colorTable;

+	ancolors = attributes->ncolors;

+	apixels = attributes->pixels;

+	mask_pixel = attributes->mask_pixel;

+    }

+/* end 3.2 bc */

+

+    for (i = 0, color = colors, xcolor = xcolors; i < ncolors;

+						  i++, color++, xcolor++) {

+

+	/* look for related info from the attributes if any */

+	found = False;

+	if (ancolors) {

+	    unsigned int offset = 0;

+

+	    for (j = 0; j < ancolors; j++) {

+		if (j == mask_pixel) {

+		    offset = 1;

+		    continue;

+		}

+		if (apixels[j - offset] == xcolor->pixel)

+		    break;

+	    }

+	    if (j != ancolors) {

+		unsigned int key;

+		char **defaults = (char **) color;

+		char **adefaults;

+

+/* 3.2 backward compatibility code */

+		if (oldColorTable)

+		    adefaults = (char **) oldColorTable[j];

+		else

+/* end 3.2 bc */

+		    adefaults = (char **) (colorTable + j);

+

+		found = True;

+		for (key = 1; key <= NKEYS; key++) {

+		    if ((s = adefaults[key]))

+			defaults[key] = (char *) xpmstrdup(s);

+		}

+	    }

+	}

+	if (!found) {

+	    /* if nothing found look for a color name */

+	    colorname = NULL;

+	    if (rgbn_max)

+		colorname = xpmGetRgbName(rgbn, rgbn_max, xcolor->red,

+					  xcolor->green, xcolor->blue);

+	    if (colorname)

+		color->c_color = (char *) xpmstrdup(colorname);

+	    else {

+		/* at last store the rgb value */

+		char buf[BUFSIZ];

+#ifndef FOR_MSW

+		sprintf(buf, "#%04X%04X%04X",

+			xcolor->red, xcolor->green, xcolor->blue);

+#else   

+		sprintf(buf, "#%02x%02x%02x",

+			xcolor->red, xcolor->green, xcolor->blue);

+#endif			

+		color->c_color = (char *) xpmstrdup(buf);

+	    }

+	    if (!color->c_color) {

+		XpmFree(xcolors);

+		xpmFreeRgbNames(rgbn, rgbn_max);

+		return (XpmNoMemory);

+	    }

+	}

+    }

+

+    XpmFree(xcolors);

+    xpmFreeRgbNames(rgbn, rgbn_max);

+    return (XpmSuccess);

+}

+

+#ifndef FOR_MSW

+# ifndef AMIGA

+/*

+ * The functions below are written from X11R5 MIT's code (XImUtil.c)

+ *

+ * The idea is to have faster functions than the standard XGetPixel function

+ * to scan the image data. Indeed we can speed up things by suppressing tests

+ * performed for each pixel. We do exactly the same tests but at the image

+ * level.

+ */

+

+static unsigned long Const low_bits_table[] = {

+    0x00000000, 0x00000001, 0x00000003, 0x00000007,

+    0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,

+    0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,

+    0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,

+    0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,

+    0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,

+    0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,

+    0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,

+    0xffffffff

+};

+

+/*

+ * Default method to scan pixels of an image data structure.

+ * The algorithm used is:

+ *

+ *	copy the source bitmap_unit or Zpixel into temp

+ *	normalize temp if needed

+ *	extract the pixel bits into return value

+ *

+ */

+

+static int

+GetImagePixels(

+    XImage		*image,

+    unsigned int	 width,

+    unsigned int	 height,

+    PixelsMap		*pmap)

+{

+    char *src;

+    char *dst;

+    unsigned int *iptr;

+    char *data;

+    unsigned int x, y;

+    int bits, depth, ibu, ibpp, offset, i;

+    unsigned long lbt;

+    Pixel pixel, px;

+

+    data = image->data;

+    iptr = pmap->pixelindex;

+    depth = image->depth;

+    lbt = low_bits_table[depth];

+    ibpp = image->bits_per_pixel;

+    offset = image->xoffset;

+

+    if (image->bitmap_unit < 0)

+	    return (XpmNoMemory);

+

+    if ((image->bits_per_pixel | image->depth) == 1) {

+	ibu = image->bitmap_unit;

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		src = &data[XYINDEX(x, y, image)];

+		dst = (char *) &pixel;

+		pixel = 0;

+		for (i = ibu >> 3; --i >= 0;)

+		    *dst++ = *src++;

+		XYNORMALIZE(&pixel, image);

+		bits = (x + offset) % ibu;

+		pixel = ((((char *) &pixel)[bits >> 3]) >> (bits & 7)) & 1;

+		if (ibpp != depth)

+		    pixel &= lbt;

+		if (storePixel(pixel, pmap, iptr))

+		    return (XpmNoMemory);

+	    }

+    } else if (image->format == XYPixmap) {

+	int nbytes, bpl, j;

+	long plane = 0;

+	ibu = image->bitmap_unit;

+	nbytes = ibu >> 3;

+	bpl = image->bytes_per_line;

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		pixel = 0;

+		plane = 0;

+		for (i = depth; --i >= 0;) {

+		    src = &data[XYINDEX(x, y, image) + plane];

+		    dst = (char *) &px;

+		    px = 0;

+		    for (j = nbytes; --j >= 0;)

+			*dst++ = *src++;

+		    XYNORMALIZE(&px, image);

+		    bits = (x + offset) % ibu;

+		    pixel = (pixel << 1) |

+			    (((((char *) &px)[bits >> 3]) >> (bits & 7)) & 1);

+		    plane = plane + (bpl * height);

+		}

+		if (ibpp != depth)

+		    pixel &= lbt;

+		if (storePixel(pixel, pmap, iptr))

+		    return (XpmNoMemory);

+	    }

+    } else if (image->format == ZPixmap) {

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		src = &data[ZINDEX(x, y, image)];

+		dst = (char *) &px;

+		px = 0;

+		for (i = (ibpp + 7) >> 3; --i >= 0;)

+		    *dst++ = *src++;

+		ZNORMALIZE(&px, image);

+		pixel = 0;

+		for (i = sizeof(unsigned long); --i >= 0;)

+		    pixel = (pixel << 8) | ((unsigned char *) &px)[i];

+		if (ibpp == 4) {

+		    if (x & 1)

+			pixel >>= 4;

+		    else

+			pixel &= 0xf;

+		}

+		if (ibpp != depth)

+		    pixel &= lbt;

+		if (storePixel(pixel, pmap, iptr))

+		    return (XpmNoMemory);

+	    }

+    } else

+	return (XpmColorError); /* actually a bad image */

+    return (XpmSuccess);

+}

+

+/*

+ * scan pixels of a 32-bits Z image data structure

+ */

+

+#if !defined(WORD64) && !defined(LONG64)

+static unsigned long byteorderpixel = MSBFirst << 24;

+#endif

+

+static int

+GetImagePixels32(

+    XImage		 *image,

+    unsigned int	 width,

+    unsigned int	 height,

+    PixelsMap		*pmap)

+{

+    unsigned char *addr;

+    unsigned char *data;

+    unsigned int *iptr;

+    unsigned int x, y;

+    unsigned long lbt;

+    Pixel pixel;

+    int depth;

+

+    data = (unsigned char *) image->data;

+    iptr = pmap->pixelindex;

+    depth = image->depth;

+    lbt = low_bits_table[depth];

+#if !defined(WORD64) && !defined(LONG64)

+    if (*((char *) &byteorderpixel) == image->byte_order) {

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		addr = &data[ZINDEX32(x, y, image)];

+		pixel = *((unsigned long *) addr);

+		if (depth != 32)

+		    pixel &= lbt;

+		if (storePixel(pixel, pmap, iptr))

+		    return (XpmNoMemory);

+	    }

+    } else

+#endif

+    if (image->byte_order == MSBFirst)

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		addr = &data[ZINDEX32(x, y, image)];

+		pixel = ((unsigned long) addr[0] << 24 |

+			 (unsigned long) addr[1] << 16 |

+			 (unsigned long) addr[2] << 8 |

+			 addr[3]);

+		if (depth != 32)

+		    pixel &= lbt;

+		if (storePixel(pixel, pmap, iptr))

+		    return (XpmNoMemory);

+	    }

+    else

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		addr = &data[ZINDEX32(x, y, image)];

+		pixel = (addr[0] |

+			 (unsigned long) addr[1] << 8 |

+			 (unsigned long) addr[2] << 16 |

+			 (unsigned long) addr[3] << 24);

+		if (depth != 32)

+		    pixel &= lbt;

+		if (storePixel(pixel, pmap, iptr))

+		    return (XpmNoMemory);

+	    }

+    return (XpmSuccess);

+}

+

+/*

+ * scan pixels of a 16-bits Z image data structure

+ */

+

+static int

+GetImagePixels16(

+    XImage		*image,

+    unsigned int	 width,

+    unsigned int	 height,

+    PixelsMap		*pmap)

+{

+    unsigned char *addr;

+    unsigned char *data;

+    unsigned int *iptr;

+    unsigned int x, y;

+    unsigned long lbt;

+    Pixel pixel;

+    int depth;

+

+    data = (unsigned char *) image->data;

+    iptr = pmap->pixelindex;

+    depth = image->depth;

+    lbt = low_bits_table[depth];

+    if (image->byte_order == MSBFirst)

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		addr = &data[ZINDEX16(x, y, image)];

+		pixel = addr[0] << 8 | addr[1];

+		if (depth != 16)

+		    pixel &= lbt;

+		if (storePixel(pixel, pmap, iptr))

+		    return (XpmNoMemory);

+	    }

+    else

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		addr = &data[ZINDEX16(x, y, image)];

+		pixel = addr[0] | addr[1] << 8;

+		if (depth != 16)

+		    pixel &= lbt;

+		if (storePixel(pixel, pmap, iptr))

+		    return (XpmNoMemory);

+	    }

+    return (XpmSuccess);

+}

+

+/*

+ * scan pixels of a 8-bits Z image data structure

+ */

+

+static int

+GetImagePixels8(

+    XImage		*image,

+    unsigned int	 width,

+    unsigned int	 height,

+    PixelsMap		*pmap)

+{

+    unsigned int *iptr;

+    unsigned char *data;

+    unsigned int x, y;

+    unsigned long lbt;

+    Pixel pixel;

+    int depth;

+

+    data = (unsigned char *) image->data;

+    iptr = pmap->pixelindex;

+    depth = image->depth;

+    lbt = low_bits_table[depth];

+    for (y = 0; y < height; y++)

+	for (x = 0; x < width; x++, iptr++) {

+	    pixel = data[ZINDEX8(x, y, image)];

+	    if (depth != 8)

+		pixel &= lbt;

+	    if (storePixel(pixel, pmap, iptr))

+		return (XpmNoMemory);

+	}

+    return (XpmSuccess);

+}

+

+/*

+ * scan pixels of a 1-bit depth Z image data structure

+ */

+

+static int

+GetImagePixels1(

+    XImage		*image,

+    unsigned int	 width,

+    unsigned int	 height,

+    PixelsMap		 *pmap,

+    storeFuncPtr	 storeFunc)

+{

+    unsigned int *iptr;

+    unsigned int x, y;

+    char *data;

+    Pixel pixel;

+    int xoff, yoff, offset, bpl;

+

+    data = image->data;

+    iptr = pmap->pixelindex;

+    offset = image->xoffset;

+    bpl = image->bytes_per_line;

+

+    if (image->bitmap_bit_order == MSBFirst)

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		xoff = x + offset;

+		yoff = y * bpl + (xoff >> 3);

+		xoff &= 7;

+		pixel = (data[yoff] & (0x80 >> xoff)) ? 1 : 0;

+		if ((*storeFunc) (pixel, pmap, iptr))

+		    return (XpmNoMemory);

+	    }

+    else

+	for (y = 0; y < height; y++)

+	    for (x = 0; x < width; x++, iptr++) {

+		xoff = x + offset;

+		yoff = y * bpl + (xoff >> 3);

+		xoff &= 7;

+		pixel = (data[yoff] & (1 << xoff)) ? 1 : 0;

+		if ((*storeFunc) (pixel, pmap, iptr))

+		    return (XpmNoMemory);

+	    }

+    return (XpmSuccess);

+}

+

+# else /* AMIGA */

+

+#define CLEAN_UP(status) \

+do {\

+    if (pixels) XpmFree (pixels);\

+    if (tmp_img) FreeXImage (tmp_img);\

+    return (status);\

+} while(0)

+

+static int

+AGetImagePixels (

+    XImage        *image,

+    unsigned int   width,

+    unsigned int   height,

+    PixelsMap     *pmap,

+    int          (*storeFunc) (Pixel, PixelsMap *, unsigned int *))

+{

+    unsigned int   *iptr;

+    unsigned int    x, y;

+    unsigned char  *pixels;

+    XImage         *tmp_img;

+    

+    pixels = XpmMalloc ((((width+15)>>4)<<4)*sizeof (*pixels));

+    if (pixels == NULL)

+	return XpmNoMemory;

+    

+    tmp_img = AllocXImage ((((width+15)>>4)<<4), 1, image->rp->BitMap->Depth);

+    if (tmp_img == NULL)

+	CLEAN_UP (XpmNoMemory);

+    

+    iptr = pmap->pixelindex;

+    for (y = 0; y < height; ++y)

+    {

+	ReadPixelLine8 (image->rp, 0, y, width, pixels, tmp_img->rp);

+	for (x = 0; x < width; ++x, ++iptr)

+	{

+	    if ((*storeFunc) (pixels[x], pmap, iptr))

+		CLEAN_UP (XpmNoMemory);

+	}

+    }

+    

+    CLEAN_UP (XpmSuccess);

+}

+

+#undef CLEAN_UP

+

+# endif/* AMIGA */

+#else  /* ndef FOR_MSW */

+static int

+MSWGetImagePixels(

+    Display	 *display,

+    XImage	 *image,

+    unsigned int  width,

+    unsigned int  height,

+    PixelsMap	 *pmap,

+    int		(*storeFunc) (Pixel, PixelsMap*, unsigned int *))

+{

+    unsigned int *iptr;

+    unsigned int x, y;

+    Pixel pixel;

+

+    iptr = pmap->pixelindex;

+

+    SelectObject(*display, image->bitmap);

+    for (y = 0; y < height; y++) {

+	for (x = 0; x < width; x++, iptr++) {

+	    pixel = GetPixel(*display, x, y);

+	    if ((*storeFunc) (pixel, pmap, iptr))

+		return (XpmNoMemory);

+	}

+    }

+    return (XpmSuccess);

+}

+

+#endif

+

+#ifndef FOR_MSW

+# ifndef AMIGA

+int

+XpmCreateXpmImageFromPixmap(

+    Display		*display,

+    Pixmap		 pixmap,

+    Pixmap		 shapemask,

+    XpmImage		*xpmimage,

+    XpmAttributes	*attributes)

+{

+    XImage *ximage = NULL;

+    XImage *shapeimage = NULL;

+    unsigned int width = 0;

+    unsigned int height = 0;

+    int ErrorStatus;

+

+    /* get geometry */

+    if (attributes && attributes->valuemask & XpmSize) {

+	width = attributes->width;

+	height = attributes->height;

+    }

+    /* get the ximages */

+    if (pixmap)

+	xpmCreateImageFromPixmap(display, pixmap, &ximage, &width, &height);

+    if (shapemask)

+	xpmCreateImageFromPixmap(display, shapemask, &shapeimage,

+				 &width, &height);

+

+    /* create the related XpmImage */

+    ErrorStatus = XpmCreateXpmImageFromImage(display, ximage, shapeimage,

+					     xpmimage, attributes);

+

+    /* destroy the ximages */

+    if (ximage)

+	XDestroyImage(ximage);

+    if (shapeimage)

+	XDestroyImage(shapeimage);

+

+    return (ErrorStatus);

+}

+

+# endif/* not AMIGA */

+#endif /* ndef FOR_MSW */