Synchronised line endinge with release branch

19 files changed, 8455 insertions, 8455 deletions

diff --git a/libXpm/COPYING b/libXpm/COPYING
index e5beea421..af4754912 100644
--- a/libXpm/COPYING
+++ b/libXpm/COPYING
@@ -1,70 +1,70 @@
-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.

-

-Copyright (C) 1998 Arnaud LE HORS

-

-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

-Arnaud LE HORS 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 Arnaud LE HORS shall not be

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

-in this Software without prior written authorization from Arnaud LE HORS.

-

-Copyright (C) 19896 Lorens Younes

-

-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

-Lorens Younes 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 Lorens Younes shall not be

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

-in this Software without prior written authorization from Lorens Younes.

-

-

+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.
+
+Copyright (C) 1998 Arnaud LE HORS
+
+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
+Arnaud LE HORS 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 Arnaud LE HORS shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from Arnaud LE HORS.
+
+Copyright (C) 19896 Lorens Younes
+
+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
+Lorens Younes 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 Lorens Younes shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from Lorens Younes.
+
+
diff --git a/libXpm/Makefile.am b/libXpm/Makefile.am
index 738a79883..a289a247e 100644
--- a/libXpm/Makefile.am
+++ b/libXpm/Makefile.am
@@ -1,23 +1,23 @@
-# Daniel Stone disowns all copyright on this file; no warranty is given as to its

-# suitability or otherwise.

-

-SUBDIRS = doc include src sxpm cxpm

-

-ACLOCAL_AMFLAGS = -I m4

-

-pkgconfigdir = $(libdir)/pkgconfig

-pkgconfig_DATA = xpm.pc

-

-EXTRA_DIST = COPYRIGHT NEWS.old

-

-MAINTAINERCLEANFILES = ChangeLog INSTALL

-

-.PHONY: ChangeLog INSTALL

-

-INSTALL:

-	$(INSTALL_CMD)

-

-ChangeLog:

-	$(CHANGELOG_CMD)

-

-dist-hook: ChangeLog INSTALL

+# Daniel Stone disowns all copyright on this file; no warranty is given as to its
+# suitability or otherwise.
+
+SUBDIRS = doc include src sxpm cxpm
+
+ACLOCAL_AMFLAGS = -I m4
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = xpm.pc
+
+EXTRA_DIST = COPYRIGHT NEWS.old
+
+MAINTAINERCLEANFILES = ChangeLog INSTALL
+
+.PHONY: ChangeLog INSTALL
+
+INSTALL:
+	$(INSTALL_CMD)
+
+ChangeLog:
+	$(CHANGELOG_CMD)
+
+dist-hook: ChangeLog INSTALL
diff --git a/libXpm/configure.ac b/libXpm/configure.ac
index 863229cae..057c056d6 100644
--- a/libXpm/configure.ac
+++ b/libXpm/configure.ac
@@ -1,69 +1,69 @@
-# Initialize Autoconf

-AC_PREREQ([2.60])

-AC_INIT([libXpm],

-        [3.5.9],

-        [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg],

-        [libXpm])

-AC_CONFIG_SRCDIR([Makefile.am])

-AC_CONFIG_MACRO_DIR([m4])

-AC_CONFIG_HEADERS([config.h])

-

-# Initialize Automake

-AM_INIT_AUTOMAKE([foreign dist-bzip2])

-AM_MAINTAINER_MODE

-

-# Initialize libtool

-AC_PROG_LIBTOOL

-

-# Require X.Org macros 1.8 or later for MAN_SUBSTS set by XORG_MANPAGE_SECTIONS

-m4_ifndef([XORG_MACROS_VERSION],

-          [m4_fatal([must install xorg-macros 1.8 or later before running autoconf/autogen])])

-XORG_MACROS_VERSION(1.8)

-XORG_DEFAULT_OPTIONS

-

-# Checks for library functions

-AC_CHECK_FUNCS([strlcat])

-

-# Obtain compiler/linker options for dependencies

-PKG_CHECK_MODULES(XPM, xproto x11)

-PKG_CHECK_MODULES(SXPM, xt xext xextproto, build_sxpm=true, build_sxpm=false)

-AM_CONDITIONAL(BUILD_SXPM, test x$build_sxpm = xtrue)

-

-# Internationalization & localization support

-AC_SEARCH_LIBS([gettext], [intl], [USE_GETTEXT="yes"], [USE_GETTEXT="no"])

-AC_MSG_CHECKING([where to install localized messages])

-AC_ARG_WITH([localedir], AS_HELP_STRING([--with-localedir=<path>],

-	[Path to install message files in (default: datadir/locale)]),

-	[LOCALEDIR=${withval}], [LOCALEDIR=${datadir}/locale])

-AX_DEFINE_DIR([LOCALEDIR], [LOCALEDIR], [Location of translated messages])

-if test "x$LOCALEDIR" = "xno" -o "x$USE_GETTEXT" = "xno" ; then

-	AC_MSG_RESULT([nowhere])

-	USE_GETTEXT="no"

-else

-	AC_MSG_RESULT([$LOCALEDIR])

-fi

-

-if test "x$USE_GETTEXT" = "xyes" ; then

-	AC_DEFINE([USE_GETTEXT], 1, 

-		  [Define to 1 if you want to use the gettext() function.])

-fi

-AM_CONDITIONAL(USE_GETTEXT, test "x$USE_GETTEXT" = "xyes")

-

-# Optional feature: When ___.xpm is requested, also look for ___.xpm.Z & .gz

-# Replaces ZFILEDEF = -DSTAT_ZFILE in old Imakefile

-AC_ARG_ENABLE(stat-zfile,

-	AS_HELP_STRING([--enable-stat-zfile],

-			[Search for files with .Z & .gz extensions automatically @<:@default=yes@:>@]),

-              [STAT_ZFILE=$enableval], [STAT_ZFILE=yes])

-if test x$STAT_ZFILE = xyes ; then

-	AC_DEFINE(STAT_ZFILE, 1, [Define to 1 to automatically look for files with .Z & .gz extensions])

-fi

-

-AC_CONFIG_FILES([Makefile

-                 doc/Makefile

-                 include/Makefile

-                 src/Makefile

-                 sxpm/Makefile

-                 cxpm/Makefile

-                 xpm.pc])

-AC_OUTPUT

+# Initialize Autoconf
+AC_PREREQ([2.60])
+AC_INIT([libXpm],
+        [3.5.9],
+        [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg],
+        [libXpm])
+AC_CONFIG_SRCDIR([Makefile.am])
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_HEADERS([config.h])
+
+# Initialize Automake
+AM_INIT_AUTOMAKE([foreign dist-bzip2])
+AM_MAINTAINER_MODE
+
+# Initialize libtool
+AC_PROG_LIBTOOL
+
+# Require X.Org macros 1.8 or later for MAN_SUBSTS set by XORG_MANPAGE_SECTIONS
+m4_ifndef([XORG_MACROS_VERSION],
+          [m4_fatal([must install xorg-macros 1.8 or later before running autoconf/autogen])])
+XORG_MACROS_VERSION(1.8)
+XORG_DEFAULT_OPTIONS
+
+# Checks for library functions
+AC_CHECK_FUNCS([strlcat])
+
+# Obtain compiler/linker options for dependencies
+PKG_CHECK_MODULES(XPM, xproto x11)
+PKG_CHECK_MODULES(SXPM, xt xext xextproto, build_sxpm=true, build_sxpm=false)
+AM_CONDITIONAL(BUILD_SXPM, test x$build_sxpm = xtrue)
+
+# Internationalization & localization support
+AC_SEARCH_LIBS([gettext], [intl], [USE_GETTEXT="yes"], [USE_GETTEXT="no"])
+AC_MSG_CHECKING([where to install localized messages])
+AC_ARG_WITH([localedir], AS_HELP_STRING([--with-localedir=<path>],
+	[Path to install message files in (default: datadir/locale)]),
+	[LOCALEDIR=${withval}], [LOCALEDIR=${datadir}/locale])
+AX_DEFINE_DIR([LOCALEDIR], [LOCALEDIR], [Location of translated messages])
+if test "x$LOCALEDIR" = "xno" -o "x$USE_GETTEXT" = "xno" ; then
+	AC_MSG_RESULT([nowhere])
+	USE_GETTEXT="no"
+else
+	AC_MSG_RESULT([$LOCALEDIR])
+fi
+
+if test "x$USE_GETTEXT" = "xyes" ; then
+	AC_DEFINE([USE_GETTEXT], 1, 
+		  [Define to 1 if you want to use the gettext() function.])
+fi
+AM_CONDITIONAL(USE_GETTEXT, test "x$USE_GETTEXT" = "xyes")
+
+# Optional feature: When ___.xpm is requested, also look for ___.xpm.Z & .gz
+# Replaces ZFILEDEF = -DSTAT_ZFILE in old Imakefile
+AC_ARG_ENABLE(stat-zfile,
+	AS_HELP_STRING([--enable-stat-zfile],
+			[Search for files with .Z & .gz extensions automatically @<:@default=yes@:>@]),
+              [STAT_ZFILE=$enableval], [STAT_ZFILE=yes])
+if test x$STAT_ZFILE = xyes ; then
+	AC_DEFINE(STAT_ZFILE, 1, [Define to 1 to automatically look for files with .Z & .gz extensions])
+fi
+
+AC_CONFIG_FILES([Makefile
+                 doc/Makefile
+                 include/Makefile
+                 src/Makefile
+                 sxpm/Makefile
+                 cxpm/Makefile
+                 xpm.pc])
+AC_OUTPUT
diff --git a/libXpm/cxpm/Makefile.am b/libXpm/cxpm/Makefile.am
index 84b2b4d0d..e7481a034 100644
--- a/libXpm/cxpm/Makefile.am
+++ b/libXpm/cxpm/Makefile.am
@@ -1,30 +1,30 @@
-bin_PROGRAMS = cxpm

-

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

-AM_CFLAGS = $(CWARNFLAGS) $(XPM_CFLAGS)

-

-cxpm_SOURCES = cxpm.c

-

-# Man page

-appmandir = $(APP_MAN_DIR)

-

-appman_PRE = cxpm.man

-appman_DATA = $(appman_PRE:man=@APP_MAN_SUFFIX@)

-

-EXTRA_DIST = $(appman_PRE)

-CLEANFILES = $(appman_DATA)

-

-SUFFIXES = .$(APP_MAN_SUFFIX) .man

-

-# String replacements in MAN_SUBSTS now come from xorg-macros.m4 via configure

-.man.$(APP_MAN_SUFFIX):

-	$(AM_V_GEN)$(SED) $(MAN_SUBSTS) < $< > $@

-

-if USE_GETTEXT

-noinst_DATA = cxpm.po

-

-cxpm.po: $(cxpm_SOURCES:%=$(srcdir)/%)

-	$(AM_V_GEN)xgettext -c"L10N_Comments" -d cxpm -n $(cxpm_SOURCES:%=$(srcdir)/%)

-

-CLEANFILES += cxpm.po

-endif

+bin_PROGRAMS = cxpm
+
+AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/include/X11
+AM_CFLAGS = $(CWARNFLAGS) $(XPM_CFLAGS)
+
+cxpm_SOURCES = cxpm.c
+
+# Man page
+appmandir = $(APP_MAN_DIR)
+
+appman_PRE = cxpm.man
+appman_DATA = $(appman_PRE:man=@APP_MAN_SUFFIX@)
+
+EXTRA_DIST = $(appman_PRE)
+CLEANFILES = $(appman_DATA)
+
+SUFFIXES = .$(APP_MAN_SUFFIX) .man
+
+# String replacements in MAN_SUBSTS now come from xorg-macros.m4 via configure
+.man.$(APP_MAN_SUFFIX):
+	$(AM_V_GEN)$(SED) $(MAN_SUBSTS) < $< > $@
+
+if USE_GETTEXT
+noinst_DATA = cxpm.po
+
+cxpm.po: $(cxpm_SOURCES:%=$(srcdir)/%)
+	$(AM_V_GEN)xgettext -c"L10N_Comments" -d cxpm -n $(cxpm_SOURCES:%=$(srcdir)/%)
+
+CLEANFILES += cxpm.po
+endif
diff --git a/libXpm/cxpm/cxpm.c b/libXpm/cxpm/cxpm.c
index 8b49c1b01..49296ee10 100644
--- a/libXpm/cxpm/cxpm.c
+++ b/libXpm/cxpm/cxpm.c
@@ -1,177 +1,177 @@
-/*

- * Copyright (C) 1998 Arnaud LE HORS

- *

- * 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

- * Arnaud LE HORS 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 Arnaud LE HORS shall not be

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

- * in this Software without prior written authorization from Arnaud LE HORS.

- */

-

-/*****************************************************************************\

-* cxpm.c:                                                                     *

-*                                                                             *

-*  Check XPM File program                                                     *

-*                                                                             *

-*  Developed by Arnaud Le Hors                                                *

-\*****************************************************************************/

-

-#define CXPMPROG

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "XpmI.h"

-#ifdef USE_GETTEXT

-#include <locale.h>

-#include <libintl.h>

-#else

-#define gettext(a) (a)

-#endif

-

-#undef xpmGetC

-#define xpmGetC(data) sGetc(data, data->stream.file)

-#define Getc sGetc

-#define Ungetc sUngetc

-

-

-/*

- * special getc and ungetc counting read lines and characters

- * note that 's' could stand both for "special" and "slow" ;-)

- */

-static int

-sGetc(xpmData *data, FILE *file)

-{

-    int c = getc(data->stream.file);

-    if (c == '\n') {

-        data->lineNum++;

-        data->charNum = 0;

-    } else {

-        data->charNum++;

-    }

-    return c;

-}

-

-static void

-sUngetc(xpmData *data, int c, FILE *file)

-{

-    ungetc(c, data->stream.file);

-    if (c == '\n') {

-        data->lineNum--;

-        data->charNum = 0;

-    } else {

-        data->charNum--;

-    }

-}

-

-/* include all the code we need (yeah, I know, quite ugly...) */

-#include "data.c"

-#include "parse.c"

-#include "RdFToI.c"	/* only for OpenReadFile and xpmDataClose */

-#include "hashtab.c"

-#include "misc.c"

-#include "Attrib.c"

-#include "Image.c"

-

-static void

-ErrorMessage(

-    int ErrorStatus,

-    xpmData *data)

-

-{

-    char *error = NULL;

-

-    switch (ErrorStatus) {

-    case XpmSuccess:

-	return;

-    case XpmOpenFailed:

-	/* L10N_Comments : Error produced when filename does not exist 

-	   or insufficient permissions to open (i.e. cxpm /no/such/file ) */

-	error = gettext("Cannot open file");

-	break;

-    case XpmFileInvalid:

-	/* L10N_Comments : Error produced when filename can be read, but

-	   is not an XPM file (i.e. cxpm /dev/null ) */

-	error = gettext("Invalid XPM file");

-	break;

-    case XpmNoMemory:

-	/* L10N_Comments : Error produced when filename can be read, but

-	   is too big for memory 

-	   (i.e. limit datasize 32 ; cxpm /usr/dt/backdrops/Crochet.pm ) */

-	error = gettext("Not enough memory");

-	break;

-    case XpmColorFailed:

-	/* L10N_Comments : Error produced when filename can be read, but

-	   contains an invalid color specification (need to create test case)*/

-	error = gettext("Failed to parse color");

-	break;

-    }

-

-    if (error) {

-	/* L10N_Comments : Wrapper around above Xpm errors - %s is

-	   replaced with the contents of the error message retrieved above */

-	fprintf(stderr, gettext("Xpm Error: %s.\n"), error);

-	if (ErrorStatus == XpmFileInvalid && data)

-	/* L10N_Comments : Error produced when filename can be read, but

-	   is not an XPM file (i.e. cxpm /dev/null ) */

-	  fprintf(stderr, gettext("Error found line %d near character %d\n"),

-		  data->lineNum + 1,

-		  data->charNum + 1);

-	exit(1);

-    }

-}

