src/common/extended.c

#if !defined(__VISAGECPP__)
#   pragma warning(disable:4001)    /* non standard extension used: single line comment */
#endif
#include "wx/setup.h"
#include <math.h>

#if wxUSE_APPLE_IEEE

/*
 * C O N V E R T   T O	 I E E E   E X T E N D E D
 */

/* Copyright (C) 1988-1991 Apple Computer, Inc.
 * All rights reserved.
 *
 * Machine-independent I/O routines for IEEE floating-point numbers.
 *
 * NaN's and infinities are converted to HUGE_VAL or HUGE, which
 * happens to be infinity on IEEE machines.	 Unfortunately, it is
 * impossible to preserve NaN's in a machine-independent way.
 * Infinities are, however, preserved on IEEE 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.
 */

#ifndef HUGE_VAL
#define HUGE_VAL HUGE
#endif /*HUGE_VAL*/

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

void ConvertToIeeeExtended(double num, unsigned char *bytes)
{
	int				sign;
	int				expon;
	double			fMant, fsMant;
	unsigned long	hiMant, loMant;

	if (num < 0) {
		sign = 0x8000;
		num *= -1;
	} else {
		sign = 0;
	}

	if (num == 0) {
		expon = 0; hiMant = 0; loMant = 0;
	}
	else {
		fMant = frexp(num, &expon);
		if ((expon > 16384) || !(fMant < 1)) {	  /* Infinity or NaN */
			expon = sign|0x7FFF; hiMant = 0; loMant = 0; /* infinity */
		}
		else {	  /* Finite */
			expon += 16382;
			if (expon < 0) {	/* denormalized */
				fMant = ldexp(fMant, expon);
				expon = 0;
			}
			expon |= sign;
			fMant = ldexp(fMant, 32);
			fsMant = floor(fMant);
			hiMant = FloatToUnsigned(fsMant);
			fMant = ldexp(fMant - fsMant, 32);
			fsMant = floor(fMant);
			loMant = FloatToUnsigned(fsMant);
		}
	}

    /* disable the warning about 'possible loss of data' & 'conversion between diff types' */
    #ifdef _MSC_VER
        #pragma warning(disable: 4244)
        #pragma warning(disable: 4135)
    #endif /* Visual C++ */

	bytes[0] = (expon >> 8) & 0xff;
	bytes[1] = expon & 0xff;
	bytes[2] = (unsigned char) ((hiMant >> 24) & 0xff);
	bytes[3] = (unsigned char) ((hiMant >> 16) & 0xff);
	bytes[4] = (unsigned char) ((hiMant >> 8) & 0xff);
	bytes[5] = (unsigned char) (hiMant & 0xff);
	bytes[6] = (unsigned char) ((loMant >> 24) & 0xff);
	bytes[7] = (unsigned char) ((loMant >> 16) & 0xff);
	bytes[8] = (unsigned char) ((loMant >> 8) & 0xff);
	bytes[9] = (unsigned char) (loMant & 0xff);

    #ifdef _MSC_VER
        #pragma warning(default: 4244)
        #pragma warning(default: 4135)
    #endif /* Visual C++ */
}

/*
 * C O N V E R T   F R O M	 I E E E   E X T E N D E D
 */

/*
 * Copyright (C) 1988-1991 Apple Computer, Inc.
 * All rights reserved.
 *
 * Machine-independent I/O routines for IEEE floating-point numbers.
 *
 * NaN's and infinities are converted to HUGE_VAL or HUGE, which
 * happens to be infinity on IEEE machines.	 Unfortunately, it is
 * impossible to preserve NaN's in a machine-independent way.
 * Infinities are, however, preserved on IEEE 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.
 */

#ifndef HUGE_VAL
# define HUGE_VAL HUGE
#endif /*HUGE_VAL*/

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

/****************************************************************
 * Extended precision IEEE floating-point conversion routine.
 ****************************************************************/

double ConvertFromIeeeExtended(const unsigned char *bytes)
{
	double			f;
	int				expon;
	unsigned long	hiMant, loMant;

	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));

	if (expon == 0 && hiMant == 0 && loMant == 0) {
		f = 0;
	}
	else {
		if (expon == 0x7FFF) {	  /* Infinity or NaN */
			f = HUGE_VAL;
		}
		else {
			expon -= 16383;
			f  = ldexp(UnsignedToFloat(hiMant), expon-=31);
			f += ldexp(UnsignedToFloat(loMant), expon-=32);
		}
	}

	if (bytes[0] & 0x80)
		return -f;
	else
		return f;
}

