/* xpmtoppm.c - convert XPM file (X11 pixmap) to PPM

   Copyright and history information is at end of file

*/

#define _DEFAULT_SOURCE /* New name for SVID & BSD source defines */

#define _BSD_SOURCE   /* Make sure strdup() is in string.h */

#define _XOPEN_SOURCE 500  /* Make sure strdup() is in string.h */

#include <assert.h>

#include <string.h>

#include "pm_c_util.h"

#include "mallocvar.h"

#include "shhopt.h"

#include "nstring.h"

#include "ppm.h"

#define MAX_LINE (8 * 1024)

  /* The maximum size XPM input line we can handle. */

/* number of xpmColorKeys */

#define NKEYS 5

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

};

struct cmdlineInfo {

    /* All the information the user supplied in the command line,

       in a form easy for the program to use.

    */

    const char * input_filespec;  /* Filespecs of input files */

    const char * alpha_filename;

    int alpha_stdout;

    int verbose;

};

static bool verbose;

static void

parseCommandLine(int argc, char ** argv,

                 struct cmdlineInfo *cmdlineP) {

/*----------------------------------------------------------------------------

   Note that the file spec array we return is stored in the storage that

   was passed to us as the argv array.

-----------------------------------------------------------------------------*/

    optEntry * option_def;

        /* Instructions to OptParseOptions2 on how to parse our options.

         */

    optStruct3 opt;

    unsigned int option_def_index;

    MALLOCARRAY_NOFAIL(option_def, 100);

    option_def_index = 0;   /* incremented by OPTENT3 */

    OPTENT3(0,   "alphaout",   OPT_STRING, &cmdlineP->alpha_filename,

            NULL, 0);

    OPTENT3(0,   "verbose",    OPT_FLAG,   &cmdlineP->verbose,

            NULL, 0);

    cmdlineP->alpha_filename = NULL;

    cmdlineP->verbose = FALSE;

    opt.opt_table = option_def;

    opt.short_allowed = FALSE;  /* We have no short (old-fashioned) options */

    opt.allowNegNum = TRUE;  /* We may have parms that are negative numbers */

    pm_optParseOptions3(&argc, argv, opt, sizeof(opt), 0);

        /* Uses and sets argc, argv, and some of *cmdlineP and others. */

    if (argc - 1 == 0)

        cmdlineP->input_filespec = NULL;  /* he wants stdin */

    else if (argc - 1 == 1)

        cmdlineP->input_filespec = strdup(argv[1]);

    else 

        pm_error("Too many arguments.  The only argument accepted\n"

                 "is the input file specification");

    if (cmdlineP->alpha_filename && 

        streq(cmdlineP->alpha_filename, "-"))

        cmdlineP->alpha_stdout = TRUE;

    else 

        cmdlineP->alpha_stdout = FALSE;

}

struct ColorNameHashTableEntry {

/*----------------------------------------------------------------------------

   An entry in the color name hash table.  It maps a color name to a

   color, or is empty.

-----------------------------------------------------------------------------*/

    bool empty;

    char colorName[3];

        /* Actual length 0-3.  NOT NUL-terminated */

    pixel color;

};

typedef struct {

/*----------------------------------------------------------------------------

   This is a color map which is primarily a hash table that maps an XPM

   color name to a color.  An XPM color name is a 0-3 character name that

   appears in the raster of an XPM image to uniquely identify a color.

   The header of the XPM contains a listing of all the color names that

   appear in the raster, identifying a color for each.

   We represent a color as a 'pixel'.

-----------------------------------------------------------------------------*/

    unsigned int nameSize;

        /* Size of color names in this hash.  0-3 */

    struct ColorNameHashTableEntry * transparentP;

        /* The element of 'table' that is for the transparent color.

           NULL if there is none.

        */

    /* This is an internally chained hash table, i.e. there are no linked

       lists.  You use the hash function to get an index into the hash table.

       If the entry indexed by that is not for the color name you're looking

       for, you look at the next entry down, and keep going down until you

       either find the color name you're looking for or hit an empty entry.

       So that we never run out of space for new color names, we make the

       creator of the hash table tell us the maximum number of colors there

       will be.  We allocate twice that size in order to reduce average hash

       chain length.

    */

    unsigned int size;

    struct ColorNameHashTableEntry * table;

} ColorNameHash;

static ColorNameHash *

