Subversion Repositories planix.SVN

/* Copyright (C) 1988-1991 Apple Computer, Inc.

 * All Rights Reserved.

 *

 * Warranty Information

 * Even though Apple has reviewed this software, Apple makes no warranty

 * or representation, either express or implied, with respect to this

 * software, its quality, accuracy, merchantability, or fitness for a

 * particular purpose.  As a result, this software is provided "as is,"

 * and you, its user, are assuming the entire risk as to its quality

 * and accuracy.

 *

 * This code may be used and freely distributed as long as it includes

 * this copyright notice and the warranty information.

 *

 *

 * Motorola processors (Macintosh, Sun, Sparc, MIPS, etc)

 * pack bytes from high to low (they are big-endian).

 * Use the HighLow routines to match the native format

 * of these machines.

 *

 * Intel-like machines (PCs, Sequent)

 * pack bytes from low to high (the are little-endian).

 * Use the LowHigh routines to match the native format

 * of these machines.

 *

 * These routines have been tested on the following machines:

 *	Apple Macintosh, MPW 3.1 C compiler

 *	Apple Macintosh, THINK C compiler

 *	Silicon Graphics IRIS, MIPS compiler

 *	Cray X/MP and Y/MP

 *	Digital Equipment VAX

 *

 *

 * Implemented by Malcolm Slaney and Ken Turkowski.

 *

 * Malcolm Slaney contributions during 1988-1990 include big- and little-

 * endian file I/O, conversion to and from Motorola's extended 80-bit

 * floating-point format, and conversions to and from IEEE single-

 * precision floating-point format.

 *

 * In 1991, Ken Turkowski implemented the conversions to and from

 * IEEE double-precision format, added more precision to the extended

 * conversions, and accommodated conversions involving +/- infinity,

 * NaN's, and denormalized numbers.

 *

 * $Id: portableio.c,v 1.11 2001/01/07 23:47:38 markt Exp $

 */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include	<stdio.h>

#if defined(__riscos__) && defined(FPA10)

#include	"ymath.h"

#else

#include	<math.h>

#endif

#include	"portableio.h"

#ifdef WITH_DMALLOC

#include <dmalloc.h>

#endif

/****************************************************************

 * Big/little-endian independent I/O routines.

 ****************************************************************/

/*

 * It is a hoax to call this code portable-IO:

 * 

 *   - It doesn't work on machines with CHAR_BIT != 8

 *   - it also don't test this error condition

 *   - otherwise it tries to handle CHAR_BIT != 8 by things like 

 *     masking 'putc(i&0xff,fp)'

 *   - It doesn't handle EOF in any way

 *   - it only works with ints with 32 or more bits

 *   - It is a collection of initial buggy code with patching the known errors

 *     instead of CORRECTING them! 

 *     For that see comments on the old Read16BitsHighLow()

 */

#ifdef KLEMM_36

signed int    ReadByte ( FILE* fp )

{

    int  result = getc (fp);

    return result == EOF  ?  0  :  (signed char) (result & 0xFF);

}

unsigned int  ReadByteUnsigned ( FILE* fp )

{

    int  result = getc (fp);

    return result == EOF  ?  0  :  (unsigned char) (result & 0xFF);

}

#else

int

ReadByte(FILE *fp)

{

	int	result;

	result = getc(fp) & 0xff;

	if (result & 0x80)

		result = result - 0x100;

	return result;

}

#endif

#ifdef KLEMM_36

int  Read16BitsLowHigh ( FILE* fp )

{

    int  low  = ReadByteUnsigned (fp);

    int  high = ReadByte         (fp);

    return (high << 8) | low;

}

#else

int

Read16BitsLowHigh(FILE *fp)

{

	int	first, second, result;

	first = 0xff & getc(fp);

	second = 0xff & getc(fp);

	result = (second << 8) + first;

#ifndef	THINK_C42

	if (result & 0x8000)

		result = result - 0x10000;

#endif	/* THINK_C */

	return(result);

}

#endif

#ifdef KLEMM_36

int  Read16BitsHighLow ( FILE* fp )

{

    int  high = ReadByte         (fp);

    int  low  = ReadByteUnsigned (fp);

    return (high << 8) | low;

}

#else

int

Read16BitsHighLow(FILE *fp)

