Repatch (from linux) of OSX IRAF

1 files changed, 848 insertions, 0 deletions

diff --git a/vendor/x11iraf/cdl/cdliraf.c b/vendor/x11iraf/cdl/cdliraf.c
new file mode 100644
index 00000000..87c28e57
--- /dev/null
+++ b/vendor/x11iraf/cdl/cdliraf.c
@@ -0,0 +1,848 @@
+#include <stdio.h>
+#ifdef linux
+/*#include <gnu/types.h>*/
+#include <sys/types.h>
+#endif
+#ifdef ULTRIX
+#include <sys/types.h>
+#endif
+#include <unistd.h>
+#define  CDL_LIBRARY_SOURCE
+#include "cdl.h"
+
+
+/*
+ * CDLIRAF.C -- Routines to read IRAF OIF images.
+ *
+ *          cdl_displayIRAF  (cdl, fname, band, frame, fbconfig, zscale)
+ *               cdl_isIRAF  (fname)
+ *             cdl_readIRAF  (fname, band, &pix, &nx, &ny, &bitpix, title);
+ */
+
+
+#define	VERSION_1	1
+#define VERSION_2	2
+
+/* Image header parmeters. */
+#define SZ_V1PIXFILE 	79
+#define SZ_V1TITLE 	79
+#define SZ_V1HDR 	2048
+
+/* Offsets into header (in sizeof(int) units) for various parameters */
+#define	IM_V1PIXTYPE	4		/* datatype of the pixels 	*/
+#define	IM_V1NDIM	5		/* number of dimensions 	*/
+#define	IM_V1LEN	6		/* image dimensions 		*/
+#define	IM_V1PHYSLEN	13		/* physical length (as stored) 	*/
+#define	IM_V1PIXOFF	22		/* offset of the pixels 	*/
+#define	IM_V1PIXFILE	103		/* name of pixel storage file 	*/
+#define	IM_V1TITLE	183		/* title of image 		*/
+
+/* Image header parmeters. */
+#define SZ_V2PIXFILE 	255
+#define SZ_V2TITLE 	383
+#define SZ_V2HDR 	1024
+
+/* Offsets into header (in sizeof(int) units) for various parameters */
+#define	IM_V2PIXTYPE	10		/* datatype of the pixels 	*/
+#define	IM_V2SWAPPED	14		/* number of dimensions 	*/
+#define	IM_V2NDIM	18		/* number of dimensions 	*/
+#define	IM_V2LEN	22		/* image dimensions 		*/
+#define	IM_V2PHYSLEN	50		/* physical length (as stored) 	*/
+#define	IM_V2PIXOFF	86		/* offset of the pixels 	*/
+#define	IM_V2PIXFILE	126		/* name of pixel storage file 	*/
+#define	IM_V2TITLE	638		/* title of image		*/
+
+/* IRAF dataype codes */
+#define	TY_CHAR		2
+#define	TY_SHORT	3
+#define	TY_INT		4
+#define	TY_LONG		5
+#define	TY_REAL		6
+#define	TY_DOUBLE	7
+#define	TY_USHORT	11
+#define	TY_UCHAR	12
+
+#ifdef __STDC__
+#include <stddef.h>
+#include <stdlib.h>
+#endif
+
+#undef max
+#define max(a,b) ((a) > (b) ? (a) : (b))
+#undef min
+#define min(a,b) ((a) < (b) ? (a) : (b))
+
+extern	int	cdl_debug;
+
+
+#ifdef ANSI_FUNC
+
+static char *cdl_getIRAFPixels(char *fname, int band, uchar **image, int *nx, int *ny, int *bitpix, char *title);
+static int cdl_readImageHdr(char *fname, int *version, int *px, int *py, int *nx, int *ny, int *nbands, int *ptype, int *offset, int *swapped, char *pfile, char *title);
+static int cdl_getVersion(FILE *fd);
+static void cdl_getPixfile(char *fname, char *pfile);
+static int cdl_setBitpix(int ptype, int *pix_size, int *bitpix);
+static void cdl_swapPixels(int swapped, int nx, int ny, int ptype, uchar **image);
+static void cdl_strpak(char *in, char *out, int len);
+static void bswap2(char *a, char *b, int nbytes);
+static void bswap4(char *a, int aoff, char *b, int boff, int nbytes);
+static void bswap8(char *a, int aoff, char *b, int boff, int nbytes);
+static int is_swapped_machine(void);
+
+#else
+
+static char  *cdl_getIRAFPixels();
+static void  cdl_getPixfile(), cdl_strpak();
+static void  bswap2(), bswap4(), bswap8();
+static void  cdl_swapPixels ();
+static int   cdl_readImageHdr(), cdl_setBitpix();
+static int   cdl_getVersion();
+static int   is_swapped_machine();
+
+#endif
+
+
+
+/*  CDL_DISPLAYIRAF -- Display an IRAF OIF format image to the given frame,
+ *  optionally doing a Zscale transform of the image pixels.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_displayIRAF (
+    CDLPtr cdl,                         /* package ptr          */
+    char *fname,			/* image name		*/
+    int band,				/* image band if 3-d	*/
+    int frame,				/* display frame	*/
+    int fbconfig,			/* frame buffer config	*/
+    int zscale				/* do zscale of image?	*/
+)
+#else
+
+int
+cdl_displayIRAF (cdl, fname, band, frame, fbconfig, zscale)
+CDLPtr  cdl;                            /* package ptr          */
+char	*fname;				/* image name		*/
+int	band;				/* image band if 3-d	*/
+int	frame;				/* display frame	*/
+int	fbconfig;			/* frame buffer config	*/
+int	zscale;				/* do zscale of image?	*/
+#endif
+{
+	char	title[128];
+	int	status, nx, ny, bitpix;
+	uchar	*pix = NULL;
+	float	z1 = 0.0, z2 = 0.0;
+
+
+	/* See if this is a valid IRAF file. */
+	if (!cdl_isIRAF (fname)) {
+	    fprintf (stderr, "%s: not a valid IRAF file or doesn't exist.\n",
+		fname);
+	    return (ERR);
+	}
+
+	/* Get the raw IRAF image pixels. */
+        if (cdl_readIRAF (fname, band, &pix, &nx, &ny, &bitpix, title))
+	    return (ERR);
+
+	if (cdl_debug) {
+	    printf("[cdl_displayIRAF] '%s[%d] frame=%d zscale=%d\n",
+		fname, band, frame, zscale);
+	    printf("[cdl_displayIRAF] %dx%d bitpix=%d pixels z1=%g z2=%g\n",
+		nx, ny, bitpix, z1, z2);
+	}
+
+        (void) cdl_setTitle (cdl, title);
+        (void) cdl_setName (cdl, fname);
+	status =  cdl_displayPix (cdl, pix, nx, ny, bitpix, frame, fbconfig,
+	    zscale);
+	free ((char *) pix);
+	return (status);
+}
+
+
+/* CDL_ISIRAF -- Test a file to see if it is a IRAF file.  We check for both
+ * V1 and V2 header magic numbers and return the appropriate version if found.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_isIRAF (
+    char *fname				/* input filename */
+)
+#else
+
+int 
+cdl_isIRAF (fname)
+char	*fname;				/* input filename */
+#endif
+{
+	register FILE *fp;
+	int value = 0;
+	char magic[24];
+
+        if ((fp = fopen (fname, "r"))) {
+            fread (magic, sizeof (char), 12, fp);
+	    fclose (fp);
+
+	    /* See if this is a valid OIF header file. */
+	    if (strncmp(magic, "imhv2", 5) == 0)
+	        value = 2;
+	    else {
+	        cdl_strpak (magic, magic, 5);
+	        if (strncmp(magic, "imhdr", 5) == 0)
+	            value = 1;
+	    }
+	}
+
+	return value;
+}
+
+
+/*  CDL_READIRAF -- Read the pixels from an IRAF OIF format image, returning
+ *  the pixel array, dimensions, and image type.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_readIRAF (
+    char *fname,			/* image name		*/
+    int band,				/* image band if 3-d	*/
+    uchar **pix,			/* pixel array (output) */
+    int *nx,
+    int *ny,				/* dimensions (output)	*/
+    int *bitpix,			/* pixel size (output)	*/
+    char *title				/* image title		*/
+)
+#else
+
+int
+cdl_readIRAF (fname, band, pix, nx, ny, bitpix, title)
+char	*fname;				/* image name		*/
+int	band;				/* image band if 3-d	*/
+uchar	**pix;				/* pixel array (output) */
+int	*nx, *ny;			/* dimensions (output)	*/
+int	*bitpix;			/* pixel size (output)	*/
+char	*title;				/* image title		*/
+#endif
+{
+	char	*errstr;
+	char	*cdl_getIRAFPixels();
+
+	/* See if this is a valid IRAF file. */
+	if (!cdl_isIRAF (fname)) {
+	    fprintf (stderr, "%s: not a valid IRAF file or doesn't exist.\n",
+		fname);
+	    return (ERR);
+	}
+
+	if ((errstr=cdl_getIRAFPixels(fname,band,pix,nx,ny,bitpix,title))) {
+	    fprintf (stderr, "%s\n", errstr);
+	    return (ERR);
+	}
+
+	if (cdl_debug)
+	    printf ("[cdl_readIRAF] '%s[%d]' nx=%d ny=%d bitpix=%d\n",
+		fname, band, *nx, *ny, *bitpix);
+
+	return (OK);
+}
+
+
+
+/* ------------------
+ * Private routines.
+ * ------------------*/
+
+/*  CDL_GETIRAFPIXELS -- Given an IRAF filename return a pointer to the pixel
+ *  array and the image dimensions.
+ */
+
+#ifdef ANSI_FUNC
+
+static char *
+cdl_getIRAFPixels (
+    char *fname,                        /* input filename       */
+    int band,				/* image band		*/
+    uchar **image,                      /* output pixels        */
+    int *nx,
+    int *ny,                       	/* dimensions           */
+    int *bitpix,			/* pixel size		*/
+    char *title				/* image title		*/
+)
+#else
+
+static char *
+cdl_getIRAFPixels (fname, band, image, nx, ny, bitpix, title)
+char    *fname;                         /* input filename       */
+int	band;				/* image band		*/
+uchar   **image;                        /* output pixels        */
+int     *nx, *ny;                       /* dimensions           */
+int	*bitpix;			/* pixel size		*/
+char	*title;				/* image title		*/
+#endif
+{
+	register int i;
+	int	 npix, px, py, nbands, pix_size, version, swapped = 0;
+	FILE 	 *pf;
+	char  	 *line, pixfile[256];
+	int 	 ptype, offset;
+
+
+	/* Read the image header params */
+	if (cdl_readImageHdr (fname, &version, &px, &py, nx, ny, &nbands,
+	    &ptype, &offset, &swapped, pixfile, title) == ERR)
+		return "error reading image header";
+
+	/* Do some simple error checking. */
+	if (band > nbands)
+	    return "Invalid band request.";
+	if (access (pixfile, R_OK) != 0)
+	    return "Cannot access pixel file";
+
+	/* Open the pixel file and seek to the beginning of the data. */
+        if ((pf = fopen (pixfile, "r")) == NULL)
+	    return "Cannot open pixel file.";
+
+	npix = (*nx) * (*ny);
+	if (cdl_setBitpix (ptype, &pix_size, bitpix) == ERR) {
+	    fclose (pf);
+	    return "Invalid pixel type in image";
+	}
+
+	/* Now suck up the pixels. */
+	*image = (uchar *) malloc (npix * pix_size);
+	offset += (band - 1) * (px * py) * pix_size;
+	lseek (fileno(pf), (off_t)offset, SEEK_SET);
+
+	if (*nx == px)
+            fread ((void *)*image, pix_size, npix, pf);
+	else {
+	    line = (char *) malloc (px * pix_size);
+	    for (i=0; i < (*ny); i++) {
+                fread (line, pix_size, px, pf);
+		bcopy (line, &((*image)[i*(*nx)*pix_size]), (*nx)*pix_size);
+	    }
+	    free ((char *)line);
+	}
+
+	/* See if we need to swap the bytes. */
+	if (version == 2)
+	    cdl_swapPixels (swapped, *nx, *ny, ptype, image);
+
+	fclose (pf);
+	return NULL;
+}
+
+
+/*  CDL_READIMAGEHDR -- Read the image header information.
+ */
+
+#ifdef ANSI_FUNC
+
+static int 
+cdl_readImageHdr (
+    char *fname,			/* image name		 */
+    int *version,			/* OIF version number	 */
+    int *px,
+    int *py,				/* physical storage dims */
+    int *nx,
+    int *ny,
+    int *nbands,			/* image dims 		 */
+    int *ptype,				/* pixel type		 */
+    int *offset,			/* offset to pixels	 */
+    int *swapped,			/* byte-swapped pixels	 */
+    char *pfile,			/* pixfile pathname	 */
+    char *title 			/* image title		 */
+)
+#else
+
+static int
+cdl_readImageHdr (fname, version, px, py, nx, ny, nbands, ptype, offset, 
+    swapped, pfile, title)
+char	*fname;				/* image name		 */
+int	*version;			/* OIF version number	 */
+int	*px, *py;			/* physical storage dims */
+int	*nx, *ny, *nbands;		/* image dims 		 */
+int	*ptype;				/* pixel type		 */
+int	*offset;			/* offset to pixels	 */
+int	*swapped;			/* byte-swapped pixels	 */
+char	*pfile;				/* pixfile pathname	 */
+char	*title; 			/* image title		 */
+#endif
+{
+	FILE 	*hdr;
+
+        if ((hdr = fopen (fname, "r")) == NULL)
+	    return (ERR);
+
+	*version = cdl_getVersion (hdr);
+	if (*version == VERSION_1) {
+	    int 	header_v1[SZ_V1HDR];
+	    char 	pixfile_v1[SZ_V1PIXFILE];
+
+	    /* Read in the image header. */
+            fread ((void *)header_v1, sizeof (char), SZ_V1HDR, hdr);
+
+	    /* Get the interesting stuff. */
+	    *px = header_v1[IM_V1PHYSLEN];
+	    *py = header_v1[IM_V1PHYSLEN+1];
+	    *nx = header_v1[IM_V1LEN];
+	    *ny = header_v1[IM_V1LEN+1];
+	    *ptype = header_v1[IM_V1PIXTYPE];
+	    *offset = (header_v1[IM_V1PIXOFF] - 1) * sizeof(short);
+	    *nbands = header_v1[IM_V1LEN+2];
+	    *swapped = 0;
+
+	    /* Find the pixfile and see if it exists. */
+	    cdl_strpak ((char *)&header_v1[IM_V1PIXFILE], pixfile_v1,
+		SZ_V1PIXFILE);
+	    cdl_getPixfile (fname, pixfile_v1);
+	    (void) strcpy (pfile, pixfile_v1);
+
+	    /* Find the image title string */
+	    if (title == (char *)NULL)
+		title = (char *) malloc (SZ_V1TITLE+1);
+	    cdl_strpak ((char *)&header_v1[IM_V1TITLE], title, SZ_V1TITLE);
+
+	} else if (*version == VERSION_2) {
+	    char	header_v2[SZ_V2HDR], *tp;
+	    char	pixfile_v2[SZ_V2PIXFILE];
+
+	    /* Read in the image header. */
+            fread (header_v2, sizeof (char), SZ_V2HDR, hdr);
+
+	    /* Get the interesting stuff. */
+            
+            if (is_swapped_machine())
+                bswap4 (&header_v2[IM_V2SWAPPED], 1, (char *)swapped, 
+		    1, sizeof(int));
+            else
+                bcopy ((char *)&header_v2[IM_V2SWAPPED], (char *)swapped, 
+		    sizeof(int));
+
+	    if (is_swapped_machine()) {
+	        bswap4 (&header_v2[IM_V2PHYSLEN], 1, (char *)px, 1,
+		    sizeof(int));
+	        bswap4 (&header_v2[IM_V2PHYSLEN+sizeof(int)], 1,
+		    (char *)py, 1, sizeof(int));
+	        bswap4 (&header_v2[IM_V2LEN], 1, (char *)nx, 1,
+		    sizeof(int));
+	        bswap4 (&header_v2[IM_V2LEN+sizeof(int)], 1, (char *)ny,
+		    1, sizeof(int));
+	        bswap4 (&header_v2[IM_V2PIXTYPE], 1, (char *)ptype, 1, 
+		    sizeof(int));
+	        bswap4 (&header_v2[IM_V2PIXOFF], 1, (char *)offset, 1, 
+		    sizeof(int));
+	        bswap4 (&header_v2[IM_V2LEN+(2*sizeof(int))], 1,
+		    (char *)nbands, 1, sizeof(int));
+	    } else {
+	        bcopy ((char *)&header_v2[IM_V2PHYSLEN], px, sizeof(int));
+	        bcopy ((char *)&header_v2[IM_V2PHYSLEN+sizeof(int)], py,
+		    sizeof(int));
+	        bcopy ((char *)&header_v2[IM_V2LEN], nx, sizeof(int));
+	        bcopy ((char *)&header_v2[IM_V2LEN+sizeof(int)], ny,
+		    sizeof(int));
+	        bcopy ((char *)&header_v2[IM_V2PIXTYPE], ptype, sizeof(int));
+	        bcopy ((char *)&header_v2[IM_V2PIXOFF], offset, sizeof(int));
+	        bcopy ((char *)&header_v2[IM_V2LEN+(2*sizeof(int))], nbands,
+		    sizeof(int));
+	    }
+ 	    *offset = (*offset - 1) * sizeof(short); 
+
+	    /* Find the pixfile and see if it exists. */
+ 	    bcopy ((char *)&header_v2[IM_V2PIXFILE], pixfile_v2, SZ_V2PIXFILE); 
+	    cdl_getPixfile (fname, pixfile_v2);
+	    (void) strcpy (pfile, pixfile_v2);
+
+	    /* Find the image title string */
+	    tp = (char *)&header_v2[IM_V2TITLE];
+	    if (title == (char *)NULL)
+		title = (char *) malloc (SZ_V2TITLE+1);
+	    strcpy (title, (char *)tp);
+	}
+
+	if (cdl_debug) {
+	    printf("[cdl_readImageHdr] px,py=%d,%d nx,ny,nb=%d,%d,%d\n\t",
+	        *px, *py, *nx, *ny, *nbands);
+	    printf("ptype=%d offset=%d swap=%d pixfile='%s' title='%s'\n",
+		*ptype, *offset, swapped, pfile, title);
+	}
+
+	fclose (hdr); 			/* we're done with the header */
+	return (OK);
+}
+
+
+/* CDL_GETVERSION -- Return image header version.
+ */
+
+#ifdef ANSI_FUNC
+
+static int 
+cdl_getVersion (
+    FILE *fd				/* input filename */
+)
+#else
+
+static int 
+cdl_getVersion (fd)
+FILE	*fd;				/* input filename */
+#endif
+{
+	int 	value = 0;
+	char 	magic[24];
+
+	rewind (fd);
+        fread (magic, sizeof (char), 12, fd);
+	rewind (fd);
+
+	/* See if this is a valid OIF header file. */
+	if (strncmp(magic, "imhv2", 5) == 0)
+            value = 2;
+	else {
+	    cdl_strpak (magic, magic, 5);
+	    if (strncmp(magic, "imhdr", 5) == 0)
+	        value = 1;
+	}
+	return value;
+}
+
+
+/*  CDL_GETPIXFILE -- Get the pixelfile pathname.
+ */
+
+#ifdef ANSI_FUNC
+
+static void 
+cdl_getPixfile (char *fname, char *pfile)
+#else
+
+static void
+cdl_getPixfile (fname, pfile)
+char	*fname;
+char	*pfile;
+#endif
+{
+	char	temp[SZ_V1PIXFILE], *ip;
+	int	len;
+	char  	*index();
+
+        if (strncmp (pfile, "HDR$", 4) == 0) {
+            /* Handle the special case of a HDR$ pixfile path, prepend the
+             * current working directory name to the pixfile.
+             */
+	    ip = pfile + 4;
+            (void) strncpy (temp, ip, SZ_V1PIXFILE);
+            (void) strncpy (pfile, fname, SZ_V1PIXFILE);
+
+            /* Find the end of the pathname. */
+            len = strlen (pfile);
+            while ( (len > 0) && (pfile[len-1] != '/') )
+              len--;
+
+            /* Add the image name. */
+            pfile[len] = '\0';
+            (void) strncat (pfile, temp, SZ_V1PIXFILE);
+
+        } else if (index (pfile, '!') != NULL) {
+            /* Strip out the leading node! prefix from the pixfile path.  */
+            for (ip = pfile; *ip != '!' ; )
+                ip++;
+            (void) strcpy (pfile, ++ip);
+        }
+}
+
+
+/*  CDL_SETBITPIX -- Set the number of pixels for a given pixel type.
+ */
+
+#ifdef ANSI_FUNC
+
+static int 
+cdl_setBitpix (int ptype, int *pix_size, int *bitpix)
+#else
+
+static int
+cdl_setBitpix (ptype, pix_size, bitpix)
+int	ptype;
+int	*pix_size;
+int	*bitpix;
+#endif
+{
+	switch (ptype) {
+	case TY_USHORT:
+	case TY_SHORT:
+	    *pix_size = sizeof (short);
+	    *bitpix = 16;
+	    break;
+	case TY_INT:
+	    *pix_size = sizeof (int);
+	    *bitpix = 32;
+	    break;
+	case TY_LONG:
+	    *pix_size = sizeof (long);
+	    *bitpix = 32;
+	    break;
+	case TY_REAL:
+	    *pix_size = sizeof (float);
+	    *bitpix = -32;
+	    break;
+	case TY_DOUBLE:
+	    *pix_size = sizeof (double);
+	    *bitpix = -64;
+	    break;
+	default:
+	    return (ERR);
+	}
+	return (OK);
+}
+
+
+/*  CDL_SWAPPIXELS -- Byte swap pixels if necessary.
+ */
+
+#ifdef ANSI_FUNC
+
+static void 
+cdl_swapPixels (int swapped, int nx, int ny, int ptype, uchar **image)
+#else
+
+static void
+cdl_swapPixels (swapped, nx, ny, ptype, image)
+int	swapped;
+int	nx, ny;
+int	ptype;
+uchar	**image;
+#endif
+{
+	if ((swapped != is_swapped_machine())) {
+	    switch (ptype) {
+	    case TY_USHORT:
+	    case TY_SHORT:
+	        bswap2 ((char *)*image, (char *)*image, 
+	          	nx * ny * sizeof(short));
+	        break;
+	    case TY_INT:
+	    case TY_LONG:
+	        bswap4 ((char *)*image, 1, (char *)*image, 1, 
+	          	nx * ny * sizeof(int));
+	        break;
+	    case TY_REAL:
+	        bswap4 ((char *)*image, 1, (char *)*image, 1, 
+	          	nx * ny * sizeof(float));
+	        break;
+	    case TY_DOUBLE:
+	        bswap8 ((char *)*image, 1, (char *)*image, 1, 
+	          	nx * ny * sizeof(double));
+	        break;
+	    }
+	}
+}
+
+
+/*  CDL_STRPAK -- Convert ASCII string from SPP char per short to C char
+ *  per byte.
+ */
+
+#ifdef ANSI_FUNC
+
+static void 
+cdl_strpak (char *in, char *out, int len)
+#else
+
+static void 
+cdl_strpak (in, out, len)
+char	*in, *out;
+int	len;
+#endif
+{
+	int	i, j;
+
+	/* Adaptive byte selection (whichever byte order) chars alternate 
+	 * with \0.
+	 */
+	j = (in[0] == '\0' ? 1 : 0);
+
+	for (i = 0; i < len; i++, j += 2)
+	    out[i] = in[j];
+	out[i] = '\0';
+}
+
+
+/* BSWAP2 - Move bytes from array "a" to array "b", swapping successive
+ * pairs of bytes.  The two arrays may be the same but may not be offset
+ * and overlapping.
+ */
+
+#ifdef ANSI_FUNC
+
+static void 
+bswap2 (
+    char *a,
+    char *b,         		/* input array                  */
+    int nbytes         		/* number of bytes to swap      */
+)
+#else
+
+static void
+bswap2 (a, b, nbytes)
+char    *a, *b;         	/* input array                  */
+int     nbytes;         	/* number of bytes to swap      */
+#endif
+{
+        register char *ip=a, *op=b, *otop;
+        register unsigned temp;
+
+        /* Swap successive pairs of bytes.
+         */
+        for (otop = op + (nbytes & ~1);  op < otop;  ) {
+            temp  = *ip++;
+            *op++ = *ip++;
+            *op++ = temp;
+        }
+
+        /* If there is an odd byte left, move it to the output array.
+         */
+        if (nbytes & 1)
+            *op = *ip;
+}
+
+
+/* BSWAP4 - Move bytes from array "a" to array "b", swapping the four bytes
+ * in each successive 4 byte group, i.e., 12345678 becomes 43218765.
+ * The input and output arrays may be the same but may not partially overlap.
+ */
+
+#ifdef ANSI_FUNC
+
+static void 
+bswap4 (
+    char *a,			/* input array			*/
+    int aoff,			/* first byte in input array	*/
+    char *b,			/* output array			*/
+    int boff,			/* first byte in output array	*/
+    int nbytes			/* number of bytes to swap	*/
+)
+#else
+
+static void
+bswap4 (a, aoff, b, boff, nbytes)
+char	*a;			/* input array			*/
+int	aoff;			/* first byte in input array	*/
+char	*b;			/* output array			*/
+int	boff;			/* first byte in output array	*/
+int	nbytes;			/* number of bytes to swap	*/
+#endif
+{
+	register char	*ip, *op, *tp;
+	register int	n;
+	static	char temp[4];
+
+	tp = temp;
+	ip = (char *)a + aoff - 1;
+	op = (char *)b + boff - 1;
+
+	/* Swap successive four byte groups.
+	 */
+	for (n = nbytes >> 2;  --n >= 0;  ) {
+	    *tp++ = *ip++;
+	    *tp++ = *ip++;
+	    *tp++ = *ip++;
+	    *tp++ = *ip++;
+	    *op++ = *--tp;
+	    *op++ = *--tp;
+	    *op++ = *--tp;
+	    *op++ = *--tp;
+	}
+
+	/* If there are any odd bytes left, move them to the output array.
+	 * Do not bother to swap as it is unclear how to swap a partial
+	 * group, and really incorrect if the data is not modulus 4.
+	 */
+	for (n = nbytes & 03;  --n >= 0;  )
+	    *op++ = *ip++;
+}
+
+
+/* BSWAP8 - Move bytes from array "a" to array "b", swapping the eight bytes
+ * in each successive 8 byte group, i.e., 12345678 becomes 87654321.
+ * The input and output arrays may be the same but may not partially overlap.
+ */
+#ifdef ANSI_FUNC
+
+static void 
+bswap8 (
+    char *a,			/* input array			*/
+    int aoff,			/* first byte in input array	*/
+    char *b,			/* output array			*/
+    int boff,			/* first byte in output array	*/
+    int nbytes			/* number of bytes to swap	*/
+)
+#else
+
+static void
+bswap8 (a, aoff, b, boff, nbytes)
+char	*a;			/* input array			*/
+int	aoff;			/* first byte in input array	*/
+char	*b;			/* output array			*/
+int	boff;			/* first byte in output array	*/
+int	nbytes;			/* number of bytes to swap	*/
+#endif
+{
+	register char	*ip, *op, *tp;
+	register int	n;
+	static	char temp[8];
+
+	tp = temp;
+	ip = (char *)a + aoff - 1;
+	op = (char *)b + boff - 1;
+
+	/* Swap successive eight byte groups.
+	 */
+	for (n = nbytes >> 3;  --n >= 0;  ) {
+	    *tp++ = *ip++;
+	    *tp++ = *ip++;
+	    *tp++ = *ip++;
+	    *tp++ = *ip++;
+	    *tp++ = *ip++;
+	    *tp++ = *ip++;
+	    *tp++ = *ip++;
+	    *tp++ = *ip++;
+	    *op++ = *--tp;
+	    *op++ = *--tp;
+	    *op++ = *--tp;
+	    *op++ = *--tp;
+	    *op++ = *--tp;
+	    *op++ = *--tp;
+	    *op++ = *--tp;
+	    *op++ = *--tp;
+	}
+
+	/* If there are any odd bytes left, move them to the output array.
+	 * Do not bother to swap as it is unclear how to swap a partial
+	 * group, and really incorrect if the data is not modulus 8.
+	 */
+	for (n = nbytes & 03;  --n >= 0;  )
+	    *op++ = *ip++;
+}
+
+
+#ifdef ANSI_FUNC
+
+static int 
+is_swapped_machine (void)
+#else
+
+static int
+is_swapped_machine ()
+#endif
+{
+	union { char ch[4]; int i; } u;
+	u.i = 1;
+	return (u.ch[0]);
+}