hash_create(unsigned int const nColors,

            unsigned int const nameSize) {

    ColorNameHash * hashP;

    MALLOCVAR_NOFAIL(hashP);

    hashP->nameSize = nameSize;

    hashP->size = nColors * 2;

    MALLOCARRAY(hashP->table, hashP->size);

    if (!hashP->table)

        pm_error("Failed to allocate memory for a %u-entry "

                 "color name hash table.", hashP->size);

    {

        unsigned int i;

        for (i = 0; i < hashP->size; ++i)

            hashP->table[i].empty = true;

    }

    hashP->transparentP = NULL;

    return hashP;

}

static void

hash_destroy(ColorNameHash * const hashP) {

    free(hashP->table);

    free(hashP);

}

static unsigned int

hashColorName(const char * const name,

              unsigned int const size,

              unsigned int const hashTableSize) {

/*----------------------------------------------------------------------------

   Return the hash value (initial index into the color name hash table)

   for the color name 'name', which is 'size' characters long.  The hash

   is to be in the range [0, hashTableSize).

-----------------------------------------------------------------------------*/

    /* I have no idea if this is an appropriate hash function.  I borrowed

       it from pnm_hashTuple()

    */

    unsigned int const hash_factor[] = {1, 33, 33*33};

    unsigned int i;

    unsigned int hash;

    hash = 0;  /* initial value */

    for (i = 0; i < size; ++i) {

        hash += name[i] * hash_factor[i];

    }

    hash %= hashTableSize;

    return hash;

}

static bool

entryMatch(struct ColorNameHashTableEntry const entry,

           const char *                   const name,

           unsigned int                   const size) {

    if (entry.empty)

        return true;

    assert(size <= ARRAY_SIZE(entry.colorName));

    {

        unsigned int i;

        for (i = 0; i < size; ++i) {

            if (name[i] != entry.colorName[i])

                return false;

        }

    }

    return true;

}

static void

bumpIndex(unsigned int * const indexP,

          unsigned int   const tableSize,

          unsigned int   const limit) {

/*----------------------------------------------------------------------------

   Bump *indexP to the next entry in a table of size 'tableSize', in a

   circular fashion.  But abort the program if this would take us to

   'limit'.

-----------------------------------------------------------------------------*/

    *indexP += 1;

    if (*indexP >= tableSize)

        *indexP = 0;

    if (*indexP == limit)

        pm_error("INTERNAL ERROR: color name hash table is full");

}

static void

hash_find(const ColorNameHash *             const hashP,

          const char *                      const name,

          struct ColorNameHashTableEntry ** const entryPP) {

/*----------------------------------------------------------------------------

   Find the entry in the color hash table *hashP for the color

   named 'name' in the lexicon of this XPM file.  If the color is in the

   table, this is where it is.  If it isn't, this is where it should go.

-----------------------------------------------------------------------------*/

    unsigned int const initialIndex  =

        hashColorName(name, hashP->nameSize, hashP->size);

    unsigned int i;

    for (i = initialIndex;

         !entryMatch(hashP->table[i], name, hashP->nameSize);

         bumpIndex(&i, hashP->size, initialIndex));

    *entryPP = &hashP->table[i];

}

static void

hash_add(ColorNameHash * const hashP,

         const char *    const name,

         pixel           const color,

         bool            const isTransparent) {

    struct ColorNameHashTableEntry * entryP;

    hash_find(hashP, name, &entryP);

    if (!entryP->empty)

        pm_error("Color name appears multiple times in color map");

    entryP->empty = false;

    {

        unsigned int i;

        for (i = 0; i < hashP->nameSize; ++i)

            entryP->colorName[i] = name[i];

    }

    entryP->color = color;

    if (isTransparent) {

        if (hashP->transparentP)

            pm_error("There are multiple NONE (transparent) entries in "

                     "the XPM color map");

        else

            hashP->transparentP = entryP;

    }

}

static pixel

hash_color(const ColorNameHash * const hashP,

           const char *          const name) {

    struct ColorNameHashTableEntry * entryP;

    hash_find(hashP, name, &entryP);

    if (entryP->empty)

        pm_error("Color name in raster is not in color map");

    return entryP->color;

}

static bool

hash_isTransparent(const ColorNameHash * const hashP,

                   const char *          const name) {

    struct ColorNameHashTableEntry * entryP;

    hash_find(hashP, name, &entryP);

    return (entryP == hashP->transparentP);

}