-

-int

-main(int argc, char **argv)

-{

-    XpmImage image;

-    char *filename;

-    int ErrorStatus;

-    xpmData data;

-

-#ifdef USE_GETTEXT

-    setlocale(LC_ALL,"");

-    bindtextdomain("cxpm",LOCALEDIR);

-    textdomain("cxpm");

-#endif

-

-    if (argc > 1) {

-        if (!strcmp(argv[1], "-?") || !strncmp(argv[1], "-h", 2)) {

-	    /* L10N_Comments : Usage message produced by running cxpm -h

-		%s will be replaced by argv[0] (program name) */

-	    fprintf(stderr, gettext("Usage: %s [filename]\n"), argv[0]);

-	    exit(1);

-	}

-        filename = argv[1];

-    } else {

-        filename = NULL;

-    }

-

-    xpmInitXpmImage(&image);

-

-    if ((ErrorStatus = OpenReadFile(filename, &data)) != XpmSuccess)

-	ErrorMessage(ErrorStatus, NULL);

-

-    ErrorStatus = xpmParseData(&data, &image, NULL);

-    ErrorMessage(ErrorStatus, &data);

-

-    xpmDataClose(&data);

-    XpmFreeXpmImage(&image);

-

-    exit(0);

-}

+/*
+ * Copyright (C) 1998 Arnaud LE HORS
+ *
+ * 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
+ * Arnaud LE HORS 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 Arnaud LE HORS shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Arnaud LE HORS.
+ */
+
+/*****************************************************************************\
+* cxpm.c:                                                                     *
+*                                                                             *
+*  Check XPM File program                                                     *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#define CXPMPROG
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "XpmI.h"
+#ifdef USE_GETTEXT
+#include <locale.h>
+#include <libintl.h>
+#else
+#define gettext(a) (a)
+#endif
+
+#undef xpmGetC
+#define xpmGetC(data) sGetc(data, data->stream.file)
+#define Getc sGetc
+#define Ungetc sUngetc
+
+
+/*
+ * special getc and ungetc counting read lines and characters
+ * note that 's' could stand both for "special" and "slow" ;-)
+ */
+static int
+sGetc(xpmData *data, FILE *file)
+{
+    int c = getc(data->stream.file);
+    if (c == '\n') {
+        data->lineNum++;
+        data->charNum = 0;
+    } else {
+        data->charNum++;
+    }
+    return c;
+}
+
+static void
+sUngetc(xpmData *data, int c, FILE *file)
+{
+    ungetc(c, data->stream.file);
+    if (c == '\n') {
+        data->lineNum--;
+        data->charNum = 0;
+    } else {
+        data->charNum--;
+    }
+}
+
+/* include all the code we need (yeah, I know, quite ugly...) */
+#include "data.c"
+#include "parse.c"
+#include "RdFToI.c"	/* only for OpenReadFile and xpmDataClose */
+#include "hashtab.c"
+#include "misc.c"
+#include "Attrib.c"
+#include "Image.c"
+
+static void
+ErrorMessage(
+    int ErrorStatus,
+    xpmData *data)
+
+{
+    char *error = NULL;
+
+    switch (ErrorStatus) {
+    case XpmSuccess:
+	return;
+    case XpmOpenFailed:
+	/* L10N_Comments : Error produced when filename does not exist 
+	   or insufficient permissions to open (i.e. cxpm /no/such/file ) */
+	error = gettext("Cannot open file");
+	break;
+    case XpmFileInvalid:
+	/* L10N_Comments : Error produced when filename can be read, but
+	   is not an XPM file (i.e. cxpm /dev/null ) */
+	error = gettext("Invalid XPM file");
+	break;
+    case XpmNoMemory:
+	/* L10N_Comments : Error produced when filename can be read, but
+	   is too big for memory 
+	   (i.e. limit datasize 32 ; cxpm /usr/dt/backdrops/Crochet.pm ) */
+	error = gettext("Not enough memory");
+	break;
+    case XpmColorFailed:
+	/* L10N_Comments : Error produced when filename can be read, but
+	   contains an invalid color specification (need to create test case)*/
+	error = gettext("Failed to parse color");
+	break;
+    }
+
+    if (error) {
+	/* L10N_Comments : Wrapper around above Xpm errors - %s is
+	   replaced with the contents of the error message retrieved above */
+	fprintf(stderr, gettext("Xpm Error: %s.\n"), error);
+	if (ErrorStatus == XpmFileInvalid && data)
+	/* L10N_Comments : Error produced when filename can be read, but
+	   is not an XPM file (i.e. cxpm /dev/null ) */
+	  fprintf(stderr, gettext("Error found line %d near character %d\n"),
+		  data->lineNum + 1,
+		  data->charNum + 1);
+	exit(1);
+    }
+}
+
+int
+main(int argc, char **argv)
+{
+    XpmImage image;
+    char *filename;
+    int ErrorStatus;
+    xpmData data;
+
+#ifdef USE_GETTEXT
+    setlocale(LC_ALL,"");
+    bindtextdomain("cxpm",LOCALEDIR);
+    textdomain("cxpm");
+#endif
+
+    if (argc > 1) {
+        if (!strcmp(argv[1], "-?") || !strncmp(argv[1], "-h", 2)) {
+	    /* L10N_Comments : Usage message produced by running cxpm -h
+		%s will be replaced by argv[0] (program name) */
+	    fprintf(stderr, gettext("Usage: %s [filename]\n"), argv[0]);
+	    exit(1);
+	}
+        filename = argv[1];
+    } else {
+        filename = NULL;
+    }
+
+    xpmInitXpmImage(&image);
+
+    if ((ErrorStatus = OpenReadFile(filename, &data)) != XpmSuccess)
+	ErrorMessage(ErrorStatus, NULL);
+
+    ErrorStatus = xpmParseData(&data, &image, NULL);
+    ErrorMessage(ErrorStatus, &data);
+
+    xpmDataClose(&data);
+    XpmFreeXpmImage(&image);
+
+    exit(0);
+}
diff --git a/libXpm/include/X11/xpm.h b/libXpm/include/X11/xpm.h
index 62b5b8b0e..38c62d80d 100644
--- a/libXpm/include/X11/xpm.h
+++ b/libXpm/include/X11/xpm.h
@@ -1,477 +1,477 @@
-/*

- * 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.

- */

-

-/*****************************************************************************\

-* xpm.h:                                                                      *

-*                                                                             *

-*  XPM library                                                                *

-*  Include file                                                               *

-*                                                                             *

-*  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

- */

-

-#ifndef XPM_h

-#define XPM_h

-

-/*

- * first some identification numbers:

- * the version and revision numbers are determined with the following rule:

- * SO Major number = LIB minor version number.

- * SO Minor number = LIB sub-minor version number.

- * e.g: Xpm version 3.2f

- *      we forget the 3 which is the format number, 2 gives 2, and f gives 6.

- *      thus we have XpmVersion = 2 and XpmRevision = 6

- *      which gives  SOXPMLIBREV = 2.6

- *

- * Then the XpmIncludeVersion number is built from these numbers.

- */

-#define XpmFormat 3

-#define XpmVersion 4

-#define XpmRevision 11

-#define XpmIncludeVersion ((XpmFormat * 100 + XpmVersion) * 100 + XpmRevision)

-

-#ifndef XPM_NUMBERS

-

-#ifdef FOR_MSW

-# define SYSV			/* uses memcpy string.h etc. */

-# include <malloc.h>

-# include "simx.h"		/* defines some X stuff using MSW types */

-#define NEED_STRCASECMP		/* at least for MSVC++ */

-#else /* FOR_MSW */

-# ifdef AMIGA

-#  include "amigax.h"

-# else /* not AMIGA */

-#  include <X11/Xlib.h>

-#  include <X11/Xutil.h>

-# endif /* not AMIGA */

-#endif /* FOR_MSW */

-

-/* let's define Pixel if it is not done yet */

-#if ! defined(_XtIntrinsic_h) && ! defined(PIXEL_ALREADY_TYPEDEFED)

-typedef unsigned long Pixel;	/* Index into colormap */

-# define PIXEL_ALREADY_TYPEDEFED

-#endif

-

-/* Return ErrorStatus codes:

- * null     if full success

- * positive if partial success

- * negative if failure

- */

-

-#define XpmColorError    1

-#define XpmSuccess       0

-#define XpmOpenFailed   -1

-#define XpmFileInvalid  -2

-#define XpmNoMemory     -3

-#define XpmColorFailed  -4

-

-typedef struct {

-    char *name;			/* Symbolic color name */

-    char *value;		/* Color value */

-    Pixel pixel;		/* Color pixel */

-}      XpmColorSymbol;

-

-typedef struct {

-    char *name;			/* name of the extension */

-    unsigned int nlines;	/* number of lines in this extension */

-    char **lines;		/* pointer to the extension array of strings */

-}      XpmExtension;

-

-typedef struct {

-    char *string;		/* characters string */

-    char *symbolic;		/* symbolic name */

-    char *m_color;		/* monochrom default */

-    char *g4_color;		/* 4 level grayscale default */

-    char *g_color;		/* other level grayscale default */

-    char *c_color;		/* color default */

-}      XpmColor;

-

-typedef struct {

-    unsigned int width;		/* image width */

-    unsigned int height;	/* image height */

-    unsigned int cpp;		/* number of characters per pixel */

-    unsigned int ncolors;	/* number of colors */

-    XpmColor *colorTable;	/* list of related colors */

-    unsigned int *data;		/* image data */

-}      XpmImage;

-

-typedef struct {

-    unsigned long valuemask;	/* Specifies which attributes are defined */

-    char *hints_cmt;		/* Comment of the hints section */

-    char *colors_cmt;		/* Comment of the colors section */

-    char *pixels_cmt;		/* Comment of the pixels section */

-    unsigned int x_hotspot;	/* Returns the x hotspot's coordinate */

-    unsigned int y_hotspot;	/* Returns the y hotspot's coordinate */

-    unsigned int nextensions;	/* number of extensions */

-    XpmExtension *extensions;	/* pointer to array of extensions */

-}      XpmInfo;

-

-typedef int (*XpmAllocColorFunc)(

-    Display*			/* display */,

-    Colormap			/* colormap */,

-    char*			/* colorname */,

-    XColor*			/* xcolor */,

-    void*			/* closure */

-);

-

-typedef int (*XpmFreeColorsFunc)(

-    Display*			/* display */,

-    Colormap			/* colormap */,

-    Pixel*			/* pixels */,

-    int				/* npixels */,

-    void*			/* closure */

-);

-

-typedef struct {

-    unsigned long valuemask;		/* Specifies which attributes are

-					   defined */

-

-    Visual *visual;			/* Specifies the visual to use */

-    Colormap colormap;			/* Specifies the colormap to use */

-    unsigned int depth;			/* Specifies the depth */

-    unsigned int width;			/* Returns the width of the created

-					   pixmap */

-    unsigned int height;		/* Returns the height of the created

-					   pixmap */

-    unsigned int x_hotspot;		/* Returns the x hotspot's

-					   coordinate */

-    unsigned int y_hotspot;		/* Returns the y hotspot's

-					   coordinate */

-    unsigned int cpp;			/* Specifies the number of char per

-					   pixel */

-    Pixel *pixels;			/* List of used color pixels */

-    unsigned int npixels;		/* Number of used pixels */

-    XpmColorSymbol *colorsymbols;	/* List of color symbols to override */

-    unsigned int numsymbols;		/* Number of symbols */

-    char *rgb_fname;			/* RGB text file name */

-    unsigned int nextensions;		/* Number of extensions */

-    XpmExtension *extensions;		/* List of extensions */

-

-    unsigned int ncolors;               /* Number of colors */

-    XpmColor *colorTable;               /* List of colors */

-/* 3.2 backward compatibility code */

-    char *hints_cmt;                    /* Comment of the hints section */

-    char *colors_cmt;                   /* Comment of the colors section */

-    char *pixels_cmt;                   /* Comment of the pixels section */

-/* end 3.2 bc */

-    unsigned int mask_pixel;            /* Color table index of transparent

-                                           color */

-

-    /* Color Allocation Directives */

-    Bool exactColors;			/* Only use exact colors for visual */

-    unsigned int closeness;		/* Allowable RGB deviation */

-    unsigned int red_closeness;		/* Allowable red deviation */

-    unsigned int green_closeness;	/* Allowable green deviation */

-    unsigned int blue_closeness;	/* Allowable blue deviation */

-    int color_key;			/* Use colors from this color set */

-

-    Pixel *alloc_pixels;		/* Returns the list of alloc'ed color

-					   pixels */

-    int nalloc_pixels;			/* Returns the number of alloc'ed

-					   color pixels */

-

-    Bool alloc_close_colors;    	/* Specify whether close colors should

-					   be allocated using XAllocColor

-					   or not */

-    int bitmap_format;			/* Specify the format of 1bit depth

-					   images: ZPixmap or XYBitmap */

-

-    /* Color functions */

-    XpmAllocColorFunc alloc_color;	/* Application color allocator */

-    XpmFreeColorsFunc free_colors;	/* Application color de-allocator */

-    void *color_closure;		/* Application private data to pass to

-					   alloc_color and free_colors */

-

-}      XpmAttributes;

-

-/* XpmAttributes value masks bits */

-#define XpmVisual	   (1L<<0)

-#define XpmColormap	   (1L<<1)

-#define XpmDepth	   (1L<<2)

-#define XpmSize		   (1L<<3)	/* width & height */

-#define XpmHotspot	   (1L<<4)	/* x_hotspot & y_hotspot */

-#define XpmCharsPerPixel   (1L<<5)

-#define XpmColorSymbols	   (1L<<6)

-#define XpmRgbFilename	   (1L<<7)

-/* 3.2 backward compatibility code */

-#define XpmInfos	   (1L<<8)

-#define XpmReturnInfos	   XpmInfos

-/* end 3.2 bc */

-#define XpmReturnPixels	   (1L<<9)

-#define XpmExtensions      (1L<<10)

-#define XpmReturnExtensions XpmExtensions

-

-#define XpmExactColors     (1L<<11)

-#define XpmCloseness	   (1L<<12)

-#define XpmRGBCloseness	   (1L<<13)

-#define XpmColorKey	   (1L<<14)

-

-#define XpmColorTable      (1L<<15)

-#define XpmReturnColorTable XpmColorTable

-

-#define XpmReturnAllocPixels (1L<<16)

-#define XpmAllocCloseColors (1L<<17)

-#define XpmBitmapFormat    (1L<<18)

-

-#define XpmAllocColor      (1L<<19)