{

	int	first, second, result;

        /* Reads the High bits, the value is -128...127 

	 * (which gave after upscaling the -32768...+32512

	 * Why this value is not converted to signed char?

	 */

        first = 0xff & getc(fp);

        /* Reads the Lows bits, the value is 0...255 

	 * This is correct. This value gives an additional offset

	 * for the High bits

	 */

	second = 0xff & getc(fp);

        /* This is right */

	result = (first << 8) + second;

        /* Now we are starting to correct the nasty bug of the first instruction

	 * The value of the high bits is wrong. Always. So we must correct this

	 * value. This seems to be not necessary for THINK_C42. This is either

	 * a 16 bit compiler with 16 bit ints (where this bug is hidden and 0x10000

	 * is not in the scope of an int) or it is not a C compiler, but only a

	 * C like compiler. In the first case the '#ifndef THINK_C42' is wrong

	 * because it's not a property of the THINK_C42 compiler, but of all compilers

	 * with sizeof(int)*CHAR_BIT < 18.

	 * Another nasty thing is that the rest of the code doesn't work for 16 bit ints,

	 * so this patch don't solve the 16 bit problem.

         */

#ifndef	THINK_C42

	if (result & 0x8000)

		result = result - 0x10000;

#endif	/* THINK_C */

	return(result);

}

#endif

void

Write8Bits(FILE *fp, int i)

{

	putc(i&0xff,fp);

}

void

Write16BitsLowHigh(FILE *fp, int i)

{

	putc(i&0xff,fp);

	putc((i>>8)&0xff,fp);

}

void

Write16BitsHighLow(FILE *fp, int i)

{

	putc((i>>8)&0xff,fp);

	putc(i&0xff,fp);

}

#ifdef KLEMM_36

int  Read24BitsHighLow ( FILE* fp )

{

    int  high = ReadByte         (fp);

    int  med  = ReadByteUnsigned (fp);

    int  low  = ReadByteUnsigned (fp);

    return (high << 16) | (med << 8) | low;

}

#else

int

Read24BitsHighLow(FILE *fp)

{

	int	first, second, third;

	int	result;

	first = 0xff & getc(fp);

	second = 0xff & getc(fp);

	third = 0xff & getc(fp);

	result = (first << 16) + (second << 8) + third;

	if (result & 0x800000)

		result = result - 0x1000000;

	return(result);

}

#endif

#define	Read32BitsLowHigh(f)	Read32Bits(f)

#ifdef KLEMM_36

int  Read32Bits ( FILE* fp )

{

    int  low  = ReadByteUnsigned (fp);

    int  medl = ReadByteUnsigned (fp);

    int  medh = ReadByteUnsigned (fp);

    int  high = ReadByte         (fp);

    return (high << 24) | (medh << 16) | (medl << 8) | low;

}

#else

int

Read32Bits(FILE *fp)

{

	int	first, second, result;

	first = 0xffff & Read16BitsLowHigh(fp);

	second = 0xffff & Read16BitsLowHigh(fp);

	result = (second << 16) + first;

#ifdef	CRAY

	if (result & 0x80000000)

		result = result - 0x100000000;

#endif	/* CRAY */

	return(result);

}

#endif

#ifdef KLEMM_36

int  Read32BitsHighLow ( FILE* fp )

{

    int  high = ReadByte         (fp);

    int  medh = ReadByteUnsigned (fp);

    int  medl = ReadByteUnsigned (fp);

    int  low  = ReadByteUnsigned (fp);

    return (high << 24) | (medh << 16) | (medl << 8) | low;

}

#else

int

Read32BitsHighLow(FILE *fp)

{

	int	first, second, result;

	first = 0xffff & Read16BitsHighLow(fp);

	second = 0xffff & Read16BitsHighLow(fp);

	result = (first << 16) + second;

#ifdef	CRAY

	if (result & 0x80000000)

		result = result - 0x100000000;

#endif

	return(result);

}

#endif

void

Write32Bits(FILE *fp, int i)

{

	Write16BitsLowHigh(fp,(int)(i&0xffffL));

	Write16BitsLowHigh(fp,(int)((i>>16)&0xffffL));

}

void

Write32BitsLowHigh(FILE *fp, int i)

{

	Write16BitsLowHigh(fp,(int)(i&0xffffL));

	Write16BitsLowHigh(fp,(int)((i>>16)&0xffffL));

}

void

Write32BitsHighLow(FILE *fp, int i)

{

	Write16BitsHighLow(fp,(int)((i>>16)&0xffffL));

	Write16BitsHighLow(fp,(int)(i&0xffffL));

}