static char lastInputLine[MAX_LINE+1];

    /* contents of line most recently read from input */

static bool backup;

    /* TRUE means next read should be a reread of the most recently read

       line, i.e. lastInputLine, instead of a read from the input file.

    */

static void

getLine(char * const line,

        size_t const size,

        FILE * const stream) {

/*----------------------------------------------------------------------------

   Read the next line from the input file 'stream', through the one-line

   buffer lastInputLine[].

   If 'backup' is true, the "next line" is the previously read line, i.e.

   the one in that one-line buffer.  Otherwise, the "next line" is the next

   line from the real file.  After reading the backed up line, we reset 

   'backup' to false.

   Return the line as a null terminated string in *line, which is an

   array of 'size' bytes.

   Exit program if the line doesn't fit in the buffer.

-----------------------------------------------------------------------------*/

    if (size > sizeof(lastInputLine))

        pm_error("INTERNAL ERROR: getLine() received 'size' parameter "

                 "which is out of bounds");

    if (backup) {

        strncpy(line, lastInputLine, size); 

        backup = FALSE;

    } else {

        if (fgets(line, size, stream) == NULL)

            pm_error("EOF or read error on input file");

        if (strlen(line) == size - 1)

            pm_error("Input file has line that is too long (longer than "

                     "%u bytes).", (unsigned)size - 1);

        STRSCPY(lastInputLine, line);

    }

}

static void

getword(char * const output, char ** const cursorP) {

    char *t1;

    char *t2;

    for (t1=*cursorP; ISSPACE(*t1); t1++); /* skip white space */

    for (t2 = t1; !ISSPACE(*t2) && *t2 != '"' && *t2 != '\0'; t2++);

        /* Move to next white space, ", or eol */

    if (t2 > t1)

        strncpy(output, t1, t2 - t1);

    output[t2 - t1] = '\0';

    *cursorP = t2;

}    

static void

addToColorMap(ColorNameHash * const hashP,

              const char *    const colorName,

              char            const colorspec[],

              bool            const isTransparent) {

/*----------------------------------------------------------------------------

   Add the color named by colorspec[] to the colormap represented by *hashP,

   as the color associated with XPM color name 'colorNumber'.

   Note that *hashP determines how long 'colorName' is.

-----------------------------------------------------------------------------*/

    hash_add(hashP, colorName, ppm_parsecolor(colorspec, PPM_MAXMAXVAL),

             isTransparent);

}

static void

validateColorName(const char * const name,

                  unsigned int const charsPerPixel) {

    unsigned int i;

    for (i = 0; i < charsPerPixel; ++i) {

        if (name[i] == '"')

            pm_error("A color map entry ends in the middle of the colormap "

                     "index");

        else if (name[i] == '\0')

            pm_error("The XPM file ends in the middle of a color map entry");

    }

}

static void