-#define XpmFreeColors      (1L<<20)

-#define XpmColorClosure    (1L<<21)

-

-

-/* XpmInfo value masks bits */

-#define XpmComments        XpmInfos

-#define XpmReturnComments  XpmComments

-

-/* XpmAttributes mask_pixel value when there is no mask */

-#ifndef FOR_MSW

-#define XpmUndefPixel 0x80000000

-#else

-/* int is only 16 bit for MSW */

-#define XpmUndefPixel 0x8000

-#endif

-

-/*

- * color keys for visual type, they must fit along with the number key of

- * each related element in xpmColorKeys[] defined in XpmI.h

- */

-#define XPM_MONO	2

-#define XPM_GREY4	3

-#define XPM_GRAY4	3

-#define XPM_GREY 	4

-#define XPM_GRAY 	4

-#define XPM_COLOR	5

-

-

-/* macros for forward declarations of functions with prototypes */

-#define FUNC(f, t, p) extern t f p

-#define LFUNC(f, t, p) static t f p

-

-

-/*

- * functions declarations

- */

-

-_XFUNCPROTOBEGIN

-

-/* FOR_MSW, all ..Pixmap.. are excluded, only the ..XImage.. are used */

-/* Same for Amiga! */

-

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

-    FUNC(XpmCreatePixmapFromData, int, (Display *display,

-					Drawable d,

-					char **data,

-					Pixmap *pixmap_return,

-					Pixmap *shapemask_return,

-					XpmAttributes *attributes));

-

-    FUNC(XpmCreateDataFromPixmap, int, (Display *display,

-					char ***data_return,

-					Pixmap pixmap,

-					Pixmap shapemask,

-					XpmAttributes *attributes));

-

-    FUNC(XpmReadFileToPixmap, int, (Display *display,

-				    Drawable d,

-				    char *filename,

-				    Pixmap *pixmap_return,

-				    Pixmap *shapemask_return,

-				    XpmAttributes *attributes));

-

-    FUNC(XpmWriteFileFromPixmap, int, (Display *display,

-				       char *filename,

-				       Pixmap pixmap,

-				       Pixmap shapemask,

-				       XpmAttributes *attributes));

-#endif

-

-    FUNC(XpmCreateImageFromData, int, (Display *display,

-				       char **data,

-				       XImage **image_return,

-				       XImage **shapemask_return,

-				       XpmAttributes *attributes));

-

-    FUNC(XpmCreateDataFromImage, int, (Display *display,

-				       char ***data_return,

-				       XImage *image,

-				       XImage *shapeimage,

-				       XpmAttributes *attributes));

-

-    FUNC(XpmReadFileToImage, int, (Display *display,

-				   char *filename,

-				   XImage **image_return,

-				   XImage **shapeimage_return,

-				   XpmAttributes *attributes));

-

-    FUNC(XpmWriteFileFromImage, int, (Display *display,

-				      char *filename,

-				      XImage *image,

-				      XImage *shapeimage,

-				      XpmAttributes *attributes));

-

-    FUNC(XpmCreateImageFromBuffer, int, (Display *display,

-					 char *buffer,

-					 XImage **image_return,

-					 XImage **shapemask_return,

-					 XpmAttributes *attributes));

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

-    FUNC(XpmCreatePixmapFromBuffer, int, (Display *display,

-					  Drawable d,

-					  char *buffer,

-					  Pixmap *pixmap_return,

-					  Pixmap *shapemask_return,

-					  XpmAttributes *attributes));

-

-    FUNC(XpmCreateBufferFromImage, int, (Display *display,

-					 char **buffer_return,

-					 XImage *image,

-					 XImage *shapeimage,

-					 XpmAttributes *attributes));

-

-    FUNC(XpmCreateBufferFromPixmap, int, (Display *display,

-					  char **buffer_return,

-					  Pixmap pixmap,

-					  Pixmap shapemask,

-					  XpmAttributes *attributes));

-#endif

-    FUNC(XpmReadFileToBuffer, int, (char *filename, char **buffer_return));

-    FUNC(XpmWriteFileFromBuffer, int, (char *filename, char *buffer));

-

-    FUNC(XpmReadFileToData, int, (char *filename, char ***data_return));

-    FUNC(XpmWriteFileFromData, int, (char *filename, char **data));

-

-    FUNC(XpmAttributesSize, int, (void));

-    FUNC(XpmFreeAttributes, void, (XpmAttributes *attributes));

-    FUNC(XpmFreeExtensions, void, (XpmExtension *extensions,

-				   int nextensions));

-

-    FUNC(XpmFreeXpmImage, void, (XpmImage *image));

-    FUNC(XpmFreeXpmInfo, void, (XpmInfo *info));

-    FUNC(XpmGetErrorString, char *, (int errcode));

-    FUNC(XpmLibraryVersion, int, (void));

-

-    /* XpmImage functions */

-    FUNC(XpmReadFileToXpmImage, int, (char *filename,

-				      XpmImage *image,

-				      XpmInfo *info));

-

-    FUNC(XpmWriteFileFromXpmImage, int, (char *filename,

-					 XpmImage *image,

-					 XpmInfo *info));

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

-    FUNC(XpmCreatePixmapFromXpmImage, int, (Display *display,

-					    Drawable d,

-					    XpmImage *image,

-					    Pixmap *pixmap_return,

-					    Pixmap *shapemask_return,

-					    XpmAttributes *attributes));

-#endif

-    FUNC(XpmCreateImageFromXpmImage, int, (Display *display,

-					   XpmImage *image,

-					   XImage **image_return,

-					   XImage **shapeimage_return,

-					   XpmAttributes *attributes));

-

-    FUNC(XpmCreateXpmImageFromImage, int, (Display *display,

-					   XImage *image,

-					   XImage *shapeimage,

-					   XpmImage *xpmimage,

-					   XpmAttributes *attributes));

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

-    FUNC(XpmCreateXpmImageFromPixmap, int, (Display *display,

-					    Pixmap pixmap,

-					    Pixmap shapemask,

-					    XpmImage *xpmimage,

-					    XpmAttributes *attributes));

-#endif

-    FUNC(XpmCreateDataFromXpmImage, int, (char ***data_return,

-					  XpmImage *image,

-					  XpmInfo *info));

-

-    FUNC(XpmCreateXpmImageFromData, int, (char **data,

-					  XpmImage *image,

-					  XpmInfo *info));

-

-    FUNC(XpmCreateXpmImageFromBuffer, int, (char *buffer,

-					    XpmImage *image,

-					    XpmInfo *info));

-

-    FUNC(XpmCreateBufferFromXpmImage, int, (char **buffer_return,

-					    XpmImage *image,

-					    XpmInfo *info));

-

-    FUNC(XpmGetParseError, int, (char *filename,

-				 int *linenum_return,

-				 int *charnum_return));

-

-    FUNC(XpmFree, void, (void *ptr));

-

-_XFUNCPROTOEND

-

-/* backward compatibility */

-

-/* for version 3.0c */

-#define XpmPixmapColorError  XpmColorError

-#define XpmPixmapSuccess     XpmSuccess

-#define XpmPixmapOpenFailed  XpmOpenFailed

-#define XpmPixmapFileInvalid XpmFileInvalid

-#define XpmPixmapNoMemory    XpmNoMemory

-#define XpmPixmapColorFailed XpmColorFailed

-

-#define XpmReadPixmapFile(dpy, d, file, pix, mask, att) \

-    XpmReadFileToPixmap(dpy, d, file, pix, mask, att)

-#define XpmWritePixmapFile(dpy, file, pix, mask, att) \

-    XpmWriteFileFromPixmap(dpy, file, pix, mask, att)

-

-/* for version 3.0b */

-#define PixmapColorError  XpmColorError

-#define PixmapSuccess     XpmSuccess

-#define PixmapOpenFailed  XpmOpenFailed

-#define PixmapFileInvalid XpmFileInvalid

-#define PixmapNoMemory    XpmNoMemory

-#define PixmapColorFailed XpmColorFailed

-

-#define ColorSymbol XpmColorSymbol

-

-#define XReadPixmapFile(dpy, d, file, pix, mask, att) \

-    XpmReadFileToPixmap(dpy, d, file, pix, mask, att)

-#define XWritePixmapFile(dpy, file, pix, mask, att) \

-    XpmWriteFileFromPixmap(dpy, file, pix, mask, att)

-#define XCreatePixmapFromData(dpy, d, data, pix, mask, att) \

-    XpmCreatePixmapFromData(dpy, d, data, pix, mask, att)

-#define XCreateDataFromPixmap(dpy, data, pix, mask, att) \

-    XpmCreateDataFromPixmap(dpy, data, pix, mask, att)

-

-#endif /* XPM_NUMBERS */

