X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/8cbd2bdeff7178c343d4f5832f5d83aa37d89ca1..6342bd1ab36c1957684c00d408d09fba65d33db6:/src/xpm/dataxpm.c

diff --git a/src/xpm/dataxpm.c b/src/xpm/dataxpm.c
index 247f8aaa09..917614e4be 100644
--- a/src/xpm/dataxpm.c
+++ b/src/xpm/dataxpm.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1989-94 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
@@ -32,129 +32,140 @@
 *  Developed by Arnaud Le Hors                                                *
 \*****************************************************************************/
 
+#ifndef CXPMPROG
 /* Official version number */
-static char *RCS_Version = "$XpmVersion: 3.4b $";
+static char *RCS_Version = "$XpmVersion: 3.4k $";
 
 /* Internal version number */
 static char *RCS_Id = "$Id$";
 
-#include "xpm34p.h"
-#ifdef VMS
-#include "sys$library:stat.h"
-#include "sys$library:ctype.h"
-#else
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <ctype.h>
+#include "XpmI.h"
 #endif
+#include <ctype.h>
 
-#include <string.h>
-
-LFUNC(ParseComment, int, (xpmData * mdata));
+#ifndef CXPMPROG
+#define Getc(data, file) getc(file)
+#define Ungetc(data, c, file) ungetc(c, file)
+#endif
 
 static int
-ParseComment(xpmData *mdata)
+ParseComment(data)
+    xpmData *data;
 {
-    if (mdata->type == XPMBUFFER) {
+    if (data->type == XPMBUFFER) {
 	register char c;
 	register unsigned int n = 0;
 	unsigned int notend;
 	char *s, *s2;
 
-	s = mdata->Comment;
-	*s = mdata->Bcmt[0];
+	s = data->Comment;
+	*s = data->Bcmt[0];
 
 	/* skip the string beginning comment */
-	s2 = mdata->Bcmt;
+	s2 = data->Bcmt;
 	do {
-	    c = *mdata->cptr++;
+	    c = *data->cptr++;
 	    *++s = c;
 	    n++;
 	    s2++;
-	} while (c == *s2 && *s2 != '\0' && c && c != mdata->Bos);
+	} while (c == *s2 && *s2 != '\0' && c);
 
 	if (*s2 != '\0') {
 	    /* this wasn't the beginning of a comment */
-	    mdata->cptr -= n;
+	    data->cptr -= n;
 	    return 0;
 	}
 	/* store comment */
-	mdata->Comment[0] = *s;
-	s = mdata->Comment;
+	data->Comment[0] = *s;
+	s = data->Comment;
 	notend = 1;
 	n = 0;
 	while (notend) {
-	    s2 = mdata->Ecmt;
-	    while (*s != *s2 && c && c != mdata->Bos) {
-		c = *mdata->cptr++;
+	    s2 = data->Ecmt;
+	    while (*s != *s2 && c) {
+		c = *data->cptr++;
+		if (n == XPMMAXCMTLEN - 1)  { /* forget it */
+		    s = data->Comment;
+		    n = 0;
+		}
 		*++s = c;
 		n++;
 	    }
-	    mdata->CommentLength = n;
+	    data->CommentLength = n;
 	    do {
-		c = *mdata->cptr++;
-		n++;
+		c = *data->cptr++;
+		if (n == XPMMAXCMTLEN - 1)  { /* forget it */
+		    s = data->Comment;
+		    n = 0;
+		}
 		*++s = c;
+		n++;
 		s2++;
-	    } while (c == *s2 && *s2 != '\0' && c && c != mdata->Bos);
+	    } while (c == *s2 && *s2 != '\0' && c);
 	    if (*s2 == '\0') {
 		/* this is the end of the comment */
 		notend = 0;
-		mdata->cptr--;
+		data->cptr--;
 	    }
 	}
 	return 0;
     } else {
-	FILE *file = mdata->stream.file;
+	FILE *file = data->stream.file;
 	register int c;
 	register unsigned int n = 0, a;
 	unsigned int notend;
 	char *s, *s2;
 
-	s = mdata->Comment;
-	*s = mdata->Bcmt[0];
+	s = data->Comment;
+	*s = data->Bcmt[0];
 
 	/* skip the string beginning comment */
-	s2 = mdata->Bcmt;
+	s2 = data->Bcmt;
 	do {
-	    c = getc(file);
+	    c = Getc(data, file);
 	    *++s = c;
 	    n++;
 	    s2++;
-	} while (c == *s2 && *s2 != '\0'
-		 && c != EOF && c != mdata->Bos);
+	} 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(*s, file);
+		Ungetc(data, *s, file);
 	    return 0;
 	}
 	/* store comment */