interpretXpm3ColorTableLine(char               const line[],

                            unsigned int       const seqNum, 

                            unsigned int       const charsPerPixel,

                            ColorNameHash *    const hashP) {

/*----------------------------------------------------------------------------

   Interpret one line of the color table in the XPM header.  'line' is the

   line from the XPM file.  It is the seqNum'th color table entry in the file.

   The raster in the file uses 'charsPerPixel' characters per pixel (i.e.

   a an XPM color name is 'charsPerPixel' characters).

   Add the information from this color table entry to the color name hash

   *hashP.

   The line may include values for multiple kinds of color (grayscale,

   color, etc.).  We take the highest of these (e.g. color over grayscale).

   If a color table entry indicates transparency, set *transparentP

   to indicate the XPM color name.

-----------------------------------------------------------------------------*/

    /* Note: this code seems to allow for multi-word color specifications,

       but I'm not aware that such are legal.  Ultimately, ppm_parsecolor()

       interprets the name, and I believe it takes only single word 

       color specifications.  -Bryan 2001.05.06.

    */

    char str2[MAX_LINE+1];    

    char * t1;

    char * t2;

    int endOfEntry;   /* boolean */

    unsigned int curkey, key, highkey;  /* current color key */

    bool lastwaskey;    

        /* The last token we processes was a key, and we have processed

           at least one token.

        */

    char curbuf[BUFSIZ];        /* current buffer */

    bool isTransparent;

    const char * colorName;

        /* The 0-3 character name this color map line gives the color

           (i.e. the name that the raster uses).  This is NOT NUL-terminated.

           It's length is bytesPerPixel.

        */

    /* read the chars */

    t1 = strchr(line, '"');

    if (t1 == NULL)

        pm_error("A line that is supposed to be an entry in the color "

                 "table does not start with a quote.  The line is '%s'.  "

                 "It is the %uth entry in the color table.", 

                 line, seqNum);

    else

        ++t1;  /* Points now to first color number character */

    validateColorName(t1, charsPerPixel);

    colorName = t1;

    t1 += charsPerPixel;

    /*

     * read color keys and values 

     */

    curkey = 0; 

    highkey = 1;

    lastwaskey = FALSE;

    t2 = t1;

    endOfEntry = FALSE;

    while ( !endOfEntry ) {

        int isKey;   /* boolean */

        getword(str2, &t2;;

        if (strlen(str2) == 0)

            endOfEntry = TRUE;

        else {

            /* See if the word we got is a valid key (and get its key

               number if so)

            */

            for (key = 1; 

                 key <= NKEYS && !streq(xpmColorKeys[key - 1], str2); 

                 key++);

            isKey = (key <= NKEYS);

            if (lastwaskey || !isKey) {

                /* This word is a color specification (or "none" for

                   transparent).

                */

                if (!curkey) 

                    pm_error("Missing color key token in color table line "

                             "'%s' before '%s'.", line, str2);

                if (!lastwaskey) 

                    strcat(curbuf, " ");        /* append space */

                if ( (strneq(str2, "None", 4)) 

                     || (strneq(str2, "none", 4)) ) {

                    /* This entry identifies the transparent color number */

                    strcat(curbuf, "#000000");  /* Make it black */

                    isTransparent = TRUE;

                } else 

                    strcat(curbuf, str2);       /* append buf */

                lastwaskey = FALSE;

            } else { 

                /* This word is a key.  So we've seen the last of the 

                   info for the previous key, and we must either put it

                   in the color map or ignore it if we already have a higher

                   color form in the colormap for this colormap entry.

                */

                if (curkey > highkey) { /* flush string */

                    addToColorMap(hashP, colorName, curbuf, isTransparent);

                    highkey = curkey;

                }

                /* intialize state to process this new key */

                curkey = key;

                curbuf[0] = '\0';

                isTransparent = FALSE;

                lastwaskey = TRUE;

            }

            if (*t2 == '"') break;

        }

    }

    /* Put the info for the last key in the line into the colormap (or

       ignore it if there's already a higher color form for this colormap

       entry in it)

    */

    if (curkey > highkey) {

        addToColorMap(hashP, colorName, curbuf, isTransparent);

        highkey = curkey;

    }

    if (highkey == 1) 

        pm_error("C error scanning color table");

}

static void

readV3ColorTable(FILE *             const ifP,

                 ColorNameHash **   const colorNameHashPP,

                 unsigned int       const nColors,

                 unsigned int       const charsPerPixel) {

/*----------------------------------------------------------------------------

   Read the color table from the XPM Version 3 header.

   Assume *ifP is positioned to the color table; leave it positioned after.

-----------------------------------------------------------------------------*/

    ColorNameHash * const colorNameHashP = hash_create(nColors, charsPerPixel);

    unsigned int seqNum;

        /* Sequence number of entry within color table in XPM header */

    for (seqNum = 0; seqNum < nColors; ++seqNum) {

        char line[MAX_LINE+1];

        getLine(line, sizeof(line), ifP);

        /* skip the comment line if any */

        if (strneq(line, "/*", 2))

            getLine(line, sizeof(line), ifP);

        interpretXpm3ColorTableLine(line, seqNum, charsPerPixel,

                                    colorNameHashP);

    }

    *colorNameHashPP = colorNameHashP;

}

static void

readXpm3Header(FILE *             const ifP,

               unsigned int *     const widthP,

               unsigned int *     const heightP, 

               unsigned int *     const charsPerPixelP,

               ColorNameHash **   const colorNameHashPP) {

/*----------------------------------------------------------------------------

  Read the header of the XPM file on stream *ifP.  Assume the

  getLine() stream is presently positioned to the beginning of the

  file and it is a Version 3 XPM file.  Leave the stream positioned

  after the header.

  Return as *widthP and *heightP the dimensions of the image indicated

  by the header.

  Return as *charsPerPixelP the number of characters the header says the

  raster uses for each pixel, i.e. the XPM color name length.

  Return the color map as *colorNameHashPP.

-----------------------------------------------------------------------------*/

    char line[MAX_LINE+1];

    const char * xpm3_signature = "/* XPM */";

    unsigned int width, height;

    unsigned int nColors;

    unsigned int charsPerPixel;

    /* Read the XPM signature comment */

    getLine(line, sizeof(line), ifP);

    if (!strneq(line, xpm3_signature, strlen(xpm3_signature))) 

        pm_error("Apparent XPM 3 file does not start with '/* XPM */'.  "

                 "First line is '%s'", xpm3_signature);

    /* Read the assignment line */

    getLine(line, sizeof(line), ifP);

    if (!strneq(line, "static char", 11))

        pm_error("Cannot find data structure declaration.  Expected a "

                 "line starting with 'static char', but found the line "

                 "'%s'.", line);

    getLine(line, sizeof(line), ifP);

    /* Skip the comment block, if one starts here */

    if (strneq(line, "/*", 2)) {

        while (!strstr(line, "*/"))

            getLine(line, sizeof(line), ifP);

        getLine(line, sizeof(line), ifP);

    }

    /* Parse the hints line */

    if (sscanf(line, "\"%u %u %u %u\",", &width, &height,

               &nColors, &charsPerPixel) != 4)

        pm_error("error scanning hints line");

    if (verbose) {

        pm_message("Width x Height:  %u x %u", width, height);

        pm_message("no. of colors:  %u", nColors);

        pm_message("chars per pixel:  %u", charsPerPixel);

    }

    readV3ColorTable(ifP, colorNameHashPP, nColors, charsPerPixel);

    *widthP         = width;

    *heightP        = height;

    *charsPerPixelP = charsPerPixel;

}

static void

readV1ColorTable(FILE *           const ifP,

                 ColorNameHash ** const colorNameHashPP,

                 unsigned int     const nColors,

                 unsigned int     const charsPerPixel) {

/*----------------------------------------------------------------------------

   Read the color table from the XPM Version 1 header.

   Assume *ifP is positioned to the color table; leave it positioned after.

-----------------------------------------------------------------------------*/

    ColorNameHash * const colorNameHashP = hash_create(nColors, charsPerPixel);

    unsigned int i;

    for (i = 0; i < nColors; ++i) {

        char line[MAX_LINE+1];

        char str1[MAX_LINE+1];

        char str2[MAX_LINE+1];

        char * t1;

        char * t2;

        getLine(line, sizeof(line), ifP);

        if ((t1 = strchr(line, '"')) == NULL)

            pm_error("D error scanning color table");

        if ((t2 = strchr(t1 + 1, '"')) == NULL)

            pm_error("E error scanning color table");

        if (t2 - t1 - 1 != charsPerPixel)

            pm_error("wrong number of chars per pixel in color table");

        strncpy(str1, t1 + 1, t2 - t1 - 1);

        str1[t2 - t1 - 1] = '\0';

        if ((t1 = strchr(t2 + 1, '"')) == NULL)

            pm_error("F error scanning color table");

        if ((t2 = strchr(t1 + 1, '"')) == NULL)

            pm_error("G error scanning color table");

        strncpy(str2, t1 + 1, t2 - t1 - 1);

        str2[t2 - t1 - 1] = '\0';

        addToColorMap(colorNameHashP, str1, str2, false);

    }

    *colorNameHashPP = colorNameHashP;

}

static void

readXpm1Header(FILE *           const ifP,

               unsigned int *   const widthP,

               unsigned int *   const heightP, 

               unsigned int *   const charsPerPixelP,

               ColorNameHash ** const colorNameHashPP) {

/*----------------------------------------------------------------------------

  Read the header of the XPM file on stream *ifP.  Assume the

  getLine() stream is presently positioned to the beginning of the

  file and it is a Version 1 XPM file.  Leave the stream positioned

  after the header.

  Return the information from the header the same as for readXpm3Header.

-----------------------------------------------------------------------------*/

    int format, v;

    bool processedStaticChar;  

        /* We have read up to and interpreted the "static char..." line */

    char * t1;

    unsigned int nColors;

    bool gotPixel, gotNColors, gotWidth, gotHeight, gotFormat;

    gotNColors = false;

    gotWidth   = false;

    gotHeight  = false;

    gotFormat  = false;

    gotPixel   = false;

    /* Read the initial defines. */

    processedStaticChar = FALSE;

    while (!processedStaticChar) {

        char line[MAX_LINE+1];

        char str1[MAX_LINE+1];

        getLine(line, sizeof(line), ifP);

        if (sscanf(line, "#define %s %d", str1, &v) == 2) {

            if ((t1 = strrchr(str1, '_')) == NULL)

                t1 = str1;

            else

                ++t1;

            if (streq(t1, "format")) {

                gotFormat = true;

                format = v;

            } else if (streq(t1, "width")) {

                gotWidth = true;

                *widthP = v;

            } else if (streq(t1, "height")) {

                gotHeight = true;

                *heightP = v;

            } else if (streq(t1, "nColors")) {

                gotNColors = true;

                nColors = v;

            } else if (streq(t1, "pixel")) {

                gotPixel = TRUE;

                *charsPerPixelP = v;

            }

        } else if (strneq(line, "static char", 11)) {

            if ((t1 = strrchr(line, '_')) == NULL)

                t1 = line;

            else

                ++t1;

            processedStaticChar = TRUE;

        }

    }

    /* File is positioned to "static char" line, which is in line[] and

       t1 points to position of last "_" in the line, or the beginning of

       the line if there is no "_"

    */

    if (!gotPixel)

        pm_error("No 'pixel' value (characters per pixel)");

    if (!gotFormat)

        pm_error("missing or invalid format");

    if (format != 1)

        pm_error("can't handle XPM version %d", format);

    if (!gotWidth)

        pm_error("missing or invalid width");

    if (!gotHeight)

        pm_error("missing or invalid height");

    if (!gotNColors)

        pm_error("missing or invalid nColors");

    if (*charsPerPixelP > 2)

        pm_message("WARNING: > 2 characters per pixel uses a lot of memory");

    /* If there's a monochrome color table, skip it. */

    if (strneq(t1, "mono", 4)) {

        for (;;) {

            char line[MAX_LINE+1];

            getLine(line, sizeof(line), ifP);

            if (strneq(line, "static char", 11))

                break;

        }

    }

    readV1ColorTable(ifP, colorNameHashPP, nColors, *charsPerPixelP);

    /* Position to first line of raster (which is the line after

       "static char ...").

    */

    for (;;) {

        char line[MAX_LINE+1];

        getLine(line, sizeof(line), ifP);

        if (strneq(line, "static char", 11))

            break;

    }

}

static void

validateRasterPixel(const char * const pixelChars,

                    unsigned int const charsPerPixel) {

    unsigned int i;

    for (i = 0; i < charsPerPixel; ++i) {

        if (pixelChars[i] == '\0')

            pm_error("XPM input file ends in the middle of a string "

                     "that represents a raster line");

        else if (pixelChars[i] == '"')

            pm_error("A string that represents a raster line in the "

                     "XPM input file is too short to contain all the "

                     "pixels (%u characters each)",

                     charsPerPixel);

    }

}

static void

convertRow(char                  const line[],

           unsigned int          const width,

           unsigned int          const charsPerPixel,

           const ColorNameHash * const colorNameHashP,

           pixel *               const pixrow,

           bit *                 const alpharow) {

/*----------------------------------------------------------------------------

   Convert one row from XPM input, which describes one raster line of the

   image, to PPM.  The XPM line is in 'line', and its format is 'width' pixel,

   'charsPerPixel' characters per pixel.  *colorNameHashP is the color table

   that applies to the line.

   Put the PPM pixels in 'pixrow'.

   Also produce PBM row 'alpharow' with the transparency information from the

   row.

   If the line doesn't start with a quote (e.g. it is empty), we issue

   a warning and just treat the line as one that describes no pixels.

   Abort program if there aren't exactly 'width' pixels in the line.

-----------------------------------------------------------------------------*/

    const char * lineCursor;

    lineCursor = strchr(line, '"');  /* position to 1st quote in line */

    if (lineCursor == NULL) {

        /* We've seen a purported XPM that had a blank line in it.  Just

           ignoring it was the right thing to do.  05.05.27.

        */

        pm_message("WARNING:  No opening quotation mark in XPM input "

                   "line which is supposed to be a line of raster data: "

                   "'%s'.  Ignoring this line.", line);

    } else {

        unsigned int col;

        ++lineCursor; /* Skip to first character after quote */