-#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.
+ */
+
+/*****************************************************************************\
+* xpm.h:                                                                      *
+*                                                                             *
+*  XPM library                                                                *
+*  Include file                                                               *
+*                                                                             *
+*  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
+ */
+
+#ifndef XPM_h
+#define XPM_h
+
+/*
+ * first some identification numbers:
+ * the version and revision numbers are determined with the following rule:
+ * SO Major number = LIB minor version number.
+ * SO Minor number = LIB sub-minor version number.
+ * e.g: Xpm version 3.2f
+ *      we forget the 3 which is the format number, 2 gives 2, and f gives 6.
+ *      thus we have XpmVersion = 2 and XpmRevision = 6
+ *      which gives  SOXPMLIBREV = 2.6
+ *
+ * Then the XpmIncludeVersion number is built from these numbers.
+ */
+#define XpmFormat 3
+#define XpmVersion 4
+#define XpmRevision 11
+#define XpmIncludeVersion ((XpmFormat * 100 + XpmVersion) * 100 + XpmRevision)
+
+#ifndef XPM_NUMBERS
+
+#ifdef FOR_MSW
+# define SYSV			/* uses memcpy string.h etc. */
+# include <malloc.h>
+# include "simx.h"		/* defines some X stuff using MSW types */
+#define NEED_STRCASECMP		/* at least for MSVC++ */
+#else /* FOR_MSW */
+# ifdef AMIGA
+#  include "amigax.h"
+# else /* not AMIGA */
+#  include <X11/Xlib.h>
+#  include <X11/Xutil.h>
+# endif /* not AMIGA */
+#endif /* FOR_MSW */
+
+/* let's define Pixel if it is not done yet */
+#if ! defined(_XtIntrinsic_h) && ! defined(PIXEL_ALREADY_TYPEDEFED)
+typedef unsigned long Pixel;	/* Index into colormap */
+# define PIXEL_ALREADY_TYPEDEFED
+#endif
+
+/* Return ErrorStatus codes:
+ * null     if full success
+ * positive if partial success
+ * negative if failure
+ */
+
+#define XpmColorError    1
+#define XpmSuccess       0
+#define XpmOpenFailed   -1
+#define XpmFileInvalid  -2
+#define XpmNoMemory     -3
+#define XpmColorFailed  -4
+
+typedef struct {
+    char *name;			/* Symbolic color name */
+    char *value;		/* Color value */
+    Pixel pixel;		/* Color pixel */
+}      XpmColorSymbol;
+
+typedef struct {
+    char *name;			/* name of the extension */
+    unsigned int nlines;	/* number of lines in this extension */
+    char **lines;		/* pointer to the extension array of strings */
+}      XpmExtension;
+
+typedef struct {
+    char *string;		/* characters string */
+    char *symbolic;		/* symbolic name */
+    char *m_color;		/* monochrom default */
+    char *g4_color;		/* 4 level grayscale default */
+    char *g_color;		/* other level grayscale default */
+    char *c_color;		/* color default */
+}      XpmColor;
+
+typedef struct {
+    unsigned int width;		/* image width */
+    unsigned int height;	/* image height */
+    unsigned int cpp;		/* number of characters per pixel */
+    unsigned int ncolors;	/* number of colors */
+    XpmColor *colorTable;	/* list of related colors */
+    unsigned int *data;		/* image data */
+}      XpmImage;
+
+typedef struct {
+    unsigned long valuemask;	/* Specifies which attributes are defined */
+    char *hints_cmt;		/* Comment of the hints section */
+    char *colors_cmt;		/* Comment of the colors section */
+    char *pixels_cmt;		/* Comment of the pixels section */
+    unsigned int x_hotspot;	/* Returns the x hotspot's coordinate */
+    unsigned int y_hotspot;	/* Returns the y hotspot's coordinate */
+    unsigned int nextensions;	/* number of extensions */
+    XpmExtension *extensions;	/* pointer to array of extensions */
+}      XpmInfo;
+
+typedef int (*XpmAllocColorFunc)(
+    Display*			/* display */,
+    Colormap			/* colormap */,
+    char*			/* colorname */,
+    XColor*			/* xcolor */,
+    void*			/* closure */
+);
+
+typedef int (*XpmFreeColorsFunc)(
+    Display*			/* display */,
+    Colormap			/* colormap */,
+    Pixel*			/* pixels */,
+    int				/* npixels */,
+    void*			/* closure */
+);
+
+typedef struct {
+    unsigned long valuemask;		/* Specifies which attributes are
+					   defined */
+
+    Visual *visual;			/* Specifies the visual to use */
+    Colormap colormap;			/* Specifies the colormap to use */
+    unsigned int depth;			/* Specifies the depth */
+    unsigned int width;			/* Returns the width of the created
+					   pixmap */
+    unsigned int height;		/* Returns the height of the created
+					   pixmap */
+    unsigned int x_hotspot;		/* Returns the x hotspot's
+					   coordinate */
+    unsigned int y_hotspot;		/* Returns the y hotspot's
+					   coordinate */
+    unsigned int cpp;			/* Specifies the number of char per
+					   pixel */
+    Pixel *pixels;			/* List of used color pixels */
+    unsigned int npixels;		/* Number of used pixels */
+    XpmColorSymbol *colorsymbols;	/* List of color symbols to override */
+    unsigned int numsymbols;		/* Number of symbols */
+    char *rgb_fname;			/* RGB text file name */
+    unsigned int nextensions;		/* Number of extensions */
+    XpmExtension *extensions;		/* List of extensions */
+
+    unsigned int ncolors;               /* Number of colors */
+    XpmColor *colorTable;               /* List of colors */
+/* 3.2 backward compatibility code */
+    char *hints_cmt;                    /* Comment of the hints section */
+    char *colors_cmt;                   /* Comment of the colors section */
+    char *pixels_cmt;                   /* Comment of the pixels section */
+/* end 3.2 bc */
+    unsigned int mask_pixel;            /* Color table index of transparent
+                                           color */
+
+    /* Color Allocation Directives */
+    Bool exactColors;			/* Only use exact colors for visual */
+    unsigned int closeness;		/* Allowable RGB deviation */
+    unsigned int red_closeness;		/* Allowable red deviation */
+    unsigned int green_closeness;	/* Allowable green deviation */
+    unsigned int blue_closeness;	/* Allowable blue deviation */
+    int color_key;			/* Use colors from this color set */
+
+    Pixel *alloc_pixels;		/* Returns the list of alloc'ed color
+					   pixels */
+    int nalloc_pixels;			/* Returns the number of alloc'ed
+					   color pixels */
+
+    Bool alloc_close_colors;    	/* Specify whether close colors should
+					   be allocated using XAllocColor
+					   or not */
+    int bitmap_format;			/* Specify the format of 1bit depth
+					   images: ZPixmap or XYBitmap */
+
+    /* Color functions */
+    XpmAllocColorFunc alloc_color;	/* Application color allocator */
+    XpmFreeColorsFunc free_colors;	/* Application color de-allocator */
+    void *color_closure;		/* Application private data to pass to
+					   alloc_color and free_colors */
+
+}      XpmAttributes;
+
+/* XpmAttributes value masks bits */
+#define XpmVisual	   (1L<<0)
+#define XpmColormap	   (1L<<1)
+#define XpmDepth	   (1L<<2)
+#define XpmSize		   (1L<<3)	/* width & height */
+#define XpmHotspot	   (1L<<4)	/* x_hotspot & y_hotspot */
+#define XpmCharsPerPixel   (1L<<5)
+#define XpmColorSymbols	   (1L<<6)
+#define XpmRgbFilename	   (1L<<7)
+/* 3.2 backward compatibility code */
+#define XpmInfos	   (1L<<8)
+#define XpmReturnInfos	   XpmInfos
+/* end 3.2 bc */
+#define XpmReturnPixels	   (1L<<9)
+#define XpmExtensions      (1L<<10)
+#define XpmReturnExtensions XpmExtensions
+
+#define XpmExactColors     (1L<<11)
+#define XpmCloseness	   (1L<<12)
+#define XpmRGBCloseness	   (1L<<13)
+#define XpmColorKey	   (1L<<14)
+
+#define XpmColorTable      (1L<<15)
+#define XpmReturnColorTable XpmColorTable
+
+#define XpmReturnAllocPixels (1L<<16)
+#define XpmAllocCloseColors (1L<<17)
+#define XpmBitmapFormat    (1L<<18)
+
+#define XpmAllocColor      (1L<<19)
+#define XpmFreeColors      (1L<<20)
+#define XpmColorClosure    (1L<<21)
+
+
+/* XpmInfo value masks bits */
+#define XpmComments        XpmInfos
+#define XpmReturnComments  XpmComments
+
+/* XpmAttributes mask_pixel value when there is no mask */
+#ifndef FOR_MSW
+#define XpmUndefPixel 0x80000000
+#else
+/* int is only 16 bit for MSW */
+#define XpmUndefPixel 0x8000
+#endif
+
+/*
+ * color keys for visual type, they must fit along with the number key of
+ * each related element in xpmColorKeys[] defined in XpmI.h
+ */
+#define XPM_MONO	2
+#define XPM_GREY4	3
+#define XPM_GRAY4	3
+#define XPM_GREY 	4
+#define XPM_GRAY 	4
+#define XPM_COLOR	5
+
+
+/* macros for forward declarations of functions with prototypes */
+#define FUNC(f, t, p) extern t f p
+#define LFUNC(f, t, p) static t f p
+
+
+/*
+ * functions declarations
+ */
+
+_XFUNCPROTOBEGIN
+
+/* FOR_MSW, all ..Pixmap.. are excluded, only the ..XImage.. are used */
+/* Same for Amiga! */
+
+#if !defined(FOR_MSW) && !defined(AMIGA)
+    FUNC(XpmCreatePixmapFromData, int, (Display *display,
+					Drawable d,
+					char **data,
+					Pixmap *pixmap_return,
+					Pixmap *shapemask_return,
+					XpmAttributes *attributes));
+
+    FUNC(XpmCreateDataFromPixmap, int, (Display *display,
+					char ***data_return,
+					Pixmap pixmap,
+					Pixmap shapemask,
+					XpmAttributes *attributes));
+
+    FUNC(XpmReadFileToPixmap, int, (Display *display,
+				    Drawable d,
+				    char *filename,
+				    Pixmap *pixmap_return,
+				    Pixmap *shapemask_return,
+				    XpmAttributes *attributes));
+
+    FUNC(XpmWriteFileFromPixmap, int, (Display *display,
+				       char *filename,
+				       Pixmap pixmap,
+				       Pixmap shapemask,
+				       XpmAttributes *attributes));
+#endif
+
+    FUNC(XpmCreateImageFromData, int, (Display *display,
+				       char **data,
+				       XImage **image_return,
+				       XImage **shapemask_return,
+				       XpmAttributes *attributes));
+
+    FUNC(XpmCreateDataFromImage, int, (Display *display,
+				       char ***data_return,
+				       XImage *image,
+				       XImage *shapeimage,
+				       XpmAttributes *attributes));
+
+    FUNC(XpmReadFileToImage, int, (Display *display,
+				   char *filename,
+				   XImage **image_return,
+				   XImage **shapeimage_return,
+				   XpmAttributes *attributes));
+
+    FUNC(XpmWriteFileFromImage, int, (Display *display,
+				      char *filename,
+				      XImage *image,
+				      XImage *shapeimage,
+				      XpmAttributes *attributes));
+
+    FUNC(XpmCreateImageFromBuffer, int, (Display *display,
+					 char *buffer,
+					 XImage **image_return,
+					 XImage **shapemask_return,
+					 XpmAttributes *attributes));
+#if !defined(FOR_MSW) && !defined(AMIGA)
+    FUNC(XpmCreatePixmapFromBuffer, int, (Display *display,
+					  Drawable d,
+					  char *buffer,
+					  Pixmap *pixmap_return,
+					  Pixmap *shapemask_return,
+					  XpmAttributes *attributes));
+
+    FUNC(XpmCreateBufferFromImage, int, (Display *display,
+					 char **buffer_return,
+					 XImage *image,
+					 XImage *shapeimage,
+					 XpmAttributes *attributes));
+
+    FUNC(XpmCreateBufferFromPixmap, int, (Display *display,
+					  char **buffer_return,
+					  Pixmap pixmap,
+					  Pixmap shapemask,
+					  XpmAttributes *attributes));
+#endif
+    FUNC(XpmReadFileToBuffer, int, (char *filename, char **buffer_return));
+    FUNC(XpmWriteFileFromBuffer, int, (char *filename, char *buffer));
+
+    FUNC(XpmReadFileToData, int, (char *filename, char ***data_return));
+    FUNC(XpmWriteFileFromData, int, (char *filename, char **data));
+
+    FUNC(XpmAttributesSize, int, (void));
+    FUNC(XpmFreeAttributes, void, (XpmAttributes *attributes));
+    FUNC(XpmFreeExtensions, void, (XpmExtension *extensions,
+				   int nextensions));
+
+    FUNC(XpmFreeXpmImage, void, (XpmImage *image));
+    FUNC(XpmFreeXpmInfo, void, (XpmInfo *info));
+    FUNC(XpmGetErrorString, char *, (int errcode));
+    FUNC(XpmLibraryVersion, int, (void));
+
+    /* XpmImage functions */
+    FUNC(XpmReadFileToXpmImage, int, (char *filename,
+				      XpmImage *image,
+				      XpmInfo *info));
+
+    FUNC(XpmWriteFileFromXpmImage, int, (char *filename,
+					 XpmImage *image,
+					 XpmInfo *info));
+#if !defined(FOR_MSW) && !defined(AMIGA)
+    FUNC(XpmCreatePixmapFromXpmImage, int, (Display *display,
+					    Drawable d,
+					    XpmImage *image,
+					    Pixmap *pixmap_return,
+					    Pixmap *shapemask_return,
+					    XpmAttributes *attributes));
+#endif
+    FUNC(XpmCreateImageFromXpmImage, int, (Display *display,
+					   XpmImage *image,
+					   XImage **image_return,
+					   XImage **shapeimage_return,
+					   XpmAttributes *attributes));
+
+    FUNC(XpmCreateXpmImageFromImage, int, (Display *display,
+					   XImage *image,
+					   XImage *shapeimage,
+					   XpmImage *xpmimage,
+					   XpmAttributes *attributes));
+#if !defined(FOR_MSW) && !defined(AMIGA)
+    FUNC(XpmCreateXpmImageFromPixmap, int, (Display *display,
+					    Pixmap pixmap,
+					    Pixmap shapemask,
+					    XpmImage *xpmimage,
+					    XpmAttributes *attributes));
+#endif
+    FUNC(XpmCreateDataFromXpmImage, int, (char ***data_return,
+					  XpmImage *image,
+					  XpmInfo *info));
+
+    FUNC(XpmCreateXpmImageFromData, int, (char **data,
+					  XpmImage *image,
+					  XpmInfo *info));
+
+    FUNC(XpmCreateXpmImageFromBuffer, int, (char *buffer,
+					    XpmImage *image,
+					    XpmInfo *info));
+
+    FUNC(XpmCreateBufferFromXpmImage, int, (char **buffer_return,
+					    XpmImage *image,
+					    XpmInfo *info));
+
+    FUNC(XpmGetParseError, int, (char *filename,
+				 int *linenum_return,
+				 int *charnum_return));
+
+    FUNC(XpmFree, void, (void *ptr));
+
+_XFUNCPROTOEND
+
+/* backward compatibility */
+
+/* for version 3.0c */
+#define XpmPixmapColorError  XpmColorError
+#define XpmPixmapSuccess     XpmSuccess
+#define XpmPixmapOpenFailed  XpmOpenFailed
+#define XpmPixmapFileInvalid XpmFileInvalid
+#define XpmPixmapNoMemory    XpmNoMemory
+#define XpmPixmapColorFailed XpmColorFailed
+
+#define XpmReadPixmapFile(dpy, d, file, pix, mask, att) \
+    XpmReadFileToPixmap(dpy, d, file, pix, mask, att)
+#define XpmWritePixmapFile(dpy, file, pix, mask, att) \
+    XpmWriteFileFromPixmap(dpy, file, pix, mask, att)
+
+/* for version 3.0b */
+#define PixmapColorError  XpmColorError
+#define PixmapSuccess     XpmSuccess
+#define PixmapOpenFailed  XpmOpenFailed
+#define PixmapFileInvalid XpmFileInvalid
+#define PixmapNoMemory    XpmNoMemory
+#define PixmapColorFailed XpmColorFailed
+
+#define ColorSymbol XpmColorSymbol
+
+#define XReadPixmapFile(dpy, d, file, pix, mask, att) \
+    XpmReadFileToPixmap(dpy, d, file, pix, mask, att)
+#define XWritePixmapFile(dpy, file, pix, mask, att) \
+    XpmWriteFileFromPixmap(dpy, file, pix, mask, att)
+#define XCreatePixmapFromData(dpy, d, data, pix, mask, att) \
+    XpmCreatePixmapFromData(dpy, d, data, pix, mask, att)
+#define XCreateDataFromPixmap(dpy, data, pix, mask, att) \
+    XpmCreateDataFromPixmap(dpy, data, pix, mask, att)
+
+#endif /* XPM_NUMBERS */
+#endif
diff --git a/libXpm/src/CrBufFrI.c b/libXpm/src/CrBufFrI.c
index b191037dc..113a45c1e 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 04bb9a046..0dacf5127 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 ba8797f7f..297d310b8 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/RdFToI.c b/libXpm/src/RdFToI.c
index 9f6e3c007..b27a6726d 100644
--- a/libXpm/src/RdFToI.c
+++ b/libXpm/src/RdFToI.c
@@ -1,274 +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>

-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);

-}

+/*
+ * 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 46e800577..f2726f995 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 ead31ab82..9d4b1aeee 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/create.c b/libXpm/src/create.c
index f9823ca6c..7c75a4211 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 904e60b6b..347aa46a2 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/parse.c b/libXpm/src/parse.c
index 1d3ef5f9d..5c7915f78 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 13c30759b..d2780a1ee 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 */
diff --git a/libXpm/sxpm/Makefile.am b/libXpm/sxpm/Makefile.am
index 706ebd963..8241e871e 100644
--- a/libXpm/sxpm/Makefile.am
+++ b/libXpm/sxpm/Makefile.am
@@ -1,40 +1,40 @@
-if BUILD_SXPM

-

-bin_PROGRAMS = sxpm

-

-AM_CPPFLAGS = -I$(top_srcdir)/include

-AM_CFLAGS = $(CWARNFLAGS) $(SXPM_CFLAGS)

-

-sxpm_SOURCES = sxpm.c

-

-LDADD = $(SXPM_LIBS) $(top_builddir)/src/libXpm.la

-

-# Man page

-appmandir = $(APP_MAN_DIR)

-

-appman_PRE = sxpm.man

-appman_DATA = $(appman_PRE:man=@APP_MAN_SUFFIX@)

-

-CLEANFILES = $(appman_DATA)

-

-SUFFIXES = .$(APP_MAN_SUFFIX) .man

-

-# String replacements in MAN_SUBSTS now come from xorg-macros.m4 via configure

-.man.$(APP_MAN_SUFFIX):

-	$(AM_V_GEN)$(SED) $(MAN_SUBSTS) < $< > $@

-

-if USE_GETTEXT

-noinst_DATA = sxpm.po

-

-sxpm.po: $(sxpm_SOURCES:%=$(srcdir)/%)

-	$(AM_V_GEN)xgettext -c"L10N_Comments" -d sxpm -n $(sxpm_SOURCES:%=$(srcdir)/%)

-

-CLEANFILES += sxpm.po

-endif

-endif

-

-EXTRA_DIST = \

-	plaid_ext.xpm \

-	plaid_mask.xpm \

-	plaid.xpm \

-	sxpm.man

+if BUILD_SXPM
+
+bin_PROGRAMS = sxpm
+
+AM_CPPFLAGS = -I$(top_srcdir)/include
+AM_CFLAGS = $(CWARNFLAGS) $(SXPM_CFLAGS)
+
+sxpm_SOURCES = sxpm.c
+
+LDADD = $(SXPM_LIBS) $(top_builddir)/src/libXpm.la
+
+# Man page
+appmandir = $(APP_MAN_DIR)
+
+appman_PRE = sxpm.man
+appman_DATA = $(appman_PRE:man=@APP_MAN_SUFFIX@)
+
+CLEANFILES = $(appman_DATA)
+
+SUFFIXES = .$(APP_MAN_SUFFIX) .man
+
+# String replacements in MAN_SUBSTS now come from xorg-macros.m4 via configure
+.man.$(APP_MAN_SUFFIX):
+	$(AM_V_GEN)$(SED) $(MAN_SUBSTS) < $< > $@
+
+if USE_GETTEXT
+noinst_DATA = sxpm.po
+
+sxpm.po: $(sxpm_SOURCES:%=$(srcdir)/%)
+	$(AM_V_GEN)xgettext -c"L10N_Comments" -d sxpm -n $(sxpm_SOURCES:%=$(srcdir)/%)
+
+CLEANFILES += sxpm.po
+endif
+endif
+
+EXTRA_DIST = \
+	plaid_ext.xpm \
+	plaid_mask.xpm \
+	plaid.xpm \
+	sxpm.man
diff --git a/libXpm/sxpm/sxpm.c b/libXpm/sxpm/sxpm.c
index 86e71443b..ea4dde308 100644
--- a/libXpm/sxpm/sxpm.c
+++ b/libXpm/sxpm/sxpm.c
@@ -1,750 +1,750 @@
-/*

- * 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.

- */

-

-/*****************************************************************************\

-* sxpm.c:                                                                     *

-*                                                                             *

-*  Show XPM File program                                                      *

-*                                                                             *

-*  Developed by Arnaud Le Hors                                                *

-\*****************************************************************************/

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-