#endif /* wxUSE_APPLE_IEEE */
Commit	Line	Data
	1	#if !defined(__VISAGECPP__)
	2	# pragma warning(disable:4001) /* non standard extension used: single line comment */
	3	#endif
	4	#include "wx/setup.h"
	5	#include <math.h>
	6
	7	#if wxUSE_APPLE_IEEE
	8
	9	/*
	10	* C O N V E R T T O I E E E E X T E N D E D
	11	*/
	12
	13	/* Copyright (C) 1988-1991 Apple Computer, Inc.
	14	* All rights reserved.
	15	*
	16	* Machine-independent I/O routines for IEEE floating-point numbers.
	17	*
	18	* NaN's and infinities are converted to HUGE_VAL or HUGE, which
	19	* happens to be infinity on IEEE machines. Unfortunately, it is
	20	* impossible to preserve NaN's in a machine-independent way.
	21	* Infinities are, however, preserved on IEEE machines.
	22	*
	23	* These routines have been tested on the following machines:
	24	* Apple Macintosh, MPW 3.1 C compiler
	25	* Apple Macintosh, THINK C compiler
	26	* Silicon Graphics IRIS, MIPS compiler
	27	* Cray X/MP and Y/MP
	28	* Digital Equipment VAX
	29	*
	30	*
	31	* Implemented by Malcolm Slaney and Ken Turkowski.
	32	*
	33	* Malcolm Slaney contributions during 1988-1990 include big- and little-
	34	* endian file I/O, conversion to and from Motorola's extended 80-bit
	35	* floating-point format, and conversions to and from IEEE single-
	36	* precision floating-point format.
	37	*
	38	* In 1991, Ken Turkowski implemented the conversions to and from
	39	* IEEE double-precision format, added more precision to the extended
	40	* conversions, and accommodated conversions involving +/- infinity,
	41	* NaN's, and denormalized numbers.
	42	*/
	43
	44	#ifndef HUGE_VAL
	45	#define HUGE_VAL HUGE
	46	#endif /HUGE_VAL/
	47
	48	#define FloatToUnsigned(f) ((unsigned long) (((long) (f - 2147483648.0)) + 2147483647L) + 1)
	49
	50	void ConvertToIeeeExtended(double num, unsigned char *bytes)
	51	{
	52	int sign;
	53	int expon;
	54	double fMant, fsMant;
	55	unsigned long hiMant, loMant;
	56
	57	if (num < 0) {
	58	sign = 0x8000;
	59	num *= -1;
	60	} else {
	61	sign = 0;
	62	}
	63
	64	if (num == 0) {
	65	expon = 0; hiMant = 0; loMant = 0;
	66	}
	67	else {
	68	fMant = frexp(num, &expon);
	69	if ((expon > 16384) \|\| !(fMant < 1)) { /* Infinity or NaN */
	70	expon = sign\|0x7FFF; hiMant = 0; loMant = 0; /* infinity */
	71	}
	72	else { /* Finite */
	73	expon += 16382;
	74	if (expon < 0) { /* denormalized */
	75	fMant = ldexp(fMant, expon);
	76	expon = 0;
	77	}
	78	expon \|= sign;
	79	fMant = ldexp(fMant, 32);
	80	fsMant = floor(fMant);
	81	hiMant = FloatToUnsigned(fsMant);
	82	fMant = ldexp(fMant - fsMant, 32);
	83	fsMant = floor(fMant);
	84	loMant = FloatToUnsigned(fsMant);
	85	}
	86	}
	87
	88	/* disable the warning about 'possible loss of data' & 'conversion between diff types' */
	89	#ifdef _MSC_VER
	90	#pragma warning(disable: 4244)
	91	#pragma warning(disable: 4135)
	92	#endif /* Visual C++ */
	93
	94	bytes[0] = (expon >> 8) & 0xff;
	95	bytes[1] = expon & 0xff;
	96	bytes[2] = (unsigned char) ((hiMant >> 24) & 0xff);
	97	bytes[3] = (unsigned char) ((hiMant >> 16) & 0xff);
	98	bytes[4] = (unsigned char) ((hiMant >> 8) & 0xff);
	99	bytes[5] = (unsigned char) (hiMant & 0xff);
	100	bytes[6] = (unsigned char) ((loMant >> 24) & 0xff);
	101	bytes[7] = (unsigned char) ((loMant >> 16) & 0xff);
	102	bytes[8] = (unsigned char) ((loMant >> 8) & 0xff);
	103	bytes[9] = (unsigned char) (loMant & 0xff);
	104
	105	#ifdef _MSC_VER
	106	#pragma warning(default: 4244)
	107	#pragma warning(default: 4135)
	108	#endif /* Visual C++ */
	109	}
	110
	111	/*
	112	* C O N V E R T F R O M I E E E E X T E N D E D
	113	*/
	114
	115	/*
	116	* Copyright (C) 1988-1991 Apple Computer, Inc.
	117	* All rights reserved.
	118	*
	119	* Machine-independent I/O routines for IEEE floating-point numbers.
	120	*
	121	* NaN's and infinities are converted to HUGE_VAL or HUGE, which
	122	* happens to be infinity on IEEE machines. Unfortunately, it is
	123	* impossible to preserve NaN's in a machine-independent way.
	124	* Infinities are, however, preserved on IEEE machines.
	125	*
	126	* These routines have been tested on the following machines:
	127	* Apple Macintosh, MPW 3.1 C compiler
	128	* Apple Macintosh, THINK C compiler
	129	* Silicon Graphics IRIS, MIPS compiler
	130	* Cray X/MP and Y/MP
	131	* Digital Equipment VAX
	132	*
	133	*
	134	* Implemented by Malcolm Slaney and Ken Turkowski.
	135	*
	136	* Malcolm Slaney contributions during 1988-1990 include big- and little-
	137	* endian file I/O, conversion to and from Motorola's extended 80-bit
	138	* floating-point format, and conversions to and from IEEE single-
	139	* precision floating-point format.
	140	*
	141	* In 1991, Ken Turkowski implemented the conversions to and from
	142	* IEEE double-precision format, added more precision to the extended
	143	* conversions, and accommodated conversions involving +/- infinity,
	144	* NaN's, and denormalized numbers.
	145	*/
	146
	147	#ifndef HUGE_VAL
	148	# define HUGE_VAL HUGE
	149	#endif /HUGE_VAL/
	150
	151	# define UnsignedToFloat(u) (((double) ((long) (u - 2147483647L - 1))) + 2147483648.0)
	152
	153	/****************************************************************
	154	* Extended precision IEEE floating-point conversion routine.
	155	****************************************************************/
	156
	157	double ConvertFromIeeeExtended(const unsigned char *bytes)
	158	{
	159	double f;
	160	int expon;
	161	unsigned long hiMant, loMant;
	162
	163	expon = ((bytes[0] & 0x7F) << 8) \| (bytes[1] & 0xFF);
	164	hiMant = ((unsigned long)(bytes[2] & 0xFF) << 24)
	165	\| ((unsigned long) (bytes[3] & 0xFF) << 16)
	166	\| ((unsigned long) (bytes[4] & 0xFF) << 8)
	167	\| ((unsigned long) (bytes[5] & 0xFF));
	168	loMant = ((unsigned long) (bytes[6] & 0xFF) << 24)
	169	\| ((unsigned long) (bytes[7] & 0xFF) << 16)
	170	\| ((unsigned long) (bytes[8] & 0xFF) << 8)
	171	\| ((unsigned long) (bytes[9] & 0xFF));
	172
	173	if (expon == 0 && hiMant == 0 && loMant == 0) {
	174	f = 0;
	175	}
	176	else {
	177	if (expon == 0x7FFF) { /* Infinity or NaN */
	178	f = HUGE_VAL;
	179	}
	180	else {
	181	expon -= 16383;
	182	f = ldexp(UnsignedToFloat(hiMant), expon-=31);
	183	f += ldexp(UnsignedToFloat(loMant), expon-=32);
	184	}
	185	}
	186
	187	if (bytes[0] & 0x80)
	188	return -f;
	189	else
	190	return f;
	191	}
	192
	193	#endif /* wxUSE_APPLE_IEEE */