#ifdef KLEMM_36

void ReadBytes (FILE     *fp, char *p, int n) 

{

    memset ( p, 0, n );

    fread  ( p, 1, n, fp );

}

#else

void ReadBytes(FILE	*fp, char *p, int n)

{

	/* What about fread? */

	while (!feof(fp) & (n-- > 0))

		*p++ = getc(fp);

}

#endif

void ReadBytesSwapped(FILE *fp, char *p, int n)

{

	register char	*q = p;

	/* What about fread? */

	while (!feof(fp) & (n-- > 0))

		*q++ = getc(fp);

        /* If not all bytes could be read, the resorting is different

	 * from the normal resorting. Is this intention or another bug?

	 */

	for (q--; p < q; p++, q--){

		n = *p;

		*p = *q;

		*q = n;

	}

}

#ifdef KLEMM_36

void WriteBytes(FILE *fp, char *p, int n)

{

    /* return n == */

    fwrite ( p, 1, n, fp );

}

#else

void WriteBytes(FILE *fp, char *p, int n)

{

        /* No error condition checking */

        while (n-- > 0)

		putc(*p++, fp);

}

#endif

#ifdef KLEMM_36

void WriteBytesSwapped(FILE *fp, char *p, int n)

{

    p += n;

    while ( n-- > 0 )

	putc ( *--p, fp );

}

#else

void WriteBytesSwapped(FILE *fp, char *p, int n)

{

	p += n-1;

	while (n-- > 0)

		putc(*p--, fp);

}

#endif

/****************************************************************

 * The following two routines make up for deficiencies in many

 * compilers to convert properly between unsigned integers and

 * floating-point.  Some compilers which have this bug are the

 * THINK_C compiler for the Macintosh and the C compiler for the

 * Silicon Graphics MIPS-based Iris.

 ****************************************************************/

#ifdef applec	/* The Apple C compiler works */

# define FloatToUnsigned(f)	((unsigned long)(f))

# define UnsignedToFloat(u)	((double)(u))

#else /* applec */

# define FloatToUnsigned(f)	((unsigned long)(((long)((f) - 2147483648.0)) + 2147483647L + 1))

# define UnsignedToFloat(u)	(((double)((long)((u) - 2147483647L - 1))) + 2147483648.0)

#endif /* applec */

/****************************************************************

 * Extended precision IEEE floating-point conversion routines

 ****************************************************************/

double

ConvertFromIeeeExtended(char* bytes)

{

	double	f;

	long	expon;

	unsigned long hiMant, loMant;

#ifdef	TEST

printf("ConvertFromIEEEExtended(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx\r",

	(long)bytes[0], (long)bytes[1], (long)bytes[2], (long)bytes[3],

	(long)bytes[4], (long)bytes[5], (long)bytes[6],

	(long)bytes[7], (long)bytes[8], (long)bytes[9]);

#endif

	expon = ((bytes[0] & 0x7F) << 8) | (bytes[1] & 0xFF);

	hiMant	=	((unsigned long)(bytes[2] & 0xFF) << 24)

			|	((unsigned long)(bytes[3] & 0xFF) << 16)

			|	((unsigned long)(bytes[4] & 0xFF) << 8)

			|	((unsigned long)(bytes[5] & 0xFF));

	loMant	=	((unsigned long)(bytes[6] & 0xFF) << 24)

			|	((unsigned long)(bytes[7] & 0xFF) << 16)

			|	((unsigned long)(bytes[8] & 0xFF) << 8)

			|	((unsigned long)(bytes[9] & 0xFF));

        /* This case should also be called if the number is below the smallest

	 * positive double variable */

	if (expon == 0 && hiMant == 0 && loMant == 0) {

		f = 0;

	}

	else {

	        /* This case should also be called if the number is too large to fit into 

		 * a double variable */

		if (expon == 0x7FFF) {	/* Infinity or NaN */

			f = HUGE_VAL;

		}

		else {

			expon -= 16383;

			f  = ldexp(UnsignedToFloat(hiMant), (int) (expon -= 31));

			f += ldexp(UnsignedToFloat(loMant), (int) (expon -= 32));

		}

	}

	if (bytes[0] & 0x80)

		return -f;

	else

		return f;

}

double

ReadIeeeExtendedHighLow(FILE *fp)

{

	char	bytes [10];

	ReadBytes ( fp, bytes, 10 );

	return ConvertFromIeeeExtended ( bytes );

}