-#include <stdio.h>

-#include <stdlib.h>

-#include <X11/StringDefs.h>

-#include <X11/Intrinsic.h>

-#include <X11/IntrinsicP.h>

-#include <X11/Shell.h>

-

-#ifdef VMS

-#include <X11/shape.h>

-#else

-#include <X11/extensions/shape.h>

-#endif

-

-#include <X11/xpm.h>

-

-#ifdef USE_GETTEXT

-#include <locale.h>

-#include <libintl.h>

-#else

-#define gettext(a) (a)

-#endif

-

-/* XPM */

-/* plaid pixmap */

-static char *plaid[] = {

-    /* width height ncolors chars_per_pixel */

-    "22 22 4 2 XPMEXT",

-    /* colors */

-    "   c red 	m white  s light_color",

-    "Y  c green	m black  s lines_in_mix",

-    "+  c yellow	m white  s lines_in_dark",

-    "x 		m black  s dark_color",

-    /* pixels */

-    "x   x   x x x   x   x x x x x x + x x x x x ",

-    "  x   x   x   x   x   x x x x x x x x x x x ",

-    "x   x   x x x   x   x x x x x x + x x x x x ",

-    "  x   x   x   x   x   x x x x x x x x x x x ",

-    "x   x   x x x   x   x x x x x x + x x x x x ",

-    "Y Y Y Y Y x Y Y Y Y Y + x + x + x + x + x + ",

-    "x   x   x x x   x   x x x x x x + x x x x x ",

-    "  x   x   x   x   x   x x x x x x x x x x x ",

-    "x   x   x x x   x   x x x x x x + x x x x x ",

-    "  x   x   x   x   x   x x x x x x x x x x x ",

-    "x   x   x x x   x   x x x x x x + x x x x x ",

-    "          x           x   x   x Y x   x   x ",

-    "          x             x   x   Y   x   x   ",

-    "          x           x   x   x Y x   x   x ",

-    "          x             x   x   Y   x   x   ",

-    "          x           x   x   x Y x   x   x ",

-    "x x x x x x x x x x x x x x x x x x x x x x ",

-    "          x           x   x   x Y x   x   x ",

-    "          x             x   x   Y   x   x   ",

-    "          x           x   x   x Y x   x   x ",

-    "          x             x   x   Y   x   x   ",

-    "          x           x   x   x Y x   x   x ",

-    "bullshit",

-    "XPMEXT ext1 data1",

-    "XPMEXT ext2",

-    "data2_1",

-    "data2_2",

-    "XPMEXT",

-    "foo",

-    "",

-    "XPMEXT ext3",

-    "data3",

-    "XPMENDEXT"

-};

-

-#define win XtWindow(topw)

-#define dpy XtDisplay(topw)

-#define root XRootWindowOfScreen(XtScreen(topw))

-#define xrdb XtDatabase(dpy)

-static Colormap colormap;

-

-void Usage(void);

-void ErrorMessage(int ErrorStatus, char *tag);

-void Punt(int i);

-void VersionInfo(void);

-void kinput(Widget widget, char *tag, XEvent *xe, Boolean *b);

-void GetNumbers(int num, int *format_return,

-		int *libmajor_return,

-		char *libminor_return);

-

-#define IWIDTH      50

-#define IHEIGHT     50

-

-typedef struct _XpmIcon {

-    Pixmap pixmap;

-    Pixmap mask;

-    XpmAttributes attributes;

-}        XpmIcon;

-

-static char **command;

-static Widget topw;

-static XpmIcon view, icon;

-static XrmOptionDescRec options[] = {

-    {"-hints", ".hints", XrmoptionNoArg, (XtPointer) "True"},

-    {"-icon", ".icon", XrmoptionSepArg, (XtPointer) NULL},

-};

-

-int

-main(

-    int		  argc,

-    char	**argv)

-{

-    int ErrorStatus;

-    unsigned int verbose = 0;		/* performs verbose output */

-    unsigned int stdinf = 1;		/* read from stdin */

-    unsigned int stdoutf = 0;		/* write to stdout */

-    unsigned int nod = 0;		/* no display */

-    unsigned int nom = 0;		/* no mask display */

-    unsigned int incResize = 0;

-    unsigned int resize = 0;

-    unsigned int w_rtn;

-    unsigned int h_rtn;

-    char *input = NULL;

-    char *output = NULL;

-    char *iconFile = NULL;

-    unsigned int numsymbols = 0;

-    XpmColorSymbol symbols[10];

-    char *stype;

-    XrmValue val;

-    unsigned long valuemask = 0;

-    int n;

-    Arg args[4];

-

-#ifdef Debug

-    char **data;

-    char *buffer;

-#endif

-

-#ifdef USE_GETTEXT

-    XtSetLanguageProc(NULL,NULL,NULL);

-    bindtextdomain("sxpm",LOCALEDIR);

-    textdomain("sxpm");

-#endif

-

-    topw = XtInitialize(argv[0], "Sxpm",

-			options, XtNumber(options), &argc, argv);

-

-    if (!topw) {

-	/* L10N_Comments : Error if no $DISPLAY or $DISPLAY can't be opened.

-	   Not normally reached as Xt exits before we get here. */

-	fprintf(stderr, gettext("Sxpm Error... [ Undefined DISPLAY ]\n"));

-	exit(1);

-    }

-    colormap = XDefaultColormapOfScreen(XtScreen(topw));

-

-    /*

-     * geometry management

-     */

-

-    if (XrmGetResource(xrdb, NULL, "sxpm.geometry", &stype, &val)

-	|| XrmGetResource(xrdb, NULL, "Sxpm.geometry", &stype, &val)) {

-

-	int flags;

-	int x_rtn;

-	int y_rtn;

-	char *geo = NULL;

-

-	geo = (char *) val.addr;

-	flags = XParseGeometry(geo, &x_rtn, &y_rtn,

-			       (unsigned int *) &w_rtn,

-			       (unsigned int *) &h_rtn);

-

-	if (!((WidthValue & flags) && (HeightValue & flags)))

-	    resize = 1;

-

-    } else

-	resize = 1;

-

-    n = 0;

-    if (resize) {

-	w_rtn = 0;

-	h_rtn = 0;

-	XtSetArg(args[n], XtNwidth, 1);

-	n++;

-	XtSetArg(args[n], XtNheight, 1);

-	n++;

-    }

-    XtSetArg(args[n], XtNmappedWhenManaged, False);

-    n++;

-    XtSetArg(args[n], XtNinput, True);

-    n++;

-    XtSetValues(topw, args, n);

-

-    if ((XrmGetResource(xrdb, "sxpm.hints", "", &stype, &val)

-	 || XrmGetResource(xrdb, "Sxpm.hints", "", &stype, &val))

-	&& !strcmp((char *) val.addr, "True")) {

-	/* gotcha */

-	incResize = 1;

-	resize = 1;

-    }

-

-    /*

-     * icon management

-     */

-

-    if (XrmGetResource(xrdb, "sxpm.icon", "", &stype, &val)

-	|| XrmGetResource(xrdb, "Sxpm.icon", "", &stype, &val)) {

-	iconFile = (char *) val.addr;

-    }

-    if (iconFile) {

-

-	XColor color, junk;

-	Pixel bpix;

-	Window iconW;

-

-	if (XAllocNamedColor(dpy, colormap, "black", &color, &junk))

-	    bpix = color.pixel;

-	else

-	    bpix = XBlackPixelOfScreen(XtScreen(topw));

-

-	iconW = XCreateSimpleWindow(dpy, root, 0, 0,

-				    IWIDTH, IHEIGHT, 1, bpix, bpix);

-

-	icon.attributes.valuemask = XpmReturnAllocPixels;

-	ErrorStatus = XpmReadFileToPixmap(dpy, root, iconFile, &icon.pixmap,

-					  &icon.mask, &icon.attributes);

-	ErrorMessage(ErrorStatus, "Icon");

-

-	XSetWindowBackgroundPixmap(dpy, iconW, icon.pixmap);

-

-	n = 0;

-	XtSetArg(args[n], XtNbackground, bpix);

-	n++;

-	XtSetArg(args[n], XtNiconWindow, iconW);

-	n++;

-	XtSetValues(topw, args, n);

-    }

-

-    /*

-     * arguments parsing

-     */

-

-    command = argv;

-    for (n = 1; n < argc; n++) {

-	if (strcmp(argv[n], "-plaid") == 0) {

-	    stdinf = 0;

-	    continue;

-	}

-	if (argv[n][0] != '-') {

-	    stdinf = 0;

-	    input = argv[n];

-	    continue;

-	}

-	if ((strlen(argv[n]) == 1) && (argv[n][0] == '-'))

-	    /* stdin */

-	    continue;

-	if (strcmp(argv[n], "-o") == 0) {

-	    if (n < argc - 1) {

-		if ((strlen(argv[n + 1]) == 1) && (argv[n + 1][0] == '-'))

-		    stdoutf = 1;

-		else

-		    output = argv[n + 1];

-		n++;

-		continue;

-	    } else

-		Usage();

-	}

-	if (strcmp(argv[n], "-nod") == 0) {

-	    nod = 1;

-	    continue;

-	}

-	if (strcmp(argv[n], "-nom") == 0) {

-	    nom = 1;

-	    continue;

-	}

-	if (strcmp(argv[n], "-sc") == 0) {

-	    if (n < argc - 2) {

-		valuemask |= XpmColorSymbols;

-		symbols[numsymbols].name = argv[++n];

-		symbols[numsymbols++].value = argv[++n];

-		continue;

-	    } else

-		Usage();

-	}

-	if (strcmp(argv[n], "-sp") == 0) {

-	    if (n < argc - 2) {

-		valuemask |= XpmColorSymbols;

-		symbols[numsymbols].name = argv[++n];

-		symbols[numsymbols].value = NULL;

-		symbols[numsymbols++].pixel = atol(argv[++n]);

-		continue;

-	    }

-	}

-	if (strcmp(argv[n], "-cp") == 0) {

-	    if (n < argc - 2) {

-		valuemask |= XpmColorSymbols;

-		symbols[numsymbols].name = NULL;

-		symbols[numsymbols].value = argv[++n];

-		symbols[numsymbols++].pixel = atol(argv[++n]);

-		continue;

-	    }

-	}

-	if (strcmp(argv[n], "-mono") == 0) {

-	    valuemask |= XpmColorKey;

-	    view.attributes.color_key = XPM_MONO;

-	    continue;

-	}

-	if (strcmp(argv[n], "-gray4") == 0 || strcmp(argv[n], "-grey4") == 0) {

-	    valuemask |= XpmColorKey;

-	    view.attributes.color_key = XPM_GRAY4;

-	    continue;

-	}

-	if (strcmp(argv[n], "-gray") == 0 || strcmp(argv[n], "-grey") == 0) {

-	    valuemask |= XpmColorKey;

-	    view.attributes.color_key = XPM_GRAY;

-	    continue;

-	}

-	if (strcmp(argv[n], "-color") == 0) {

-	    valuemask |= XpmColorKey;

-	    view.attributes.color_key = XPM_COLOR;

-	    continue;

-	}

-	if (strncmp(argv[n], "-closecolors", 6) == 0) {

-	    valuemask |= XpmCloseness;

-	    view.attributes.closeness = 40000;

-	    continue;

-	}

-	if (strcmp(argv[n], "-rgb") == 0) {

-	    if (n < argc - 1) {

-		valuemask |= XpmRgbFilename;

-		view.attributes.rgb_fname = argv[++n];

-		continue;

-	    } else

-		Usage();

-

-	}

-	if (strncmp(argv[n], "-version", 4) == 0) {

-	    VersionInfo();

-	    exit(0);

-	}

-	if (strcmp(argv[n], "-v") == 0) {

-	    verbose = 1;

-	    continue;

-	}

-	if (strcmp(argv[n], "-pcmap") == 0) {

-	    valuemask |= XpmColormap;

-	    continue;

-	}

-	Usage();

-    }

-

-    XtRealizeWidget(topw);

-    if (valuemask & XpmColormap) {

-	colormap = XCreateColormap(dpy, win,

-				   DefaultVisual(dpy, DefaultScreen(dpy)),

-				   AllocNone);

-	view.attributes.colormap = colormap;

-	XSetWindowColormap(dpy, win, colormap);

-    }

-    view.attributes.colorsymbols = symbols;

-    view.attributes.numsymbols = numsymbols;

-    view.attributes.valuemask = valuemask;

-

-#ifdef Debug

-    /* this is just to test the XpmCreateDataFromPixmap function */

-

-    view.attributes.valuemask |= XpmReturnAllocPixels;

-    view.attributes.valuemask |= XpmReturnExtensions;

-    ErrorStatus = XpmCreatePixmapFromData(dpy, win, plaid,

-					  &view.pixmap, &view.mask,

-					  &view.attributes);

-    ErrorMessage(ErrorStatus, "Plaid");

-

-    ErrorStatus = XpmCreateDataFromPixmap(dpy, &data, view.pixmap, view.mask,

-					  &view.attributes);

-    ErrorMessage(ErrorStatus, "Data");

-    if (verbose && view.attributes.nextensions) {

-	unsigned int i, j;

-

-	for (i = 0; i < view.attributes.nextensions; i++) {

-	    fprintf(stderr, "Xpm extension : %s\n",

-		    view.attributes.extensions[i].name);

-	    for (j = 0; j < view.attributes.extensions[i].nlines; j++)

-		fprintf(stderr, "\t\t%s\n",

-			view.attributes.extensions[i].lines[j]);

-	}

-    }

-    XFreePixmap(dpy, view.pixmap);

-    if (view.mask)

-	XFreePixmap(dpy, view.mask);

-

-    XFreeColors(dpy, colormap,

-		view.attributes.alloc_pixels,

-		view.attributes.nalloc_pixels, 0);

-

-    XpmFreeAttributes(&view.attributes);

-    view.attributes.valuemask = valuemask;

-#endif

-

-    if (input || stdinf) {

-	view.attributes.valuemask |= XpmReturnInfos;

-	view.attributes.valuemask |= XpmReturnAllocPixels;

-	view.attributes.valuemask |= XpmReturnExtensions;

-

-#ifdef Debug

-	XpmFree(data);

-

-	/*

-	 * this is just to test the XpmCreatePixmapFromBuffer and

-	 * XpmCreateBufferFromPixmap functions

-	 */

-	ErrorStatus = XpmReadFileToBuffer(input, &buffer);

-	ErrorMessage(ErrorStatus, "CreateBufferFromFile");

-

-	ErrorStatus = XpmCreatePixmapFromBuffer(dpy, win, buffer,

-						&view.pixmap, &view.mask,

-						&view.attributes);

-	ErrorMessage(ErrorStatus, "CreatePixmapFromBuffer");

-	XpmFree(buffer);

-	ErrorStatus = XpmCreateBufferFromPixmap(dpy, &buffer,

-						view.pixmap, view.mask,

-						&view.attributes);

-	ErrorMessage(ErrorStatus, "CreateBufferFromPixmap");

-	ErrorStatus = XpmWriteFileFromBuffer("buffer_output", buffer);

-	ErrorMessage(ErrorStatus, "WriteFileFromBuffer");

-	XpmFree(buffer);

-	if (view.pixmap) {

-	    XFreePixmap(dpy, view.pixmap);

-	    if (view.mask)

-		XFreePixmap(dpy, view.mask);

-

-	    XFreeColors(dpy, colormap, view.attributes.alloc_pixels,

-			view.attributes.nalloc_pixels, 0);

-

-	    XpmFreeAttributes(&view.attributes);

-	}

-	ErrorStatus = XpmReadFileToData(input, &data);

-	ErrorMessage(ErrorStatus, "ReadFileToData");

-	ErrorStatus = XpmCreatePixmapFromData(dpy, win, data,

-					      &view.pixmap, &view.mask,

-					      &view.attributes);

-	ErrorMessage(ErrorStatus, "CreatePixmapFromData");

-	ErrorStatus = XpmWriteFileFromData("sxpmout.xpm", data);

-	ErrorMessage(ErrorStatus, "WriteFileFromData");

-	XpmFree(data);

-	XpmFreeAttributes(&view.attributes);

-#endif

-	ErrorStatus = XpmReadFileToPixmap(dpy, win, input,

-					  &view.pixmap, &view.mask,

-					  &view.attributes);

-	ErrorMessage(ErrorStatus, "Read");

-	if (verbose && view.attributes.nextensions) {

-	    unsigned int i, j;

-

-	    for (i = 0; i < view.attributes.nextensions; i++) {

-		/* L10N_Comments : Output when -v & file has extensions 

-		   %s is replaced by extension name */

-		fprintf(stderr, gettext("Xpm extension : %s\n"),

-			view.attributes.extensions[i].name);

-		for (j = 0; j < view.attributes.extensions[i].nlines; j++)

-		    fprintf(stderr, "\t\t%s\n",

-			    view.attributes.extensions[i].lines[j]);

-	    }

-	}

-    } else {

-#ifdef Debug

-	ErrorStatus = XpmCreatePixmapFromData(dpy, win, data,

-					      &view.pixmap, &view.mask,

-					      &view.attributes);

-	XpmFree(data);

-#else

-	ErrorStatus = XpmCreatePixmapFromData(dpy, win, plaid,

-					      &view.pixmap, &view.mask,

-					      &view.attributes);

-#endif

-	ErrorMessage(ErrorStatus, "Plaid");

-    }

-    if (output || stdoutf) {

-	ErrorStatus = XpmWriteFileFromPixmap(dpy, output, view.pixmap,

-					     view.mask, &view.attributes);

-	ErrorMessage(ErrorStatus, "Write");

-    }

-    if (!nod) {

-

-	/*

-	 * manage display if requested

-	 */

-

-	XSizeHints size_hints;

-	char *xString = NULL;

-

-	if (w_rtn && h_rtn

-	    && ((w_rtn < view.attributes.width)

-		|| h_rtn < view.attributes.height)) {

-	    resize = 1;

-	}

-	if (resize) {

-	    XtResizeWidget(topw,

-			   view.attributes.width, view.attributes.height, 1);

-	}

-	if (incResize) {

-	    size_hints.flags = USSize | PMinSize | PResizeInc;

-	    size_hints.height = view.attributes.height;

-	    size_hints.width = view.attributes.width;

-	    size_hints.height_inc = view.attributes.height;

-	    size_hints.width_inc = view.attributes.width;

-	} else

-	    size_hints.flags = PMinSize;

-

-	size_hints.min_height = view.attributes.height;

-	size_hints.min_width = view.attributes.width;

-	XSetWMNormalHints(dpy, win, &size_hints);

-

-	if (input) {

-	    xString = (char *) XtMalloc((sizeof(char) * strlen(input)) + 20);

-	    sprintf(xString, "Sxpm: %s", input);

-	    XStoreName(dpy, win, xString);

-	    XSetIconName(dpy, win, xString);

-	} else if (stdinf) {

-	    XStoreName(dpy, win, "Sxpm: stdin");

-	    XSetIconName(dpy, win, "Sxpm: stdin");

-	} else {

-	    XStoreName(dpy, win, "Sxpm");

-	    XSetIconName(dpy, win, "Sxpm");

-	}

-

-	XtAddEventHandler(topw, KeyPressMask, False,

-			  (XtEventHandler) kinput, NULL);

-	XSetWindowBackgroundPixmap(dpy, win, view.pixmap);

-

-	if (view.mask && !nom)

-	    XShapeCombineMask(dpy, win, ShapeBounding, 0, 0,

-			      view.mask, ShapeSet);

-

-	XClearWindow(dpy, win);

-	XtMapWidget(topw);

-	if (xString)

-	    XtFree(xString);

-	XtMainLoop();

-    }

-    Punt(0);

-

-    /* Muffle gcc */

-    return 0;

-}