-	mdata->Comment[0] = *s;
-	s = mdata->Comment;
+	data->Comment[0] = *s;
+	s = data->Comment;
 	notend = 1;
 	n = 0;
 	while (notend) {
-	    s2 = mdata->Ecmt;
-	    while (*s != *s2 && c != EOF && c != mdata->Bos) {
-		c = getc(file);
+	    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++;
 	    }
-	    mdata->CommentLength = n;
+	    data->CommentLength = n;
 	    do {
-		c = getc(file);
-		n++;
+		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 && c != mdata->Bos);
+	    } while (c == *s2 && *s2 != '\0' && c != EOF);
 	    if (*s2 == '\0') {
 		/* this is the end of the comment */
 		notend = 0;
-		ungetc(*s, file);
+		Ungetc(data, *s, file);
 	    }
 	}
 	return 0;
@@ -165,142 +176,146 @@ ParseComment(xpmData *mdata)
  * skip to the end of the current string and the beginning of the next one
  */
 int
-xpmNextString(xpmData *mdata)
+xpmNextString(data)
+    xpmData *data;
 {
-    if (!mdata->type)
-	mdata->cptr = (mdata->stream.data)[++mdata->line];
-    else if (mdata->type == XPMBUFFER) {
+    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 (mdata->Eos)
-	    while ((c = *mdata->cptr++) && c != mdata->Eos);
+	if (data->Eos)
+	    while ((c = *data->cptr++) && c != data->Eos);
 
 	/*
 	 * then get to the beginning of the next string looking for possible
 	 * comment
 	 */
-	if (mdata->Bos) {
-	    while ((c = *mdata->cptr++) && c != mdata->Bos)
-		if (mdata->Bcmt && c == mdata->Bcmt[0])
-		    ParseComment(mdata);
-	} else if (mdata->Bcmt) {	/* XPM2 natural */
-	    while ((c = *mdata->cptr++) == mdata->Bcmt[0])
-		ParseComment(mdata);
-	    mdata->cptr--;
+	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 = mdata->stream.file;
+	FILE *file = data->stream.file;
 
 	/* get to the end of the current string */
-	if (mdata->Eos)
-	    while ((c = getc(file)) != mdata->Eos && c != EOF);
+	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 (mdata->Bos) {
-	    while ((c = getc(file)) != mdata->Bos && c != EOF)
-		if (mdata->Bcmt && c == mdata->Bcmt[0])
-		    ParseComment(mdata);
-
-	} else if (mdata->Bcmt) {	/* XPM2 natural */
-	    while ((c = getc(file)) == mdata->Bcmt[0])
-		ParseComment(mdata);
-	    ungetc(c, file);
+	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 compute the following unsigned int,
- * returns 1 if one is found and 0 if not
- */
-int
-xpmNextUI(xpmData *mdata, unsigned int *ui_return)
-{
-    char buf[BUFSIZ];
-    int l;
-
-    l = xpmNextWord(mdata, buf, BUFSIZ);
-    return atoui(buf, l, ui_return);
-}
-
 /*
  * skip whitespace and return the following word
  */
 unsigned int
-xpmNextWord(xpmData *mdata, char *buf, unsigned int buflen)
+xpmNextWord(data, buf, buflen)
+    xpmData *data;
+    char *buf;
+    unsigned int buflen;
 {
     register unsigned int n = 0;
     int c;
 
-    if (!mdata->type || mdata->type == XPMBUFFER) {
-	while (isspace(c = *mdata->cptr) && c != mdata->Eos)
-	    mdata->cptr++;
+    if (!data->type || data->type == XPMBUFFER) {
+	while (isspace(c = *data->cptr) && c != data->Eos)
+	    data->cptr++;
 	do {
-	    c = *mdata->cptr++;
+	    c = *data->cptr++;
 	    *buf++ = c;
 	    n++;
-	} while (!isspace(c) && c != mdata->Eos && n < buflen);
+	} while (!isspace(c) && c != data->Eos && n < buflen);
 	n--;
-	mdata->cptr--;
+	data->cptr--;
     } else {
-	FILE *file = mdata->stream.file;
+	FILE *file = data->stream.file;
 
-	while ((c = getc(file)) != EOF && isspace(c) && c != mdata->Eos);
-	while (!isspace(c) && c != mdata->Eos && c != EOF && n < buflen) {
+	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(file);
+	    c = Getc(data, file);
 	}
-	ungetc(c, file);
+	Ungetc(data, c, file);
     }
     return (n);
 }
 
+/*
+ * skip whitespace and compute the following unsigned int,
+ * returns 1 if one is found and 0 if not
+ */
+int
+xpmNextUI(data, ui_return)
+    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 *mdata, char **sptr, unsigned int *l)
+xpmGetString(data, sptr, l)
+    xpmData *data;
+    char **sptr;
+    unsigned int *l;
 {
     unsigned int i, n = 0;
     int c;
-    char *p, *q, buf[BUFSIZ];
-
-    if (!mdata->type || mdata->type == XPMBUFFER) {
-	if (mdata->cptr) {
-	    char *start;
-
-	    while (isspace(c = *mdata->cptr) && c != mdata->Eos)
-		mdata->cptr++;
-	    start = mdata->cptr;
-	    while ((c = *mdata->cptr) && c != mdata->Eos)
-		mdata->cptr++;
-	    n = mdata->cptr - start + 1;
+    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 (mdata->type)		/* XPMBUFFER */
+	    if (data->type)		/* XPMBUFFER */
 		p[n - 1] = '\0';
 	}
     } else {
-	FILE *file = mdata->stream.file;
+	FILE *file = data->stream.file;
 
-	while ((c = getc(file)) != EOF && isspace(c) && c != mdata->Eos);
-	if (c == EOF)
+	if ((c = Getc(data, file)) == EOF)
 	    return (XpmFileInvalid);
-	p = NULL;
+
 	i = 0;
 	q = buf;
 	p = (char *) XpmMalloc(1);
-	while (c != mdata->Eos && c != EOF) {
+	while (c != data->Eos && c != EOF) {
 	    if (i == BUFSIZ) {
 		/* get to the end of the buffer */
 		/* malloc needed memory */
@@ -319,7 +334,7 @@ xpmGetString(xpmData *mdata, char **sptr, unsigned int *l)
 	    }
 	    *q++ = c;
 	    i++;
-	    c = getc(file);
+	    c = Getc(data, file);
 	}
 	if (c == EOF) {
 	    XpmFree(p);
@@ -342,7 +357,7 @@ xpmGetString(xpmData *mdata, char **sptr, unsigned int *l)
 	    *p = '\0';
 	    n = 1;
 	}
-	ungetc(c, file);
+	Ungetc(data, c, file);
     }
     *sptr = p;
     *l = n;
@@ -353,187 +368,22 @@ xpmGetString(xpmData *mdata, char **sptr, unsigned int *l)
  * get the current comment line
  */
 int
-xpmGetCmt(xpmData *mdata, char **cmt)
+xpmGetCmt(data, cmt)
+    xpmData *data;
+    char **cmt;
 {
-    if (!mdata->type)
+    if (!data->type)
 	*cmt = NULL;
-    else if (mdata->CommentLength) {
-	*cmt = (char *) XpmMalloc(mdata->CommentLength + 1);
-	strncpy(*cmt, mdata->Comment, mdata->CommentLength);
-	(*cmt)[mdata->CommentLength] = '\0';
-	mdata->CommentLength = 0;
+    else if (data->CommentLength) {
+	*cmt = (char *) XpmMalloc(data->CommentLength + 1);
+	strncpy(*cmt, data->Comment, data->CommentLength);
+	(*cmt)[data->CommentLength] = '\0';
+	data->CommentLength = 0;
     } else
 	*cmt = NULL;
     return 0;
 }
 
-/*
- * open the given file to be read as an xpmData which is returned.
- */
-int
-xpmReadFile(char *filename, xpmData *mdata)
-{
-#ifdef ZPIPE
-    char *compressfile, buf[BUFSIZ];
-    struct stat status;
-
-#endif
-
-    if (!filename) {
-	mdata->stream.file = (stdin);
-	mdata->type = XPMFILE;
-    } else {
-#ifdef ZPIPE
-	if (((int) strlen(filename) > 2) &&
-	    !strcmp(".Z", filename + (strlen(filename) - 2))) {
-	    mdata->type = XPMPIPE;
-	    sprintf(buf, "uncompress -c %s", filename);
-	    if (!(mdata->stream.file = popen(buf, "r")))
-		return (XpmOpenFailed);
-
-	} else if (((int) strlen(filename) > 3) &&
-		   !strcmp(".gz", filename + (strlen(filename) - 3))) {
-	    mdata->type = XPMPIPE;
-	    sprintf(buf, "gunzip -qc %s", filename);
-	    if (!(mdata->stream.file = popen(buf, "r")))
-		return (XpmOpenFailed);
-
-	} else {
-	    if (!(compressfile = (char *) XpmMalloc(strlen(filename) + 4)))
-		return (XpmNoMemory);
-
-	    strcpy(compressfile, filename);
-	    strcat(compressfile, ".Z");
-	    if (!stat(compressfile, &status)) {
-		sprintf(buf, "uncompress -c %s", compressfile);
-		if (!(mdata->stream.file = popen(buf, "r"))) {
-		    XpmFree(compressfile);
-		    return (XpmOpenFailed);
-		}
-		mdata->type = XPMPIPE;
-	    } else {
-		strcpy(compressfile, filename);
-		strcat(compressfile, ".gz");
-		if (!stat(compressfile, &status)) {
-		    sprintf(buf, "gunzip -c %s", compressfile);
-		    if (!(mdata->stream.file = popen(buf, "r"))) {
-			XpmFree(compressfile);
-			return (XpmOpenFailed);
-		    }
-		    mdata->type = XPMPIPE;
-		} else {
-#endif
-		    if (!(mdata->stream.file = fopen(filename, "r"))) {
-#ifdef ZPIPE
-			XpmFree(compressfile);
-#endif
-			return (XpmOpenFailed);
-		    }
-		    mdata->type = XPMFILE;
-#ifdef ZPIPE
-		}
-	    }
-	    XpmFree(compressfile);
-	}
-#endif
-    }
-    mdata->CommentLength = 0;
-    return (XpmSuccess);
-}
-
-/*
- * open the given file to be written as an xpmData which is returned
- */
-int
-xpmWriteFile(char *filename, xpmData *mdata)
-{
-#ifdef ZPIPE
-    char buf[BUFSIZ];
-
-#endif
-
-    if (!filename) {
-	mdata->stream.file = (stdout);
-	mdata->type = XPMFILE;
-    } else {
-#ifdef ZPIPE
-	if ((int) strlen(filename) > 2
-	    && !strcmp(".Z", filename + (strlen(filename) - 2))) {
-	    sprintf(buf, "compress > %s", filename);
-	    if (!(mdata->stream.file = popen(buf, "w")))
-		return (XpmOpenFailed);
-
-	    mdata->type = XPMPIPE;
-	} else if ((int) strlen(filename) > 3
-		   && !strcmp(".gz", filename + (strlen(filename) - 3))) {
-	    sprintf(buf, "gzip -q > %s", filename);
-	    if (!(mdata->stream.file = popen(buf, "w")))
-		return (XpmOpenFailed);
-
-	    mdata->type = XPMPIPE;
-	} else {
-#endif
-	    if (!(mdata->stream.file = fopen(filename, "w")))
-		return (XpmOpenFailed);
-
-	    mdata->type = XPMFILE;
-#ifdef ZPIPE
-	}
-#endif
-    }
-    return (XpmSuccess);
-}
-
-/*
- * open the given array to be read or written as an xpmData which is returned
- */
-void
-xpmOpenArray(char **data, xpmData *mdata)
-{
-    mdata->type = XPMARRAY;
-    mdata->stream.data = data;
-    mdata->cptr = *data;
-    mdata->line = 0;
-    mdata->CommentLength = 0;
-    mdata->Bcmt = mdata->Ecmt = NULL;
-    mdata->Bos = mdata->Eos = '\0';
-    mdata->format = 0;			/* this can only be Xpm 2 or 3 */
-}
-
-/*
- * open the given buffer to be read or written as an xpmData which is returned
- */
-void
-xpmOpenBuffer(char *buffer, xpmData *mdata)
-{
-    mdata->type = XPMBUFFER;
-    mdata->cptr = buffer;
-    mdata->CommentLength = 0;
-}
-
-/*
- * close the file related to the xpmData if any
- */
-int
-xpmDataClose(xpmData *mdata)
-{
-    switch (mdata->type) {
-    case XPMARRAY:
-    case XPMBUFFER:
-	break;
-    case XPMFILE:
-	if (mdata->stream.file != (stdout) && mdata->stream.file != (stdin))
-	    fclose(mdata->stream.file);
-	break;
-#ifdef ZPIPE
-    case XPMPIPE:
-	pclose(mdata->stream.file);
-	break;
-#endif
-    }
-    return 0;
-}
-
 xpmDataType xpmDataTypes[] =
 {
     "", "!", "\n", '\0', '\n', "", "", "", "",	/* Natural type */
@@ -550,28 +400,30 @@ xpmDataType xpmDataTypes[] =
  * parse xpm header
  */
 int
-xpmParseHeader(xpmData *mdata)
+xpmParseHeader(data)
+    xpmData *data;
 {
     char buf[BUFSIZ];
     int l, n = 0;
 
-    if (mdata->type) {
-	mdata->Bos = '\0';
-	mdata->Eos = '\n';
-	mdata->Bcmt = mdata->Ecmt = NULL;
-	l = xpmNextWord(mdata, buf, BUFSIZ);
+    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(mdata, buf, BUFSIZ);
+	    l = xpmNextWord(data, buf, BUFSIZ);
 	    if (!l)
 		return (XpmFileInvalid);
-	    ptr = strchr(buf, '_');
+	    buf[l] = '\0';
+	    ptr = rindex(buf, '_');
 	    if (!ptr || strncmp("_format", ptr, l - (ptr - buf)))
 		return XpmFileInvalid;
 	    /* this is definitely an XPM 1 file */
-	    mdata->format = 1;
+	    data->format = 1;
 	    n = 1;			/* handle XPM1 as mainly XPM2 C */
 	} else {
 
@@ -579,14 +431,14 @@ xpmParseHeader(xpmData *mdata)
 	     * skip the first word, get the second one, and see if this is
 	     * XPM 2 or 3
 	     */
-	    l = xpmNextWord(mdata, buf, BUFSIZ);
+	    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(mdata, buf, BUFSIZ);
+		    l = xpmNextWord(data, buf, BUFSIZ);
 
 		    /*
 		     * get infos about this type
@@ -595,29 +447,29 @@ xpmParseHeader(xpmData *mdata)
 			   && strncmp(xpmDataTypes[n].type, buf, l))
 			n++;
 		}
-		mdata->format = 0;
+		data->format = 0;
 	    } else
 		/* nope this is not an XPM file */
 		return XpmFileInvalid;
 	}
 	if (xpmDataTypes[n].type) {
 	    if (n == 0) {		/* natural type */
-		mdata->Bcmt = xpmDataTypes[n].Bcmt;
-		mdata->Ecmt = xpmDataTypes[n].Ecmt;
-		xpmNextString(mdata);	/* skip the end of the headerline */
-		mdata->Bos = xpmDataTypes[n].Bos;
-		mdata->Eos = xpmDataTypes[n].Eos;
+		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 {
-		mdata->Bcmt = xpmDataTypes[n].Bcmt;
-		mdata->Ecmt = xpmDataTypes[n].Ecmt;
-		if (!mdata->format) {	/* XPM 2 or 3 */
-		    mdata->Bos = xpmDataTypes[n].Bos;
-		    mdata->Eos = '\0';
+		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(mdata);
-		    mdata->Eos = xpmDataTypes[n].Eos;
+		    xpmNextString(data);
+		    data->Eos = xpmDataTypes[n].Eos;
 		} else			/* XPM 1 skip end of line */
-		    xpmNextString(mdata);
+		    xpmNextString(data);
 	    }
 	} else
 	    /* we don't know about that type of XPM file... */