return(0);	}    }/* * Take the comment which was accumulated from the input file, copy it * and tack it into this header. */static booleansetComment(ImageHeader *header){    assert(header != (ImageHeader *)NULL);		          if (incommentsize == 0) {	/* There was no comment in the input file */	header->comment = (char *)NULL;	return(TRUE);	}    /* The last thing in the comment should be a newline - clobber it */    assert(incomment[incommentsize - 1] == '\n');    incomment[incommentsize] = '\0';    header->comment = strdup(incomment);    if (header->comment == (char *)NULL) {	return(FALSE);	}    return(TRUE);    }void *imNew(ImageType type, unsigned width, unsigned height){    return(imNewOffset(type, width, height, 0, 0));    }void *imNewOffset(ImageType type, unsigned width, unsigned height,	    int xbase, int ybase){    void **areaPtr;    ImageHeader *newHeader;    /* Allocate and initialise the header */    newHeader = (ImageHeader *)malloc(sizeof(* newHeader));    if (newHeader == (ImageHeader *)NULL) {	return((void *)NULL);	}    newHeader->width = width;    newHeader->height = height;    newHeader->xbase = xbase;    newHeader->ybase = ybase;    newHeader->tag = type;    newHeader->comment = (char *)NULL;    /*     * Allocate the data area for the appropriate type of image,      * allocate and initialise the actual *Image and return it.     * This exists in one form for each type of Image.     */    switch(type) {      case IMAGE_GRAY: {	GrayImage newGray;	newGray = (GrayImage)malloc(sizeof(* newGray));	if (newGray == (GrayImage)NULL) {	    free((void *)newHeader);	    return((void *)NULL);	    }	areaPtr = allocImage(width, height, xbase, ybase, sizeof(unsigned char));	if (areaPtr == (void **)NULL) {	    free((void *)newHeader);	    free((void *)newGray);	    return((void *)NULL);	    }	newHeader->body.grayptr = newGray;	newGray->header = newHeader;	newGray->data = (unsigned char **)areaPtr;	return((void *)newGray);	break;			/* Paranoia strikes */	}      case IMAGE_FLOAT: {	FloatImage newFloat;	newFloat = (FloatImage)malloc(sizeof(* newFloat));	if (newFloat == (FloatImage)NULL) {	    free((void *)newHeader);	    return((void *)NULL);	    }	areaPtr = allocImage(width, height, xbase, ybase, sizeof(float));	if (areaPtr == (void **)NULL) {	    free((void *)newHeader);	    free((void *)newFloat);	    return((void *)NULL);	    }	newHeader->body.floatptr = newFloat;	newFloat->header = newHeader;	newFloat->data = (float **)areaPtr;	return((void *)newFloat);	break;	}      case IMAGE_RGB: {	RGBImage newRGB;	newRGB = (RGBImage)malloc(sizeof(* newRGB));	if (newRGB == (RGBImage)NULL) {	    free((void *)newHeader);	    return((void *)NULL);	    }	areaPtr = allocImage(width, height, xbase, ybase, sizeof(RGB));	if (areaPtr == (void **)NULL) {	    free((void *)newHeader);	    free((void *)newRGB);	    return((void *)NULL);	    }	newHeader->body.RGBptr = newRGB;	newRGB->header = newHeader;	newRGB->data = (RGB **)areaPtr;	return((void *)newRGB);	break;	}      case IMAGE_DOUBLE: {	DoubleImage newDouble;	newDouble = (DoubleImage)malloc(sizeof(* newDouble));	if (newDouble == (DoubleImage)NULL) {	    free((void *)newHeader);	    return((void *)NULL);	    }	areaPtr = allocImage(width, height, xbase, ybase, sizeof(double));	if (areaPtr == (void **)NULL) {	    free((void *)newHeader);	    free((void *)newDouble);	    return((void *)NULL);	    }	newHeader->body.doubleptr = newDouble;	newDouble->header = newHeader;	newDouble->data = (double **)areaPtr;	return((void *)newDouble);	break;	}      case IMAGE_BINARY: {	BinaryImage newBinary;	newBinary = (BinaryImage)malloc(sizeof(* newBinary));	if (newBinary == (BinaryImage)NULL) {	    free((void *)newHeader);	    return((void *)NULL);	    }	areaPtr = allocImage(width, height, xbase, ybase, sizeof(char));	if (areaPtr == (void **)NULL) {	    free((void *)newHeader);	    free((void *)newBinary);	    return((void *)NULL);	    }	newHeader->body.binaryptr = newBinary;	newBinary->header = newHeader;	newBinary->data = (char **)areaPtr;	return((void *)newBinary);	break;	}      case IMAGE_LONG: {	LongImage newLong;	newLong = (LongImage)malloc(sizeof(* newLong));	if (newLong == (LongImage)NULL) {	    free((void *)newHeader);	    return((void *)NULL);	    }	areaPtr = allocImage(width, height, xbase, ybase, sizeof(long));	if (areaPtr == (void **)NULL) {	    free((void *)newHeader);	    free((void *)newLong);	    return((void *)NULL);	    }	newHeader->body.longptr = newLong;	newLong->header = newHeader;	newLong->data = (long **)areaPtr;	return((void *)newLong);	break;	}      case IMAGE_PTR: {	PtrImage newPtr;	newPtr = (PtrImage)malloc(sizeof(* newPtr));	if (newPtr == (PtrImage)NULL) {	    free((void *)newHeader);	    return((void *)NULL);	    }	areaPtr = allocImage(width, height, xbase, ybase, sizeof(void *));	if (areaPtr == (void **)NULL) {	    free((void *)newHeader);	    free((void *)newPtr);	    return((void *)NULL);	    }	newHeader->body.ptrptr = newPtr;	newPtr->header = newHeader;	newPtr->data = (void ***)areaPtr;	return((void *)newPtr);	break;	}      case IMAGE_SHORT: {	ShortImage newShort;	newShort = (ShortImage)malloc(sizeof(* newShort));	if (newShort == (ShortImage)NULL) {	    free((void *)newHeader);	    return((void *)NULL);	    }	areaPtr = allocImage(width, height, xbase, ybase, sizeof(short));	if (areaPtr == (void **)NULL) {	    free((void *)newHeader);	    free((void *)newShort);	    return((void *)NULL);	    }	newHeader->body.shortptr = newShort;	newShort->header = newHeader;	newShort->data = (short **)areaPtr;	return((void *)newShort);	break;	}      default: {	panic("bad image tag");	}      }    /*NOTREACHED*/    }voidim_Free_(void *im, ImageHeader *header){    void **areaPtr;    unsigned el_size;    int xbase, ybase;    assert(im != (void *)NULL);    assert(header != (ImageHeader *)NULL);    /* Pull out the data area and the size of the element */    getAreaAndSize(im, header, &areaPtr, &el_size);    /* and get rid of all of them */    xbase = header->xbase;    ybase = header->ybase;    free((void *)im);    if (header->comment != (char *)NULL) {	free((void *)header->comment);	}    free((void *)header);    freeImage(areaPtr, xbase, ybase, el_size);    }voidim_SetOffset_(void *im, ImageHeader *header, int newxbase, int newybase){    int y;    int oldxbase;    int oldybase;    assert(im != (void *)NULL);    assert(header != (ImageHeader *)NULL);    oldxbase = header->xbase;    oldybase = header->ybase;#define	FIX_PTRS(im, imtype) \    { \	imtype vim = (imtype)(im); \	for (y = imGetYBase(vim); y <= imGetYMax(vim); y++) { \	    vim->data[y] += (oldxbase - newxbase); \	    } \	vim->data += (oldybase - newybase); \    }    switch(header->tag) {      case IMAGE_GRAY:		FIX_PTRS(im, GrayImage);	break;      case IMAGE_FLOAT:		FIX_PTRS(im, FloatImage);	break;      case IMAGE_RGB:		FIX_PTRS(im, RGBImage);		break;      case IMAGE_DOUBLE:	FIX_PTRS(im, DoubleImage);	break;      case IMAGE_BINARY:	FIX_PTRS(im, BinaryImage);	break;      case IMAGE_LONG:		FIX_PTRS(im, LongImage);	break;      case IMAGE_PTR:		FIX_PTRS(im, PtrImage);		break;      case IMAGE_SHORT:		FIX_PTRS(im, ShortImage);	break;      default: {	panic("bad image tag");	}      }#undef	FIX_PTRS    header->xbase = newxbase;    header->ybase = newybase;    }void *imLoad(ImageType type, char *filename){    FILE *inFile;    void *im;    /* Open the file, imLoadF on it, then close it */    assert(filename != (char *)NULL);    inFile = fopen(filename, "r");    if (inFile == (FILE *)NULL) {	return((void *)NULL);	}    im = imLoadF(type, inFile);    if (fclose(inFile) == EOF) {	/*	 * It would be a strange day that fclose on a read-only file	 * gave an error, but...	 *	 * Sigh - have to track down the image's header so we can free it.	 */	if (im) {	    ImageHeader *header = getHeader(im, type);	    im_Free_(im, header);	    }	return((void *)NULL);	}    return(im);    }void *imLoadF(ImageType type, FILE *inFile){    char fileHeader[PBM_MAX_LINELEN];    void *im;    int c;    int i;    ImageType filetype;    void * (*readfunc)(FILE *inFile, ImageHeader **readimHeader);    void *readim;    ImageHeader *readimHeader;    assert(inFile != (FILE *)NULL);    /*     * Read up to the first whitespace in order to find the file's header.     */    i = 0;    do {	c = getc(inFile);	if (c == EOF) {	    return((void *)NULL);	    }	fileHeader[i++] = c;	} while (!isspace(c));    fileHeader[--i] = '\0';		/* Clobber the whitespace */    /* Determine who is supposed to handle this sort of file */    for (i = 0; i < NREADERS; i++) {	if (strcmp(fileHeader, fileReaders[i].filetag) == 0) {	    /* Found it */	    filetype = fileReaders[i].filetype;	    readfunc = fileReaders[i].readfunc;	    break;	    }	}    if (i == NREADERS) {	/* Didn't match any of the ones in the table - unknown type. */	return((void *)NULL);	}    /* Clear the comment buffer */    incommentsize = 0;    /* Read in the file */    readim = (*readfunc)(inFile, &readimHeader);    if (readim == (void *)NULL) {	/* Didn't load for whatever reason */	return((void *)NULL);	}    if (filetype == type) {	/* The file was of the expected type - no conversion required */	if (!setComment(readimHeader)) {	    /* Sigh - stumbled over the comment */	    im_Free_(readim, readimHeader);	    return((void *)NULL);	    }	return(readim);	}    /*     * OK. We read in a file, and it wasn't what we expected. We get to     * promote it to the expected image type, if that's defined.     *     * If that conversion isn't a promotion, kick out.     */    if (!convertTable[filetype][type].isPromotion) {	im_Free_(readim, readimHeader);	return((void *)NULL);	}        /* Convert... */    im = im_Promote_(readim, readimHeader, type);    if (im == (void *)NULL) {	/* Didn't work. */	im_Free_(readim, readimHeader);	return((void *)NULL);	}    /* Kill the image we read in, and return the promoted one. */    im_Free_(readim, readimHeader);    /* Stick the comment from the file into the header */    readimHeader = getHeader(im, type);    if (!setComment(readimHeader)) {	/* Died in the comment copy */	im_Free_(im, readimHeader);	return((void *)NULL);	}    return(im);    }intim_Save_(void *im, ImageHeader *header, char *filename){    FILE *outFile;        assert(filename != (char *)NULL);    assert(im != (void *)NULL);    assert(header != (ImageHeader *)NULL);    /* Open the file, imSaveF on it, then close it */    outFile = fopen(filename, "w");    if (outFile == (FILE *)NULL) {	return(-1);	}    /* Write the image */    if (im_SaveF_(im, header, outFile) == -1) {	(void)fclose(outFile);	return(-1);	}    /* and close the file */    if (fclose(outFile) == EOF) {	/* Bah. */	return(-1);	}    return(0);    }intim_SaveF_(void *im, ImageHeader *header, FILE *outFile){    void *rect;