-

-void

-Usage(void)

-{

-    /* L10N_Comments : Usage message (sxpm -h) in two parts. 

-       In the first part %s is replaced by the command name. */

-    fprintf(stderr, gettext("\nUsage:  %s [options...]\n"), command[0]);

-    fprintf(stderr, gettext("Where options are:\n\

-\n\

-[-d host:display]            Display to connect to.\n\

-[-g geom]                    Geometry of window.\n\

-[-hints]                     Set ResizeInc for window.\n\

-[-icon filename]             Set pixmap for iconWindow.\n\

-[-plaid]                     Read the included plaid pixmap.\n\

-[filename]                   Read from file 'filename', and from standard\n\

-                             input if 'filename' is '-'.\n\

-[-o filename]                Write to file 'filename', and to standard\n\

-                             output if 'filename' is '-'.\n\

-[-pcmap]                     Use a private colormap.\n\

-[-closecolors]               Try to use `close' colors.\n\

-[-nod]                       Don't display in window.\n\

-[-nom]                       Don't use clip mask if any.\n\

-[-mono]                      Use the colors specified for a monochrome visual.\n\

-[-grey4]                     Use the colors specified for a 4 greyscale visual.\n\

-[-grey]                      Use the colors specified for a greyscale visual.\n\

-[-color]                     Use the colors specified for a color visual.\n\

-[-sc symbol color]           Override color defaults.\n\

-[-sp symbol pixel]           Override color defaults.\n\

-[-cp color pixel]            Override color defaults.\n\

-[-rgb filename]              Search color names in the rgb text file 'filename'.\n\

-[-v]                         Verbose - print out extensions.\n\

-[-version]                   Print out program's version number\n\

-                             and library's version number if different.\n\

-if no input is specified sxpm reads from standard input.\n\

-\n"));

-    exit(0);

-}

-

-

-void

-ErrorMessage(

-    int		 ErrorStatus,

-    char	*tag)

-{

-    char *error = NULL;

-    char *warning = NULL;

-

-    switch (ErrorStatus) {

-    case XpmSuccess:

-	return;

-    case XpmColorError:

-/* L10N_Comments : The following set of messages are classified as 

-   either errors or warnings.  Based on the class of message, different

-   wrappers are selected at the end to state the message source & class. 

-

-	   L10N_Comments : WARNING produced when filename can be read, but

-	   contains an invalid color specification (need to create test case)*/

-	warning = gettext("Could not parse or alloc requested color");

-	break;

-    case XpmOpenFailed:

-	/* L10N_Comments : ERROR produced when filename does not exist 

-	   or insufficient permissions to open (i.e. sxpm /no/such/file ) */

-	error = gettext("Cannot open file");

-	break;

-    case XpmFileInvalid:

-	/* L10N_Comments : ERROR produced when filename can be read, but

-	   is not an XPM file (i.e. sxpm /dev/null ) */

-	error = gettext("Invalid XPM file");

-	break;

-    case XpmNoMemory:

-	/* L10N_Comments : ERROR produced when filename can be read, but

-	   is too big for memory 

-	   (i.e. limit datasize 32 ; sxpm /usr/dt/backdrops/Crochet.pm ) */

-	error = gettext("Not enough memory");

-	break;

-    case XpmColorFailed:

-	/* L10N_Comments : ERROR produced when filename can be read, but

-	   contains an invalid color specification (need to create test case)*/

-	error = gettext("Failed to parse or alloc some color");

-	break;

-    }

-

-    if (warning)

-	/* L10N_Comments : Wrapper around above WARNING messages.

-	   First %s is the tag for the operation that produced the warning.

-	   Second %s is the message selected from the above set. */

-	fprintf(stderr, gettext("%s Xpm Warning: %s.\n"), tag, warning);

-

-    if (error) {

-	/* L10N_Comments : Wrapper around above ERROR messages.

-	   First %s is the tag for the operation that produced the error.

-	   Second %s is the message selected from the above set */

-	fprintf(stderr, gettext("%s Xpm Error: %s.\n"), tag, error);

-	Punt(1);

-    }

-}

-

-void

-Punt(int i)

-{

-    if (icon.pixmap) {

-	XFreePixmap(dpy, icon.pixmap);

-	if (icon.mask)

-	    XFreePixmap(dpy, icon.mask);

-

-	XFreeColors(dpy, colormap,

-		    icon.attributes.alloc_pixels,

-		    icon.attributes.nalloc_pixels, 0);

-

-	XpmFreeAttributes(&icon.attributes);

-    }

-    if (view.pixmap) {

-	XFreePixmap(dpy, view.pixmap);

-	if (view.mask)

-	    XFreePixmap(dpy, view.mask);

-

-	XFreeColors(dpy, colormap,

-		    view.attributes.alloc_pixels,

-		    view.attributes.nalloc_pixels, 0);

-

-	XpmFreeAttributes(&view.attributes);

-    }

-    exit(i);

-}

-

-void

-kinput(

-    Widget	 widget,

-    char	*tag,

-    XEvent	*xe,

-    Boolean	*b)

-{

-    char c = '\0';

-

-    XLookupString(&(xe->xkey), &c, 1, NULL, NULL);

-    if (c == 'q' || c == 'Q')

-	Punt(0);

-}

-

-/*

- * small function to extract various version numbers from the given global

- * number (following the rule described in xpm.h).

- */

-void

-GetNumbers(

-    int		 num,

-    int		*format_return,

-    int		*libmajor_return,

-    char	*libminor_return)

-{

-    *format_return = num / 10000;

-    *libmajor_return = (num % 10000) / 100;

-    *libminor_return = 'a' + (num % 10000) % 100 - 1;

-}

-

-void

-VersionInfo(void)

-{

-    int format, libmajor;

-    char libminor;

-

-    GetNumbers(XpmIncludeVersion, &format, &libmajor, &libminor);

-    /* L10N_Comments : sxpm -version output */

-    fprintf(stderr, gettext("sxpm version: %d.%d%c\n"),

-	    format, libmajor, libminor);

-    /* L10N_Comments :

-     * if we are linked to an XPM library different from the one we've been

-     * compiled with, print its own number too when sxpm -version is called.

-     */

-    if (XpmIncludeVersion != XpmLibraryVersion()) {

-	GetNumbers(XpmLibraryVersion(), &format, &libmajor, &libminor);

-	fprintf(stderr, gettext("using the XPM library version: %d.%d%c\n"),

-		format, libmajor, libminor);

-    }

-}

+/*
+ * 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.
+ */
+
+/*****************************************************************************\
+* sxpm.c:                                                                     *
+*                                                                             *
+*  Show XPM File program                                                      *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <X11/StringDefs.h>
+#include <X11/Intrinsic.h>
+#include <X11/IntrinsicP.h>
+#include <X11/Shell.h>
+
+#ifdef VMS
+#include <X11/shape.h>
+#else
+#include <X11/extensions/shape.h>
+#endif
+
+#include <X11/xpm.h>
+
+#ifdef USE_GETTEXT
+#include <locale.h>
+#include <libintl.h>
+#else
+#define gettext(a) (a)
+#endif
+
+/* XPM */
+/* plaid pixmap */
+static char *plaid[] = {
+    /* width height ncolors chars_per_pixel */
+    "22 22 4 2 XPMEXT",
+    /* colors */
+    "   c red 	m white  s light_color",
+    "Y  c green	m black  s lines_in_mix",
+    "+  c yellow	m white  s lines_in_dark",
+    "x 		m black  s dark_color",
+    /* pixels */
+    "x   x   x x x   x   x x x x x x + x x x x x ",
+    "  x   x   x   x   x   x x x x x x x x x x x ",
+    "x   x   x x x   x   x x x x x x + x x x x x ",
+    "  x   x   x   x   x   x x x x x x x x x x x ",
+    "x   x   x x x   x   x x x x x x + x x x x x ",
+    "Y Y Y Y Y x Y Y Y Y Y + x + x + x + x + x + ",
+    "x   x   x x x   x   x x x x x x + x x x x x ",
+    "  x   x   x   x   x   x x x x x x x x x x x ",
+    "x   x   x x x   x   x x x x x x + x x x x x ",
+    "  x   x   x   x   x   x x x x x x x x x x x ",
+    "x   x   x x x   x   x x x x x x + x x x x x ",
+    "          x           x   x   x Y x   x   x ",
+    "          x             x   x   Y   x   x   ",
+    "          x           x   x   x Y x   x   x ",
+    "          x             x   x   Y   x   x   ",
+    "          x           x   x   x Y x   x   x ",
+    "x x x x x x x x x x x x x x x x x x x x x x ",
+    "          x           x   x   x Y x   x   x ",
+    "          x             x   x   Y   x   x   ",
+    "          x           x   x   x Y x   x   x ",
+    "          x             x   x   Y   x   x   ",
+    "          x           x   x   x Y x   x   x ",
+    "bullshit",
+    "XPMEXT ext1 data1",
+    "XPMEXT ext2",
+    "data2_1",
+    "data2_2",
+    "XPMEXT",
+    "foo",
+    "",
+    "XPMEXT ext3",
+    "data3",
+    "XPMENDEXT"
+};
+
+#define win XtWindow(topw)
+#define dpy XtDisplay(topw)
+#define root XRootWindowOfScreen(XtScreen(topw))
+#define xrdb XtDatabase(dpy)
+static Colormap colormap;
+
+void Usage(void);
+void ErrorMessage(int ErrorStatus, char *tag);
+void Punt(int i);
+void VersionInfo(void);
+void kinput(Widget widget, char *tag, XEvent *xe, Boolean *b);
+void GetNumbers(int num, int *format_return,
+		int *libmajor_return,
+		char *libminor_return);
+
+#define IWIDTH      50
+#define IHEIGHT     50
+
+typedef struct _XpmIcon {
+    Pixmap pixmap;
+    Pixmap mask;
+    XpmAttributes attributes;
+}        XpmIcon;
+
+static char **command;
+static Widget topw;
+static XpmIcon view, icon;
+static XrmOptionDescRec options[] = {
+    {"-hints", ".hints", XrmoptionNoArg, (XtPointer) "True"},
+    {"-icon", ".icon", XrmoptionSepArg, (XtPointer) NULL},
+};
+
+int
+main(
+    int		  argc,
+    char	**argv)
+{
+    int ErrorStatus;
+    unsigned int verbose = 0;		/* performs verbose output */
+    unsigned int stdinf = 1;		/* read from stdin */
+    unsigned int stdoutf = 0;		/* write to stdout */
+    unsigned int nod = 0;		/* no display */
+    unsigned int nom = 0;		/* no mask display */
+    unsigned int incResize = 0;
+    unsigned int resize = 0;
+    unsigned int w_rtn;
+    unsigned int h_rtn;
+    char *input = NULL;
+    char *output = NULL;
+    char *iconFile = NULL;
+    unsigned int numsymbols = 0;
+    XpmColorSymbol symbols[10];
+    char *stype;
+    XrmValue val;
+    unsigned long valuemask = 0;
+    int n;
+    Arg args[4];
+
+#ifdef Debug
+    char **data;
+    char *buffer;
+#endif
+
+#ifdef USE_GETTEXT
+    XtSetLanguageProc(NULL,NULL,NULL);
+    bindtextdomain("sxpm",LOCALEDIR);
+    textdomain("sxpm");
+#endif
+
+    topw = XtInitialize(argv[0], "Sxpm",
+			options, XtNumber(options), &argc, argv);
+
+    if (!topw) {
+	/* L10N_Comments : Error if no $DISPLAY or $DISPLAY can't be opened.
+	   Not normally reached as Xt exits before we get here. */
+	fprintf(stderr, gettext("Sxpm Error... [ Undefined DISPLAY ]\n"));
+	exit(1);
+    }
+    colormap = XDefaultColormapOfScreen(XtScreen(topw));
+
+    /*
+     * geometry management
+     */
+
+    if (XrmGetResource(xrdb, NULL, "sxpm.geometry", &stype, &val)
+	|| XrmGetResource(xrdb, NULL, "Sxpm.geometry", &stype, &val)) {
+
+	int flags;
+	int x_rtn;
+	int y_rtn;
+	char *geo = NULL;
+
+	geo = (char *) val.addr;
+	flags = XParseGeometry(geo, &x_rtn, &y_rtn,
+			       (unsigned int *) &w_rtn,
+			       (unsigned int *) &h_rtn);
+
+	if (!((WidthValue & flags) && (HeightValue & flags)))
+	    resize = 1;
+
+    } else
+	resize = 1;
+
+    n = 0;
+    if (resize) {
+	w_rtn = 0;
+	h_rtn = 0;
+	XtSetArg(args[n], XtNwidth, 1);
+	n++;
+	XtSetArg(args[n], XtNheight, 1);
+	n++;
+    }
+    XtSetArg(args[n], XtNmappedWhenManaged, False);
+    n++;
+    XtSetArg(args[n], XtNinput, True);
+    n++;
+    XtSetValues(topw, args, n);
+
+    if ((XrmGetResource(xrdb, "sxpm.hints", "", &stype, &val)
+	 || XrmGetResource(xrdb, "Sxpm.hints", "", &stype, &val))
+	&& !strcmp((char *) val.addr, "True")) {
+	/* gotcha */
+	incResize = 1;
+	resize = 1;
+    }
+
+    /*
+     * icon management
+     */
+
+    if (XrmGetResource(xrdb, "sxpm.icon", "", &stype, &val)
+	|| XrmGetResource(xrdb, "Sxpm.icon", "", &stype, &val)) {
+	iconFile = (char *) val.addr;
+    }
+    if (iconFile) {
+
+	XColor color, junk;
+	Pixel bpix;
+	Window iconW;
+
+	if (XAllocNamedColor(dpy, colormap, "black", &color, &junk))
+	    bpix = color.pixel;
+	else
+	    bpix = XBlackPixelOfScreen(XtScreen(topw));
+
+	iconW = XCreateSimpleWindow(dpy, root, 0, 0,
+				    IWIDTH, IHEIGHT, 1, bpix, bpix);
+
+	icon.attributes.valuemask = XpmReturnAllocPixels;
+	ErrorStatus = XpmReadFileToPixmap(dpy, root, iconFile, &icon.pixmap,
+					  &icon.mask, &icon.attributes);
+	ErrorMessage(ErrorStatus, "Icon");
+
+	XSetWindowBackgroundPixmap(dpy, iconW, icon.pixmap);
+
+	n = 0;
+	XtSetArg(args[n], XtNbackground, bpix);
+	n++;
+	XtSetArg(args[n], XtNiconWindow, iconW);
+	n++;
+	XtSetValues(topw, args, n);
+    }
+
+    /*
+     * arguments parsing
+     */
+
+    command = argv;
+    for (n = 1; n < argc; n++) {
+	if (strcmp(argv[n], "-plaid") == 0) {
+	    stdinf = 0;
+	    continue;
+	}
+	if (argv[n][0] != '-') {
+	    stdinf = 0;
+	    input = argv[n];
+	    continue;
+	}
+	if ((strlen(argv[n]) == 1) && (argv[n][0] == '-'))
+	    /* stdin */
+	    continue;
+	if (strcmp(argv[n], "-o") == 0) {
+	    if (n < argc - 1) {
+		if ((strlen(argv[n + 1]) == 1) && (argv[n + 1][0] == '-'))
+		    stdoutf = 1;
+		else
+		    output = argv[n + 1];
+		n++;
+		continue;
+	    } else
+		Usage();
+	}
+	if (strcmp(argv[n], "-nod") == 0) {
+	    nod = 1;
+	    continue;
+	}
+	if (strcmp(argv[n], "-nom") == 0) {
+	    nom = 1;
+	    continue;
+	}
+	if (strcmp(argv[n], "-sc") == 0) {
+	    if (n < argc - 2) {
+		valuemask |= XpmColorSymbols;
+		symbols[numsymbols].name = argv[++n];
+		symbols[numsymbols++].value = argv[++n];
+		continue;
+	    } else
+		Usage();
+	}
+	if (strcmp(argv[n], "-sp") == 0) {
+	    if (n < argc - 2) {
+		valuemask |= XpmColorSymbols;
+		symbols[numsymbols].name = argv[++n];
+		symbols[numsymbols].value = NULL;
+		symbols[numsymbols++].pixel = atol(argv[++n]);
+		continue;
+	    }
+	}
+	if (strcmp(argv[n], "-cp") == 0) {
+	    if (n < argc - 2) {
+		valuemask |= XpmColorSymbols;
+		symbols[numsymbols].name = NULL;
+		symbols[numsymbols].value = argv[++n];
+		symbols[numsymbols++].pixel = atol(argv[++n]);
+		continue;
+	    }
+	}
+	if (strcmp(argv[n], "-mono") == 0) {
+	    valuemask |= XpmColorKey;
+	    view.attributes.color_key = XPM_MONO;
+	    continue;
+	}
+	if (strcmp(argv[n], "-gray4") == 0 || strcmp(argv[n], "-grey4") == 0) {
+	    valuemask |= XpmColorKey;
+	    view.attributes.color_key = XPM_GRAY4;
+	    continue;
+	}
+	if (strcmp(argv[n], "-gray") == 0 || strcmp(argv[n], "-grey") == 0) {
+	    valuemask |= XpmColorKey;
+	    view.attributes.color_key = XPM_GRAY;
+	    continue;
+	}
+	if (strcmp(argv[n], "-color") == 0) {
+	    valuemask |= XpmColorKey;
+	    view.attributes.color_key = XPM_COLOR;
+	    continue;
+	}
+	if (strncmp(argv[n], "-closecolors", 6) == 0) {
+	    valuemask |= XpmCloseness;
+	    view.attributes.closeness = 40000;
+	    continue;
+	}
+	if (strcmp(argv[n], "-rgb") == 0) {
+	    if (n < argc - 1) {
+		valuemask |= XpmRgbFilename;
+		view.attributes.rgb_fname = argv[++n];
+		continue;
+	    } else
+		Usage();
+
+	}
+	if (strncmp(argv[n], "-version", 4) == 0) {
+	    VersionInfo();
+	    exit(0);
+	}
+	if (strcmp(argv[n], "-v") == 0) {
+	    verbose = 1;
+	    continue;
+	}
+	if (strcmp(argv[n], "-pcmap") == 0) {
+	    valuemask |= XpmColormap;
+	    continue;
+	}
+	Usage();
+    }
+
+    XtRealizeWidget(topw);
+    if (valuemask & XpmColormap) {
+	colormap = XCreateColormap(dpy, win,
+				   DefaultVisual(dpy, DefaultScreen(dpy)),
+				   AllocNone);
+	view.attributes.colormap = colormap;
+	XSetWindowColormap(dpy, win, colormap);
+    }
+    view.attributes.colorsymbols = symbols;
+    view.attributes.numsymbols = numsymbols;
+    view.attributes.valuemask = valuemask;
+
+#ifdef Debug
+    /* this is just to test the XpmCreateDataFromPixmap function */
+
+    view.attributes.valuemask |= XpmReturnAllocPixels;
+    view.attributes.valuemask |= XpmReturnExtensions;
+    ErrorStatus = XpmCreatePixmapFromData(dpy, win, plaid,
+					  &view.pixmap, &view.mask,
+					  &view.attributes);
+    ErrorMessage(ErrorStatus, "Plaid");
+
+    ErrorStatus = XpmCreateDataFromPixmap(dpy, &data, view.pixmap, view.mask,
+					  &view.attributes);
+    ErrorMessage(ErrorStatus, "Data");
+    if (verbose && view.attributes.nextensions) {
+	unsigned int i, j;
+
+	for (i = 0; i < view.attributes.nextensions; i++) {
+	    fprintf(stderr, "Xpm extension : %s\n",
+		    view.attributes.extensions[i].name);
+	    for (j = 0; j < view.attributes.extensions[i].nlines; j++)
+		fprintf(stderr, "\t\t%s\n",
+			view.attributes.extensions[i].lines[j]);
+	}
+    }
+    XFreePixmap(dpy, view.pixmap);
+    if (view.mask)
+	XFreePixmap(dpy, view.mask);
+
+    XFreeColors(dpy, colormap,
+		view.attributes.alloc_pixels,
+		view.attributes.nalloc_pixels, 0);
+
+    XpmFreeAttributes(&view.attributes);
+    view.attributes.valuemask = valuemask;
+#endif
+
+    if (input || stdinf) {
+	view.attributes.valuemask |= XpmReturnInfos;
+	view.attributes.valuemask |= XpmReturnAllocPixels;
+	view.attributes.valuemask |= XpmReturnExtensions;
+
+#ifdef Debug
+	XpmFree(data);
+
+	/*
+	 * this is just to test the XpmCreatePixmapFromBuffer and
+	 * XpmCreateBufferFromPixmap functions
+	 */
+	ErrorStatus = XpmReadFileToBuffer(input, &buffer);
+	ErrorMessage(ErrorStatus, "CreateBufferFromFile");
+
+	ErrorStatus = XpmCreatePixmapFromBuffer(dpy, win, buffer,
+						&view.pixmap, &view.mask,
+						&view.attributes);
+	ErrorMessage(ErrorStatus, "CreatePixmapFromBuffer");
+	XpmFree(buffer);
+	ErrorStatus = XpmCreateBufferFromPixmap(dpy, &buffer,
+						view.pixmap, view.mask,
+						&view.attributes);
+	ErrorMessage(ErrorStatus, "CreateBufferFromPixmap");
+	ErrorStatus = XpmWriteFileFromBuffer("buffer_output", buffer);
+	ErrorMessage(ErrorStatus, "WriteFileFromBuffer");
+	XpmFree(buffer);
+	if (view.pixmap) {
+	    XFreePixmap(dpy, view.pixmap);
+	    if (view.mask)
+		XFreePixmap(dpy, view.mask);
+
+	    XFreeColors(dpy, colormap, view.attributes.alloc_pixels,
+			view.attributes.nalloc_pixels, 0);
+
+	    XpmFreeAttributes(&view.attributes);
+	}
+	ErrorStatus = XpmReadFileToData(input, &data);
+	ErrorMessage(ErrorStatus, "ReadFileToData");
+	ErrorStatus = XpmCreatePixmapFromData(dpy, win, data,
+					      &view.pixmap, &view.mask,
+					      &view.attributes);
+	ErrorMessage(ErrorStatus, "CreatePixmapFromData");
+	ErrorStatus = XpmWriteFileFromData("sxpmout.xpm", data);
+	ErrorMessage(ErrorStatus, "WriteFileFromData");
+	XpmFree(data);
+	XpmFreeAttributes(&view.attributes);
+#endif
+	ErrorStatus = XpmReadFileToPixmap(dpy, win, input,
+					  &view.pixmap, &view.mask,
+					  &view.attributes);
+	ErrorMessage(ErrorStatus, "Read");
+	if (verbose && view.attributes.nextensions) {
+	    unsigned int i, j;
+
+	    for (i = 0; i < view.attributes.nextensions; i++) {
+		/* L10N_Comments : Output when -v & file has extensions 
+		   %s is replaced by extension name */
+		fprintf(stderr, gettext("Xpm extension : %s\n"),
+			view.attributes.extensions[i].name);
+		for (j = 0; j < view.attributes.extensions[i].nlines; j++)
+		    fprintf(stderr, "\t\t%s\n",
+			    view.attributes.extensions[i].lines[j]);
+	    }
+	}
+    } else {
+#ifdef Debug
+	ErrorStatus = XpmCreatePixmapFromData(dpy, win, data,
+					      &view.pixmap, &view.mask,
+					      &view.attributes);
+	XpmFree(data);
+#else
+	ErrorStatus = XpmCreatePixmapFromData(dpy, win, plaid,
+					      &view.pixmap, &view.mask,
+					      &view.attributes);
+#endif
+	ErrorMessage(ErrorStatus, "Plaid");
+    }
+    if (output || stdoutf) {
+	ErrorStatus = XpmWriteFileFromPixmap(dpy, output, view.pixmap,
+					     view.mask, &view.attributes);
+	ErrorMessage(ErrorStatus, "Write");
+    }
+    if (!nod) {
+
+	/*
+	 * manage display if requested
+	 */
+
+	XSizeHints size_hints;
+	char *xString = NULL;
+
+	if (w_rtn && h_rtn
+	    && ((w_rtn < view.attributes.width)
+		|| h_rtn < view.attributes.height)) {
+	    resize = 1;
+	}
+	if (resize) {
+	    XtResizeWidget(topw,
+			   view.attributes.width, view.attributes.height, 1);
+	}
+	if (incResize) {
+	    size_hints.flags = USSize | PMinSize | PResizeInc;
+	    size_hints.height = view.attributes.height;
+	    size_hints.width = view.attributes.width;
+	    size_hints.height_inc = view.attributes.height;
+	    size_hints.width_inc = view.attributes.width;
+	} else
+	    size_hints.flags = PMinSize;
+
+	size_hints.min_height = view.attributes.height;
+	size_hints.min_width = view.attributes.width;
+	XSetWMNormalHints(dpy, win, &size_hints);
+
+	if (input) {
+	    xString = (char *) XtMalloc((sizeof(char) * strlen(input)) + 20);
+	    sprintf(xString, "Sxpm: %s", input);
+	    XStoreName(dpy, win, xString);
+	    XSetIconName(dpy, win, xString);
+	} else if (stdinf) {
+	    XStoreName(dpy, win, "Sxpm: stdin");
+	    XSetIconName(dpy, win, "Sxpm: stdin");
+	} else {
+	    XStoreName(dpy, win, "Sxpm");
+	    XSetIconName(dpy, win, "Sxpm");
+	}
+
+	XtAddEventHandler(topw, KeyPressMask, False,
+			  (XtEventHandler) kinput, NULL);
+	XSetWindowBackgroundPixmap(dpy, win, view.pixmap);
+
+	if (view.mask && !nom)
+	    XShapeCombineMask(dpy, win, ShapeBounding, 0, 0,
+			      view.mask, ShapeSet);
+
+	XClearWindow(dpy, win);
+	XtMapWidget(topw);
+	if (xString)
+	    XtFree(xString);
+	XtMainLoop();
+    }
+    Punt(0);
+
+    /* Muffle gcc */
+    return 0;
+}
+
+void
+Usage(void)
+{
+    /* L10N_Comments : Usage message (sxpm -h) in two parts. 
+       In the first part %s is replaced by the command name. */
+    fprintf(stderr, gettext("\nUsage:  %s [options...]\n"), command[0]);
+    fprintf(stderr, gettext("Where options are:\n\
+\n\
+[-d host:display]            Display to connect to.\n\
+[-g geom]                    Geometry of window.\n\
+[-hints]                     Set ResizeInc for window.\n\
+[-icon filename]             Set pixmap for iconWindow.\n\
+[-plaid]                     Read the included plaid pixmap.\n\
+[filename]                   Read from file 'filename', and from standard\n\
+                             input if 'filename' is '-'.\n\
+[-o filename]                Write to file 'filename', and to standard\n\
+                             output if 'filename' is '-'.\n\
+[-pcmap]                     Use a private colormap.\n\
+[-closecolors]               Try to use `close' colors.\n\
+[-nod]                       Don't display in window.\n\
+[-nom]                       Don't use clip mask if any.\n\
+[-mono]                      Use the colors specified for a monochrome visual.\n\
+[-grey4]                     Use the colors specified for a 4 greyscale visual.\n\
+[-grey]                      Use the colors specified for a greyscale visual.\n\
+[-color]                     Use the colors specified for a color visual.\n\
+[-sc symbol color]           Override color defaults.\n\
+[-sp symbol pixel]           Override color defaults.\n\
+[-cp color pixel]            Override color defaults.\n\
+[-rgb filename]              Search color names in the rgb text file 'filename'.\n\
+[-v]                         Verbose - print out extensions.\n\
+[-version]                   Print out program's version number\n\
+                             and library's version number if different.\n\
+if no input is specified sxpm reads from standard input.\n\
+\n"));
+    exit(0);
+}
+
+
+void
+ErrorMessage(
+    int		 ErrorStatus,
+    char	*tag)
+{
+    char *error = NULL;
+    char *warning = NULL;
+
+    switch (ErrorStatus) {
+    case XpmSuccess:
+	return;
+    case XpmColorError:
+/* L10N_Comments : The following set of messages are classified as 
+   either errors or warnings.  Based on the class of message, different
+   wrappers are selected at the end to state the message source & class. 
+
+	   L10N_Comments : WARNING produced when filename can be read, but
+	   contains an invalid color specification (need to create test case)*/
+	warning = gettext("Could not parse or alloc requested color");
+	break;
+    case XpmOpenFailed:
+	/* L10N_Comments : ERROR produced when filename does not exist 
+	   or insufficient permissions to open (i.e. sxpm /no/such/file ) */
+	error = gettext("Cannot open file");
+	break;
+    case XpmFileInvalid:
+	/* L10N_Comments : ERROR produced when filename can be read, but
+	   is not an XPM file (i.e. sxpm /dev/null ) */
+	error = gettext("Invalid XPM file");
+	break;
+    case XpmNoMemory:
+	/* L10N_Comments : ERROR produced when filename can be read, but
+	   is too big for memory 
+	   (i.e. limit datasize 32 ; sxpm /usr/dt/backdrops/Crochet.pm ) */
+	error = gettext("Not enough memory");
+	break;
+    case XpmColorFailed:
+	/* L10N_Comments : ERROR produced when filename can be read, but
+	   contains an invalid color specification (need to create test case)*/
+	error = gettext("Failed to parse or alloc some color");
+	break;
+    }
+
+    if (warning)
+	/* L10N_Comments : Wrapper around above WARNING messages.
+	   First %s is the tag for the operation that produced the warning.
+	   Second %s is the message selected from the above set. */
+	fprintf(stderr, gettext("%s Xpm Warning: %s.\n"), tag, warning);
+
+    if (error) {
+	/* L10N_Comments : Wrapper around above ERROR messages.
+	   First %s is the tag for the operation that produced the error.
+	   Second %s is the message selected from the above set */
+	fprintf(stderr, gettext("%s Xpm Error: %s.\n"), tag, error);
+	Punt(1);
+    }
+}
+
+void
+Punt(int i)
+{
+    if (icon.pixmap) {
+	XFreePixmap(dpy, icon.pixmap);
+	if (icon.mask)
+	    XFreePixmap(dpy, icon.mask);
+
+	XFreeColors(dpy, colormap,
+		    icon.attributes.alloc_pixels,
+		    icon.attributes.nalloc_pixels, 0);
+
+	XpmFreeAttributes(&icon.attributes);
+    }
+    if (view.pixmap) {
+	XFreePixmap(dpy, view.pixmap);
+	if (view.mask)
+	    XFreePixmap(dpy, view.mask);
+
+	XFreeColors(dpy, colormap,
+		    view.attributes.alloc_pixels,
+		    view.attributes.nalloc_pixels, 0);
+
+	XpmFreeAttributes(&view.attributes);
+    }
+    exit(i);
+}
+
+void
+kinput(
+    Widget	 widget,
+    char	*tag,
+    XEvent	*xe,
+    Boolean	*b)
+{
+    char c = '\0';
+
+    XLookupString(&(xe->xkey), &c, 1, NULL, NULL);
+    if (c == 'q' || c == 'Q')
+	Punt(0);
+}
+
+/*
+ * small function to extract various version numbers from the given global
+ * number (following the rule described in xpm.h).
+ */
+void
+GetNumbers(
+    int		 num,
+    int		*format_return,
+    int		*libmajor_return,
+    char	*libminor_return)
+{
+    *format_return = num / 10000;
+    *libmajor_return = (num % 10000) / 100;
+    *libminor_return = 'a' + (num % 10000) % 100 - 1;
+}
+
+void
+VersionInfo(void)
+{
+    int format, libmajor;
+    char libminor;
+
+    GetNumbers(XpmIncludeVersion, &format, &libmajor, &libminor);
+    /* L10N_Comments : sxpm -version output */
+    fprintf(stderr, gettext("sxpm version: %d.%d%c\n"),
+	    format, libmajor, libminor);
+    /* L10N_Comments :
+     * if we are linked to an XPM library different from the one we've been
+     * compiled with, print its own number too when sxpm -version is called.
+     */
+    if (XpmIncludeVersion != XpmLibraryVersion()) {
+	GetNumbers(XpmLibraryVersion(), &format, &libmajor, &libminor);
+	fprintf(stderr, gettext("using the XPM library version: %d.%d%c\n"),
+		format, libmajor, libminor);
+    }
+}
diff --git a/libXpm/sxpm/sxpm.man b/libXpm/sxpm/sxpm.man
index 0f539e772..49cf3066a 100644
--- a/libXpm/sxpm/sxpm.man
+++ b/libXpm/sxpm/sxpm.man
@@ -1,131 +1,131 @@
-.\"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.

-.\"

-.nr )S 12

-.TH SXPM 1

-.PD

-.ad b

-.SH NAME

-sxpm \- Show an XPM (X PixMap) file and/or convert XPM 1 or 2 files to XPM 3.

-.SH SYNOPSIS

-\fBsxpm\fR

-[\|\fB-d\fR displayname\|] 

-[\|\fB-g\fR geometry\|] 

-[\|\fB-hints\fR\|] 

-[\|\fB-icon\fR filename\|] 

-[\|\fB-plaid\| | \|\fRfilename\| | \|-\|]

-[\|\fB-o\fR filename\| | \|\fB-o\fR -\|] 

-[\|\fB-pcmap\fR\|] 

-[\|\fB-closecolors\fR\|] 

-[\|\fB-nod\fR\|] 

-[\|\fB-nom\fR\|] 

-[\|\fB-mono | -grey4 | -grey | -color\fR\|] 

-[\|\fB-sc\fR symbol color\|] 

-[\|\fB-sp\fR symbol pixel\|] 

-[\|\fB-cp\fR color pixel\|] 

-[\|\fB-rgb\fR filename\|] 

-[\|\fB-v\fR\|] 

-.SH DESCRIPTION

-.PP

-The \fIsxpm\fP program can be used to view any XPM (version 1, 2, or 3) file

-and/or to convert a file from XPM1 or XPM2 to XPM version 3. If \fIsxpm\fP is

-run with any dummy option specified, the usage is displayed. If no geometry is

-specified, the show window will have the size of the read pixmap. Pressing the

-key Q in the window will quit the program.

-.SH OPTIONS

-.TP 8

-.B \-d \fIdisplay\fP

-Specifies the display to connect to.

-.TP 8

-.B \-g \fIgeom\fP

-Window geometry (default is pixmap's size).

-.TP 8

-.B \-hints

-Set ResizeInc for window.

-.TP 8

-.B \-icon \fIfilename\fP

-Set icon to pixmap created from the file \fIfilename\fP.

-.TP 8

-.B \-plaid

-Show the plaid pixmap which is stored as data\fP.

-.TP 8

-.B \fIfilename\fP

-Read from the file \fIfilename\fP and from standard input if \fIfilename\fP is '-'.

-If no input is specified sxpm reads from standard input.

-.TP 8

-.B \-o \fIfilename\fP

-Write to the file \fIfilename\fP (overwrite if it already exists) and to

-standard output if \fIfilename\fP is '-'.

-.TP 8

-.B \-mono

-Use the colors specified for a monochrome visual.

-.TP 8

-.B \-grey4

-Use the colors specified for a 4 color greyscale visual.

-.TP 8

-.B \-grey

-Use the colors specified for a greyscale visual.

-.TP 8

-.B \-color

-Use the colors specified for a color visual.

-.TP 8

-.B \-pcmap

-Use a private colormap.

-.TP 8

-.B \-closecolors

-Try to use "close colors" before reverting to other visuals.

-.TP 8

-.B \-nod

-Do not display the pixmap in a window.  (Useful when using as converter)

-.TP 8

-.B \-nom

-Do not use the clipmask if there is any.

-.TP 8

-.B \-sc \fIsymbol colorname\fP

-Override default color to \fIsymbol\fP to \fIcolorname\fP.

-.TP 8

-.B \-sp \fIsymbol pixelvalue\fP

-Override default color to \fIsymbol\fP to \fIpixelvalue\fP.

-.TP 8

-.B \-cp \fIcolorname pixelvalue\fP

-Override default color to \fIcolorname\fP to \fIpixelvalue\fP.

-.TP 8

-.B \-rgb \fIfilename\fP

-Search color names in the file \fIfilename\fP and write them out instead of

-the rgb values.

-.TP 8

-.B \-v

-Verbose - to print out extensions (stderr).

-

-

-.SH KNOWN BUGS

-Some window managers may not accept a pixmap which is not a bitmap as icon

-because this does not respect ICCCM, many of the well known ones will accept

-it though.

-

-.SH AUTHOR

-Arnaud Le Hors    (lehors@sophia.inria.fr)

-.br

-Bull Research France

-.br

-Copyright (C) 1989-95 by Groupe Bull.

+.\"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.
+.\"
+.nr )S 12
+.TH SXPM 1
+.PD
+.ad b
+.SH NAME
+sxpm \- Show an XPM (X PixMap) file and/or convert XPM 1 or 2 files to XPM 3.
+.SH SYNOPSIS
+\fBsxpm\fR
+[\|\fB-d\fR displayname\|] 
+[\|\fB-g\fR geometry\|] 
+[\|\fB-hints\fR\|] 
+[\|\fB-icon\fR filename\|] 
+[\|\fB-plaid\| | \|\fRfilename\| | \|-\|]
+[\|\fB-o\fR filename\| | \|\fB-o\fR -\|] 
+[\|\fB-pcmap\fR\|] 
+[\|\fB-closecolors\fR\|] 
+[\|\fB-nod\fR\|] 
+[\|\fB-nom\fR\|] 
+[\|\fB-mono | -grey4 | -grey | -color\fR\|] 
+[\|\fB-sc\fR symbol color\|] 
+[\|\fB-sp\fR symbol pixel\|] 
+[\|\fB-cp\fR color pixel\|] 
+[\|\fB-rgb\fR filename\|] 
+[\|\fB-v\fR\|] 
+.SH DESCRIPTION
+.PP
+The \fIsxpm\fP program can be used to view any XPM (version 1, 2, or 3) file
+and/or to convert a file from XPM1 or XPM2 to XPM version 3. If \fIsxpm\fP is
+run with any dummy option specified, the usage is displayed. If no geometry is
+specified, the show window will have the size of the read pixmap. Pressing the
+key Q in the window will quit the program.
+.SH OPTIONS
+.TP 8
+.B \-d \fIdisplay\fP
+Specifies the display to connect to.
+.TP 8
+.B \-g \fIgeom\fP
+Window geometry (default is pixmap's size).
+.TP 8
+.B \-hints
+Set ResizeInc for window.
+.TP 8
+.B \-icon \fIfilename\fP
+Set icon to pixmap created from the file \fIfilename\fP.
+.TP 8
+.B \-plaid
+Show the plaid pixmap which is stored as data\fP.
+.TP 8
+.B \fIfilename\fP
+Read from the file \fIfilename\fP and from standard input if \fIfilename\fP is '-'.
+If no input is specified sxpm reads from standard input.
+.TP 8
+.B \-o \fIfilename\fP
+Write to the file \fIfilename\fP (overwrite if it already exists) and to
+standard output if \fIfilename\fP is '-'.
+.TP 8
+.B \-mono
+Use the colors specified for a monochrome visual.
+.TP 8
+.B \-grey4
+Use the colors specified for a 4 color greyscale visual.
+.TP 8
+.B \-grey
+Use the colors specified for a greyscale visual.
+.TP 8
+.B \-color
+Use the colors specified for a color visual.
+.TP 8
+.B \-pcmap
+Use a private colormap.
+.TP 8
+.B \-closecolors
+Try to use "close colors" before reverting to other visuals.
+.TP 8
+.B \-nod
+Do not display the pixmap in a window.  (Useful when using as converter)
+.TP 8
+.B \-nom
+Do not use the clipmask if there is any.
+.TP 8
+.B \-sc \fIsymbol colorname\fP
+Override default color to \fIsymbol\fP to \fIcolorname\fP.
+.TP 8
+.B \-sp \fIsymbol pixelvalue\fP
+Override default color to \fIsymbol\fP to \fIpixelvalue\fP.
+.TP 8
+.B \-cp \fIcolorname pixelvalue\fP
+Override default color to \fIcolorname\fP to \fIpixelvalue\fP.
+.TP 8
+.B \-rgb \fIfilename\fP
+Search color names in the file \fIfilename\fP and write them out instead of
+the rgb values.
+.TP 8
+.B \-v
+Verbose - to print out extensions (stderr).
+
+
+.SH KNOWN BUGS
+Some window managers may not accept a pixmap which is not a bitmap as icon
+because this does not respect ICCCM, many of the well known ones will accept
+it though.
+
+.SH AUTHOR
+Arnaud Le Hors    (lehors@sophia.inria.fr)
+.br
+Bull Research France
+.br
+Copyright (C) 1989-95 by Groupe Bull.