d0p1/ack
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Updated for ANSI C, cleaned up a bit

Browse source
This commit is contained in:
ceriel 1993-01-05 12:06:58 +00:00
parent 55131b091f
commit 005f32298f
38 changed files with 295 additions and 262 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

112
mach/proto/fp/FP_types.h
View file

@ -13,7 +13,7 @@
/********************************************************/
/*
THESE STRUCTURES ARE USED TO ADDRESS THE INDIVIDUAL
PARTS OF THE FLOATING NUMBER REPRESENTATIONS.
PARTS OF THE FLOATING POINT NUMBER REPRESENTATIONS.
THREE STRUCTURES ARE DEFINED:
SINGLE: single precision floating format
@ -22,48 +22,92 @@
*/
/********************************************************/
#ifdef EXT_DEBUG
#ifndef __FPSTDIO
#define __FPSTDIO
#include <stdio.h>
#endif
#endif
#ifndef __FPTYPES
#define __FPTYPES
typedef unsigned long _float;
typedef union {
double _dbl;
unsigned long __double[2];
} _double;
typedef struct {
unsigned long h_32; /* higher 32 bits of 64 */
unsigned long l_32; /* lower 32 bits of 64 */
} B64;
typedef union { /* address parts of float */
/* field to extract exponent */
short sgl_exp[sizeof(float)/sizeof(short)];
/* same as fract below */
_float f[sizeof(float)/sizeof(_float)];
unsigned long fract;
} SINGLE;
typedef unsigned long SINGLE;
typedef union {
/* field to extract exponent */
short dbl_exp[sizeof(double)/sizeof(short)];
/* for normal syntax use */
_double _f8[sizeof(double)/sizeof(_double)];
/* a float in a double - for returns */
_float _f4[sizeof(double)/sizeof(_float)];
/* to be deleted eventually */
struct { /* address parts of float */
SINGLE p1; /* part one */
unsigned long p2; /* part two */
} _s;
typedef struct {
unsigned long d[2];
} DOUBLE;
typedef struct { /* expanded float format */
short sign;
short exp;
unsigned long m1;
unsigned long m2; /* includes guard byte */
B64 mantissa;
#define m1 mantissa.h_32
#define m2 mantissa.l_32
} EXTEND;
struct fef4_returns {
int e;
SINGLE f;
};
struct fef8_returns {
int e;
DOUBLE f;
};
struct fif4_returns {
SINGLE ipart;
SINGLE fpart;
};
struct fif8_returns {
DOUBLE ipart;
DOUBLE fpart;
};
#if __STDC__
#define _PROTOTYPE(function, params) function params
#else
#define _PROTOTYPE(function, params) function()
#endif
_PROTOTYPE( void add_ext, (EXTEND *e1, EXTEND *e2));
_PROTOTYPE( void mul_ext, (EXTEND *e1, EXTEND *e2));
_PROTOTYPE( void div_ext, (EXTEND *e1, EXTEND *e2));
_PROTOTYPE( void sub_ext, (EXTEND *e1, EXTEND *e2));
_PROTOTYPE( void sft_ext, (EXTEND *e1, EXTEND *e2));
_PROTOTYPE( void nrm_ext, (EXTEND *e1));
_PROTOTYPE( void zrf_ext, (EXTEND *e1));
_PROTOTYPE( void extend, (unsigned long *from, EXTEND *to, int size));
_PROTOTYPE( void compact, (EXTEND *from, unsigned long *to, int size));
_PROTOTYPE( void _fptrp, (int));
_PROTOTYPE( SINGLE adf4, (SINGLE s2, SINGLE s1));
_PROTOTYPE( DOUBLE adf8, (DOUBLE s2, DOUBLE s1));
_PROTOTYPE( SINGLE sbf4, (SINGLE s2, SINGLE s1));
_PROTOTYPE( DOUBLE sbf8, (DOUBLE s2, DOUBLE s1));
_PROTOTYPE( SINGLE dvf4, (SINGLE s2, SINGLE s1));
_PROTOTYPE( DOUBLE dvf8, (DOUBLE s2, DOUBLE s1));
_PROTOTYPE( SINGLE mlf4, (SINGLE s2, SINGLE s1));
_PROTOTYPE( DOUBLE mlf8, (DOUBLE s2, DOUBLE s1));
_PROTOTYPE( SINGLE ngf4, (SINGLE f));
_PROTOTYPE( DOUBLE ngf8, (DOUBLE f));
_PROTOTYPE( void zrf4, (SINGLE *l));
_PROTOTYPE( void zrf8, (DOUBLE *z));
_PROTOTYPE( SINGLE cff4, (DOUBLE src));
_PROTOTYPE( DOUBLE cff8, (SINGLE src));
_PROTOTYPE( SINGLE cif4, (int ss, long src));
_PROTOTYPE( DOUBLE cif8, (int ss, long src));
_PROTOTYPE( SINGLE cuf4, (int ss, long src));
_PROTOTYPE( DOUBLE cuf8, (int ss, long src));
_PROTOTYPE( long cfu, (int ds, int ss, DOUBLE src));
_PROTOTYPE( long cfi, (int ds, int ss, DOUBLE src));
_PROTOTYPE( int cmf4, (SINGLE s2, SINGLE s1));
_PROTOTYPE( int cmf8, (DOUBLE d1, DOUBLE d2));
_PROTOTYPE( void fef4, (struct fef4_returns *r, SINGLE s1));
_PROTOTYPE( void fef8, (struct fef8_returns *r, DOUBLE s1));
_PROTOTYPE( void fif4, (struct fif4_returns *p, SINGLE x, SINGLE y));
_PROTOTYPE( void fif8, (struct fif8_returns *p, DOUBLE x, DOUBLE y));
_PROTOTYPE( void b64_sft, (B64 *, int));
_PROTOTYPE( void b64_lsft, (B64 *));
_PROTOTYPE( void b64_rsft, (B64 *));
_PROTOTYPE( int b64_add, (B64 *, B64 *));
#endif

5
mach/proto/fp/add_ext.c
View file

@ -11,6 +11,7 @@
#include "FP_types.h"
void
add_ext(e1,e2)
register EXTEND *e1,*e2;
{
@ -45,8 +46,8 @@ register EXTEND *e1,*e2;
}
}
else {
if (b64_add(&e1->m1,&e2->m1)) { /* addition carry */
b64_rsft(&e1->m1); /* shift mantissa one bit RIGHT */
if (b64_add(&e1->mantissa,&e2->mantissa)) { /* addition carry */
b64_rsft(&e1->mantissa); /* shift mantissa one bit RIGHT */
e1->m1 |= 0x80000000L; /* set max bit */
e1->exp++; /* increase the exponent */
}

4
mach/proto/fp/adder.c
View file

@ -13,7 +13,7 @@
# include <stdio.h>
# endif
# include "adder.h"
# include "FP_types.h"
# define UNKNOWN -1
# define TRUE 1
# define FALSE 0
@ -22,6 +22,7 @@
/*
* add 64 bits
*/
int
b64_add(e1,e2)
/*
* pointers to 64 bit 'registers'
@ -45,6 +46,5 @@ register B64 *e1,*e2;
# endif
if ((carry) && (++e1->h_32 == 0))
return(TRUE); /* had a 64 bit overflow */
else
return(overflow); /* return status from higher add */
}

14
mach/proto/fp/adf4.c
View file

@ -11,23 +11,23 @@
#include "FP_types.h"
_float
SINGLE
adf4(s2,s1)
_float s1,s2;
SINGLE s1,s2;
{
EXTEND e1,e2;
int swap = 0;
if (s1 == (_float) 0) {
if (s1 == (SINGLE) 0) {
s1 = s2;
return s1;
}
if (s2 == (_float) 0) {
if (s2 == (SINGLE) 0) {
return s1;
}
extend((_double *)&s1,&e1,sizeof(SINGLE));
extend((_double *)&s2,&e2,sizeof(SINGLE));
extend(&s1,&e1,sizeof(SINGLE));
extend(&s2,&e2,sizeof(SINGLE));
add_ext(&e1,&e2);
compact(&e1,(_double *)&s1,sizeof(SINGLE));
compact(&e1,&s1,sizeof(SINGLE));
return s1;
}

14
mach/proto/fp/adf8.c
View file

@ -11,23 +11,23 @@
#include "FP_types.h"
_double
DOUBLE
adf8(s2,s1)
_double s1,s2;
DOUBLE s1,s2;
{
EXTEND e1,e2;
if (s1.__double[0] == 0 && s1.__double[1] == 0) {
if (s1.d[0] == 0 && s1.d[1] == 0) {
s1 = s2;
return s1;
}
if (s2.__double[0] == 0 && s2.__double[1] == 0) {
if (s2.d[0] == 0 && s2.d[1] == 0) {
return s1;
}
extend(&s1,&e1,sizeof(_double));
extend(&s2,&e2,sizeof(_double));
extend(&s1.d[0],&e1,sizeof(DOUBLE));
extend(&s2.d[0],&e2,sizeof(DOUBLE));
add_ext(&e1,&e2);
compact(&e1,&s1,sizeof(_double));
compact(&e1,&s1.d[0],sizeof(DOUBLE));
return s1;
}

12
mach/proto/fp/cff4.c
View file

@ -6,7 +6,7 @@
/* $Header$ */
/*
CONVERT DOUBLE TO FLOAT (CFF 8 4)
CONVERT DOUBLE TO SINGLE (CFF 8 4)
This routine works quite simply. A floating point
of size 08 is converted to extended format.
@ -17,13 +17,13 @@
#include "FP_types.h"
_float
SINGLE
cff4(src)
_double src; /* the source itself - THIS TIME it's DOUBLE */
DOUBLE src; /* the source itself - THIS TIME it's DOUBLE */
{
EXTEND buf;
extend(&src,&buf,8); /* no matter what */
compact(&buf,(_double *) &(src.__double[1]),4);
return *(_float *)&(src.__double[1]);
extend(&src.d[0],&buf,sizeof(DOUBLE)); /* no matter what */
compact(&buf,&(src.d[1]),sizeof(SINGLE));
return *(SINGLE *)&(src.d[1]);
}

12
mach/proto/fp/cff8.c
View file

@ -6,7 +6,7 @@
/* $Header$ */
/*
CONVERT FLOAT TO DOUBLE (CFF 4 8)
CONVERT SINGLE TO DOUBLE (CFF 4 8)
This routine works quite simply. A floating point
of size 04 is converted to extended format.
@ -17,13 +17,13 @@
#include "FP_types.h"
_double
DOUBLE
cff8(src)
_float src;
SINGLE src;
{
EXTEND buf;
extend((_double *) &src,&buf,4); /* no matter what */
compact(&buf,(_double *) &src,8);
return *(_double *) &src;
extend(&src,&buf,sizeof(SINGLE)); /* no matter what */
compact(&buf, &src,sizeof(DOUBLE));
return *(DOUBLE *) ((void *) &src);
}

8
mach/proto/fp/cfi.c
View file

@ -21,15 +21,15 @@ long
cfi(ds,ss,src)
int ds; /* destination size (2 or 4) */
int ss; /* source size (4 or 8) */
_double src; /* assume worst case */
DOUBLE src; /* assume worst case */
{
EXTEND buf;
long new;
short max_exp;
extend(&src,&buf,ss); /* get extended format */
extend(&src.d[0],&buf,ss); /* get extended format */
if (buf.exp < 0) { /* no conversion needed */
src.__double[ss == 8] = 0L;
src.d[ss == 8] = 0L;
return(0L);
}
max_exp = (ds << 3) - 2; /* signed numbers */
@ -47,6 +47,6 @@ _double src; /* assume worst case */
if (buf.sign)
new = -new;
done:
src.__double[ss == 8] = new;
src.d[ss == 8] = new;
return(new);
}

8
mach/proto/fp/cfu.c
View file

@ -20,15 +20,15 @@ long
cfu(ds,ss,src)
int ds; /* destination size (2 or 4) */
int ss; /* source size (4 or 8) */
_double src; /* assume worst case */
DOUBLE src; /* assume worst case */
{
EXTEND buf;
long new;
short newint, max_exp;
extend(&src,&buf,ss); /* get extended format */
extend(&src.d[0],&buf,ss); /* get extended format */
if (buf.exp < 0) { /* no conversion needed */
src.__double[ss == 8] = 0L;
src.d[ss == 8] = 0L;
return(0L);
}
max_exp = (ds << 3) - 1;
@ -38,6 +38,6 @@ _double src; /* assume worst case */
}
new = buf.m1 >> (31-buf.exp);
done:
src.__double[ss == 8] = new;
src.d[ss == 8] = new;
return(new);
}

14
mach/proto/fp/cif4.c
View file

@ -6,7 +6,7 @@
/* $Header$ */
/*
CONVERT INTEGER TO FLOAT (CIF n 4)
CONVERT INTEGER TO SINGLE (CIF n 4)
THIS ROUTINE WORKS BY FILLING AN EXTENDED
WITH THE INTEGER VALUE IN EXTENDED FORMAT
@ -16,7 +16,7 @@
#include "FP_types.h"
_float
SINGLE
cif4(ss,src)
int ss; /* source size */
long src; /* largest possible integer to convert */
@ -24,22 +24,22 @@ long src; /* largest possible integer to convert */
EXTEND buf;
short *ipt;
long i_src;
_float *result;
SINGLE *result;
zrf_ext(&buf);
if (ss == sizeof(long)) {
buf.exp = 31;
i_src = src;
result = (_float *) &src;
result = (SINGLE *) &src;
}
else {
ipt = (short *) &src;
i_src = (long) *ipt;
buf.exp = 15;
result = (_float *) &ss;
result = (SINGLE *) &ss;
}
if (i_src == 0) {
*result = (_float) 0L;
*result = (SINGLE) 0L;
return(0L);
}
/* ESTABLISHED THAT src != 0 */
@ -52,6 +52,6 @@ long src; /* largest possible integer to convert */
if (ss != sizeof(long))
buf.m1 <<= 16;
nrm_ext(&buf); /* adjust mantissa field */
compact(&buf,(_double *) result,4); /* put on stack */
compact(&buf, result,sizeof(SINGLE)); /* put on stack */
return(*result);
}

8
mach/proto/fp/cif8.c
View file

@ -16,17 +16,17 @@
#include "FP_types.h"
_double
DOUBLE
cif8(ss,src)
int ss; /* source size */
long src; /* largest possible integer to convert */
{
EXTEND buf;
_double *result; /* for return value */
DOUBLE *result; /* for return value */
short *ipt;
long i_src;
result = (_double *) &ss; /* always */
result = (DOUBLE *) ((void *) &ss); /* always */
zrf_ext(&buf);
if (ss == sizeof(long)) {
buf.exp = 31;
@ -51,6 +51,6 @@ long src; /* largest possible integer to convert */
if (ss != sizeof(long))
buf.m1 <<= 16;
nrm_ext(&buf);
compact(&buf,result,8);
compact(&buf,&result->d[0],8);
return(*result);
}

2
mach/proto/fp/cmf4.c
View file

@ -14,7 +14,7 @@
int
cmf4(f1,f2)
_float f1,f2;
SINGLE f1,f2;
{
/*
* return ((f1 < f2) ? 1 : (f1 - f2))

3
mach/proto/fp/cmf8.c
View file

@ -12,8 +12,9 @@
#include "FP_types.h"
#include "get_put.h"
int
cmf8(d1,d2)
_double d1,d2;
DOUBLE d1,d2;
{
#define SIGN(x) (((x) < 0) ? -1 : 1)
/*

79
mach/proto/fp/compact.c
View file

@ -15,21 +15,22 @@
# include "FP_types.h"
# include "get_put.h"
void
compact(f,to,size)
EXTEND *f;
_double *to;
unsigned long *to;
int size;
{
int error = 0;
if (size == sizeof(_double)) {
if (size == sizeof(DOUBLE)) {
/*
* COMPACT EXTENDED INTO DOUBLE
*/
DOUBLE *DBL;
DOUBLE *DBL = (DOUBLE *) (void *) to;
if ((f->m1|(f->m2 & DBL_ZERO)) == 0L) {
zrf8(to);
zrf8(DBL);
return;
}
f->exp += DBL_BIAS; /* restore proper bias */
@ -42,25 +43,24 @@ dbl_over: trap(EFOVFL);
return;
}
else if (f->exp < DBL_MIN) {
b64_rsft(&(f->m1));
b64_rsft(&(f->mantissa));
if (f->exp < 0) {
b64_sft(&(f->m1), -f->exp);
b64_sft(&(f->mantissa), -f->exp);
f->exp = 0;
}
/* underflow ??? */
}
/* local CAST conversion */
DBL = (DOUBLE *) to;
/* because of special format shift only 10 bits */
/* bit shift mantissa 10 bits */
/* first align within words, then do store operation */
DBL->_s.p1.fract = f->m1 >> DBL_RUNPACK; /* plus 22 == 32 */
DBL->_s.p2 = f->m2 >> DBL_RUNPACK; /* plus 22 == 32 */
DBL->_s.p2 |= (f->m1 << DBL_LUNPACK); /* plus 10 == 32 */
DBL->d[0] = f->m1 >> DBL_RUNPACK; /* plus 22 == 32 */
DBL->d[1] = f->m2 >> DBL_RUNPACK; /* plus 22 == 32 */
DBL->d[1] |= (f->m1 << DBL_LUNPACK); /* plus 10 == 32 */
/* if not exact then round to nearest */
/* on a tie, round to even */
@ -72,17 +72,17 @@ dbl_over: trap(EFOVFL);
if (((f->m2 & DBL_EXACT) > DBL_ROUNDUP)
|| ((f->m2 & DBL_EXACT) == DBL_ROUNDUP
&& (f->m2 & (DBL_ROUNDUP << 1)))) {
DBL->_s.p2++; /* rounding up */
if (DBL->_s.p2 == 0L) { /* carry out */
DBL->_s.p1.fract++;
DBL->d[1]++; /* rounding up */
if (DBL->d[1] == 0L) { /* carry out */
DBL->d[0]++;
if (f->exp == 0 && (DBL->_s.p1.fract & ~DBL_MASK)) {
if (f->exp == 0 && (DBL->d[0] & ~DBL_MASK)) {
f->exp++;
}
if (DBL->_s.p1.fract & DBL_CARRYOUT) { /* carry out */
if (DBL->_s.p1.fract & 01)
DBL->_s.p2 = CARRYBIT;
DBL->_s.p1.fract >>= 1;
if (DBL->d[0] & DBL_CARRYOUT) { /* carry out */
if (DBL->d[0] & 01)
DBL->d[1] = CARRYBIT;
DBL->d[0] >>= 1;
f->exp++;
}
}
@ -101,24 +101,24 @@ dbl_over: trap(EFOVFL);
* 2) shift and store exponent
*/
DBL->_s.p1.fract &= DBL_MASK;
DBL->_s.p1.fract |=
DBL->d[0] &= DBL_MASK;
DBL->d[0] |=
((long) (f->exp << DBL_EXPSHIFT) << EXP_STORE);
if (f->sign)
DBL->_s.p1.fract |= CARRYBIT;
DBL->d[0] |= CARRYBIT;
/*
* STORE MANTISSA
*/
#if FL_MSL_AT_LOW_ADDRESS
put4(DBL->_s.p1.fract, (char *) &DBL->_s.p1.fract);
put4(DBL->_s.p2, (char *) &DBL->_s.p2);
put4(DBL->d[0], (char *) &DBL->d[0]);
put4(DBL->d[1], (char *) &DBL->d[1]);
#else
{ unsigned long l;
put4(DBL->_s.p2, (char *) &l);
put4(DBL->_s.p1.fract, (char *) &DBL->_s.p2);
DBL->_s.p1.fract = l;
put4(DBL->d[1], (char *) &l);
put4(DBL->d[0], (char *) &DBL->d[1]);
DBL->d[0] = l;
}
#endif
}
@ -129,9 +129,9 @@ dbl_over: trap(EFOVFL);
SINGLE *SGL;
/* local CAST conversion */
SGL = (SINGLE *) to;
SGL = (SINGLE *) (void *) to;
if ((f->m1 & SGL_ZERO) == 0L) {
SGL->fract = 0L;
*SGL = 0L;
return;
}
f->exp += SGL_BIAS; /* restore bias */
@ -144,16 +144,16 @@ sgl_over: trap(EFOVFL);
return;
}
else if (f->exp < SGL_MIN) {
b64_rsft(&(f->m1));
b64_rsft(&(f->mantissa));
if (f->exp < 0) {
b64_sft(&(f->m1), -f->exp);
b64_sft(&(f->mantissa), -f->exp);
f->exp = 0;
}
/* underflow ??? */
}
/* shift mantissa and store */
SGL->fract = (f->m1 >> SGL_RUNPACK);
*SGL = (f->m1 >> SGL_RUNPACK);
/* check for rounding to nearest */
/* on a tie, round to even */
@ -165,13 +165,13 @@ sgl_over: trap(EFOVFL);
if (((f->m1 & SGL_EXACT) > SGL_ROUNDUP)
|| ((f->m1 & SGL_EXACT) == SGL_ROUNDUP
&& (f->m1 & (SGL_ROUNDUP << 1)))) {
SGL->fract++;
if (f->exp == 0 && (SGL->fract & ~SGL_MASK)) {
(*SGL)++;
if (f->exp == 0 && (*SGL & ~SGL_MASK)) {
f->exp++;
}
/* check normal */
if (SGL->fract & SGL_CARRYOUT) {
SGL->fract >>= 1;
if (*SGL & SGL_CARRYOUT) {
*SGL >>= 1;
f->exp++;
}
if (f->exp > SGL_MAX)
@ -188,16 +188,15 @@ sgl_over: trap(EFOVFL);
* 2) shift and store exponent
*/
SGL->fract &= SGL_MASK; /* B23-B31 are 0 */
SGL->fract |=
((long) (f->exp << SGL_EXPSHIFT) << EXP_STORE);
*SGL &= SGL_MASK; /* B23-B31 are 0 */
*SGL |= ((long) (f->exp << SGL_EXPSHIFT) << EXP_STORE);
if (f->sign)
SGL->fract |= CARRYBIT;
*SGL |= CARRYBIT;
/*
* STORE MANTISSA
*/
put4(SGL->fract, (char *) &SGL->fract);
put4(*SGL, (char *) &SGL);
}
}

16
mach/proto/fp/cuf4.c
View file

@ -6,7 +6,7 @@
/* $Header$ */
/*
CONVERT INTEGER TO FLOAT (CUF n 4)
CONVERT INTEGER TO SINGLE (CUF n 4)
THIS ROUTINE WORKS BY FILLING AN EXTENDED
WITH THE INTEGER VALUE IN EXTENDED FORMAT
@ -16,31 +16,31 @@
#include "FP_types.h"
_float
SINGLE
cuf4(ss,src)
int ss; /* source size */
long src; /* largest possible integer to convert */
{
EXTEND buf;
short *ipt;
_float *result;
SINGLE *result;
long i_src;
zrf_ext(&buf);
if (ss == sizeof(long)) {
buf.exp = 31;
i_src = src;
result = (_float *) &src;
result = (SINGLE *) &src;
}
else {
ipt = (short *) &src;
i_src = (long) *ipt;
buf.exp = 15;
result = (_float *) &ss;
result = (SINGLE *) ((void *) &ss);
}
if (i_src == 0) {
*result = (_float) 0L;
return (_float) 0L;
*result = (SINGLE) 0L;
return (SINGLE) 0L;
}
/* ESTABLISHED THAT src != 0 */
@ -53,6 +53,6 @@ long src; /* largest possible integer to convert */
/* adjust mantissa field */
nrm_ext(&buf);
compact(&buf,(_double *) result,4);
compact(&buf,result,4);
return *result;
}

8
mach/proto/fp/cuf8.c
View file

@ -16,7 +16,7 @@
#include "FP_types.h"
_double
DOUBLE
cuf8(ss,src)
int ss; /* source size */
long src; /* largest possible integer to convert */
@ -36,7 +36,7 @@ long src; /* largest possible integer to convert */
buf.exp = 15;
}
if (i_src == 0) {
zrf8(&ss);
zrf8((DOUBLE *)((void *)&ss));
return;
}
/* ESTABLISHED THAT src != 0 */
@ -50,6 +50,6 @@ long src; /* largest possible integer to convert */
/* adjust mantissa field */
nrm_ext(&buf);
compact(&buf,(_double *) &ss,8);
return *((_double *) &ss);
compact(&buf,(unsigned long *) (void *)&ss,8);
return *((DOUBLE *) (void *)&ss);
}

34
mach/proto/fp/div_ext.c
View file

@ -26,11 +26,12 @@
*/
/********************************************************/
void
div_ext(e1,e2)
EXTEND *e1,*e2;
{
short error = 0;
unsigned long result[2];
B64 result;
register unsigned long *lp;
#ifndef USE_DIVIDE
short count;
@ -60,8 +61,8 @@ EXTEND *e1,*e2;
* that m1 is quaranteed to be larger if its
* maximum bit is set
*/
b64_rsft(&e1->m1); /* 64 bit shift right */
b64_rsft(&e2->m1); /* 64 bit shift right */
b64_rsft(&e1->mantissa); /* 64 bit shift right */
b64_rsft(&e2->mantissa); /* 64 bit shift right */
e1->exp++;
e2->exp++;
#endif
@ -75,8 +76,8 @@ EXTEND *e1,*e2;
/* init control variables */
count = 64;
result[0] = 0L;
result[1] = 0L;
result.h_32 = 0L;
result.l_32 = 0L;
/* partial product division loop */
@ -84,7 +85,7 @@ EXTEND *e1,*e2;
/* first left shift result 1 bit */
/* this is ALWAYS done */
b64_lsft(result);
b64_lsft(&result);
/* compare dividend and divisor */
/* if dividend >= divisor add a bit */
@ -95,7 +96,7 @@ EXTEND *e1,*e2;
; /* null statement */
/* i.e., don't add or subtract */
else {
result[1]++; /* ADD */
result.l_32++; /* ADD */
if (e2->m2 > e1->m2)
e1->m1 -= 1; /* carry in */
e1->m1 -= e2->m1; /* do SUBTRACTION */
@ -116,7 +117,7 @@ EXTEND *e1,*e2;
error = ((*lp | *(lp+1)) != 0L) ? 1 : 0;
if (error) { /* more work */
/* assume max bit == 0 (see above) */
b64_lsft(&e1->m1);
b64_lsft(&e1->mantissa);
continue;
}
else
@ -124,7 +125,7 @@ EXTEND *e1,*e2;
} /* end of divide by subtraction loop */
if (count > 0) {
lp = result;
lp = &result.h_32;
if (count > 31) { /* move to higher word */
*lp = *(lp+1);
count -= 32;
@ -132,16 +133,16 @@ EXTEND *e1,*e2;
}
if (*lp)
*lp <<= count; /* shift rest of way */
lp++; /* == &result[1] */
lp++; /* == &result.l_32 */
if (*lp) {
result[0] |= (*lp >> 32-count);
result.h_32 |= (*lp >> 32-count);
*lp <<= count;
}
}
#else /* USE_DIVIDE */
u[4] = (e1->m2 & 1) << 15;
b64_rsft(&(e1->m1));
b64_rsft(&(e1->mantissa));
u[0] = e1->m1 >> 16;
u[1] = e1->m1;
u[2] = e1->m2 >> 16;
@ -152,9 +153,9 @@ EXTEND *e1,*e2;
v[3] = e2->m2 >> 16;
v[4] = e2->m2;
while (! v[maxv]) maxv--;
result[0] = 0;
result[1] = 0;
lp = result;
result.h_32 = 0;
result.l_32 = 0;
lp = &result.h_32;
/*
* Use an algorithm of Knuth (The art of programming, Seminumerical
@ -241,8 +242,7 @@ EXTEND *e1,*e2;
*/
INEXACT();
#endif
e1->m1 = result[0];
e1->m2 = result[1];
e1->mantissa = result;
nrm_ext(e1);
if (e1->exp < EXT_MIN) {

12
mach/proto/fp/dvf4.c
View file

@ -6,22 +6,22 @@
/* $Header$ */
/*
DIVIDE TWO FLOATS - SINGLE Precision (dvf 4)
DIVIDE TWO SINGLES - SINGLE Precision (dvf 4)
*/
#include "FP_types.h"
_float
SINGLE
dvf4(s2,s1)
_float s1,s2;
SINGLE s1,s2;
{
EXTEND e1,e2;
extend((_double *)&s1,&e1,sizeof(_float));
extend((_double *)&s2,&e2,sizeof(_float));
extend(&s1,&e1,sizeof(SINGLE));
extend(&s2,&e2,sizeof(SINGLE));
/* do a divide */
div_ext(&e1,&e2);
compact(&e1,(_double *)&s1,sizeof(_float));
compact(&e1,&s1,sizeof(SINGLE));
return s1;
}

10
mach/proto/fp/dvf8.c
View file

@ -11,17 +11,17 @@
#include "FP_types.h"
_double
DOUBLE
dvf8(s2,s1)
_double s1,s2;
DOUBLE s1,s2;
{
EXTEND e1,e2;
extend(&s1,&e1,sizeof(_double));
extend(&s2,&e2,sizeof(_double));
extend(&s1.d[0],&e1,sizeof(DOUBLE));
extend(&s2.d[0],&e2,sizeof(DOUBLE));
/* do a divide */
div_ext(&e1,&e2);
compact(&e1,&s1,sizeof(_double));
compact(&e1,&s1.d[0],sizeof(DOUBLE));
return s1;
}

3
mach/proto/fp/extend.c
View file

@ -32,8 +32,9 @@
#include "get_put.h"
/********************************************************/
void
extend(from,to,size)
_double *from;
unsigned long *from;
EXTEND *to;
int size;
{

12
mach/proto/fp/fef4.c
View file

@ -11,13 +11,9 @@
#include "FP_types.h"
struct fef4_returns {
int e;
_float f;
};
void
fef4(r,s1)
_float s1;
SINGLE s1;
struct fef4_returns *r;
{
EXTEND buf;
@ -25,7 +21,7 @@ struct fef4_returns *r;
to itself (see table)
*/
extend((_double *) &s1,&buf,sizeof(_float));
extend(&s1,&buf,sizeof(SINGLE));
if (buf.exp == 0 && buf.m1 == 0 && buf.m2 == 0) {
p->e = 0;
}
@ -33,5 +29,5 @@ struct fef4_returns *r;
p->e = buf.exp+1;
buf.exp = -1;
}
compact(&buf,(_double *) &p->f,sizeof(_float));
compact(&buf,&p->f,sizeof(SINGLE));
}

12
mach/proto/fp/fef8.c
View file

@ -11,13 +11,9 @@
#include "FP_types.h"
struct fef8_returns {
int e;
_double f;
};
void
fef8(r, s1)
_double s1;
DOUBLE s1;
struct fef8_returns *r;
{
EXTEND buf;
@ -25,7 +21,7 @@ struct fef8_returns *r;
to itself (see table)
*/
extend(&s1,&buf,sizeof(_double));
extend(&s1.d[0],&buf,sizeof(DOUBLE));
if (buf.exp == 0 && buf.m1 == 0 && buf.m2 == 0) {
p->e = 0;
}
@ -33,5 +29,5 @@ struct fef8_returns *r;
p->e = buf.exp + 1;
buf.exp = -1;
}
compact(&buf,&p->f,sizeof(_double));
compact(&buf,&p->f.d[0],sizeof(DOUBLE));
}

22
mach/proto/fp/fif4.c
View file

@ -12,26 +12,20 @@
#include "FP_types.h"
#include "FP_shift.h"
_float sbf4();
struct fif4_returns {
_float ipart;
_float fpart;
};
void
fif4(p,x,y)
_float x,y;
SINGLE x,y;
struct fif4_returns *p;
{
EXTEND e1,e2;
extend((_double *)&y,&e1,sizeof(_float));
extend((_double *)&x,&e2,sizeof(_float));
extend(&y,&e1,sizeof(SINGLE));
extend(&x,&e2,sizeof(SINGLE));
/* do a multiply */
mul_ext(&e1,&e2);
e2 = e1;
compact(&e2, (_double *)&y, sizeof(_float));
compact(&e2,&y,sizeof(SINGLE));
if (e1.exp < 0) {
p->ipart = 0;
p->fpart = y;
@ -42,8 +36,8 @@ struct fif4_returns *p;
p->fpart = 0;
return;
}
b64_sft(&e1.m1, 63 - e1.exp);
b64_sft(&e1.m1, e1.exp - 63); /* "loose" low order bits */
compact(&e1,(_double *) &(p->ipart), sizeof(SINGLE));
b64_sft(&e1.mantissa, 63 - e1.exp);
b64_sft(&e1.mantissa, e1.exp - 63); /* "loose" low order bits */
compact(&e1,&(p->ipart),sizeof(SINGLE));
p->fpart = sbf4(p->ipart, y);
}

30
mach/proto/fp/fif8.c
View file

@ -12,40 +12,34 @@
#include "FP_types.h"
#include "FP_shift.h"
_double sbf8();
struct fif8_returns {
_double ipart;
_double fpart;
};
void
fif8(p,x,y)
_double x,y;
DOUBLE x,y;
struct fif8_returns *p;
{
EXTEND e1,e2;
extend(&y,&e1,sizeof(_double));
extend(&x,&e2,sizeof(_double));
extend(&y.d[0],&e1,sizeof(DOUBLE));
extend(&x.d[0],&e2,sizeof(DOUBLE));
/* do a multiply */
mul_ext(&e1,&e2);
e2 = e1;
compact(&e2, &y, sizeof(_double));
compact(&e2, &y.d[0], sizeof(DOUBLE));
if (e1.exp < 0) {
p->ipart.__double[0] = 0;
p->ipart.__double[1] = 0;
p->ipart.d[0] = 0;
p->ipart.d[1] = 0;
p->fpart = y;
return;
}
if (e1.exp > 62 - DBL_M1LEFT) {
p->ipart = y;
p->fpart.__double[0] = 0;
p->fpart.__double[1] = 0;
p->fpart.d[0] = 0;
p->fpart.d[1] = 0;
return;
}
b64_sft(&e1.m1, 63 - e1.exp);
b64_sft(&e1.m1, e1.exp - 63); /* "loose" low order bits */
compact(&e1, &(p->ipart), sizeof(DOUBLE));
b64_sft(&e1.mantissa, 63 - e1.exp);
b64_sft(&e1.mantissa, e1.exp - 63); /* "loose" low order bits */
compact(&e1, &(p->ipart.d[0]), sizeof(DOUBLE));
p->fpart = sbf8(p->ipart, y);
}

10
mach/proto/fp/mlf4.c
View file

@ -11,16 +11,16 @@
#include "FP_types.h"
_float
SINGLE
mlf4(s2,s1)
_float s1,s2;
SINGLE s1,s2;
{
EXTEND e1,e2;
extend((_double *)&s1,&e1,sizeof(_float));
extend((_double *)&s2,&e2,sizeof(_float));
extend(&s1,&e1,sizeof(SINGLE));
extend(&s2,&e2,sizeof(SINGLE));
/* do a multiply */
mul_ext(&e1,&e2);
compact(&e1,(_double *)&s1,sizeof(_float));
compact(&e1,&s1,sizeof(SINGLE));
return(s1);
}

12
mach/proto/fp/mlf8.c
View file

@ -6,21 +6,21 @@
/* $Header$ */
/*
* Multiply Single Precision Float (MLF 8)
* Multiply Double Precision Float (MLF 8)
*/
#include "FP_types.h"
_double
DOUBLE
mlf8(s2,s1)
_double s1,s2;
DOUBLE s1,s2;
{
EXTEND e1,e2;
extend(&s1,&e1,sizeof(_double));
extend(&s2,&e2,sizeof(_double));
extend(&s1.d[0],&e1,sizeof(DOUBLE));
extend(&s2.d[0],&e2,sizeof(DOUBLE));
/* do a multiply */
mul_ext(&e1,&e2);
compact(&e1,&s1,sizeof(_double));
compact(&e1,&s1.d[0],sizeof(DOUBLE));
return(s1);
}

2
mach/proto/fp/mul_ext.c
View file

@ -9,12 +9,12 @@
ROUTINE TO MULTIPLY TWO EXTENDED FORMAT NUMBERS
*/
# include "adder.h"
# include "FP_bias.h"
# include "FP_trap.h"
# include "FP_types.h"
# include "FP_shift.h"
void
mul_ext(e1,e2)
EXTEND *e1,*e2;
{

6
mach/proto/fp/ngf4.c
View file

@ -14,13 +14,13 @@
#include "get_put.h"
#define OFF ((FL_MSW_AT_LOW_ADDRESS ? 0 : 2) + (FL_MSB_AT_LOW_ADDRESS ? 0 : 1))
_float
SINGLE
ngf4(f)
_float f;
SINGLE f;
{
unsigned char *p;
if (f != (_float) 0) {
if (f != (SINGLE) 0) {
p = (unsigned char *) &f + OFF;
*p ^= 0x80;
}

6
mach/proto/fp/ngf8.c
View file

@ -15,13 +15,13 @@
#define OFF ((FL_MSL_AT_LOW_ADDRESS ? 0 : 4) + (FL_MSW_AT_LOW_ADDRESS ? 0 : 2) + (FL_MSB_AT_LOW_ADDRESS ? 0 : 1))
_double
DOUBLE
ngf8(f)
_double f;
DOUBLE f;
{
unsigned char *p;
if (f.__double[0] != 0 || f.__double[1] != 0) {
if (f.d[0] != 0 || f.d[1] != 0) {
p = (unsigned char *) &f + OFF;
*p ^= 0x80;
}

3
mach/proto/fp/nrm_ext.c
View file

@ -14,6 +14,7 @@
#include "FP_shift.h"
#include "FP_types.h"
void
nrm_ext(e1)
EXTEND *e1;
{
@ -44,6 +45,6 @@ EXTEND *e1;
cnt--;
}
e1->exp += cnt;
b64_sft(&(e1->m1), cnt);
b64_sft(&(e1->mantissa), cnt);
}
}

10
mach/proto/fp/sbf4.c
View file

@ -11,15 +11,13 @@
#include "FP_types.h"
extern _float adf4(), ngf4();
_float
SINGLE
sbf4(s2,s1)
_float s1,s2;
SINGLE s1,s2;
{
_float *result = &s1; /* s1 may not be in a register! */
SINGLE *result = &s1; /* s1 may not be in a register! */
if (s2 == (_float) 0) {
if (s2 == (SINGLE) 0) {
return s1;
}
s2 = ngf4(s2);

10
mach/proto/fp/sbf8.c
View file

@ -11,15 +11,13 @@
#include "FP_types.h"
extern _double adf8(), ngf8();
_double
DOUBLE
sbf8(s2,s1)
_double s1,s2;
DOUBLE s1,s2;
{
_double *result = &s1; /* s1 may not be in a register! */
DOUBLE *result = &s1; /* s1 may not be in a register! */
if (s2.__double[0] == 0 && s2.__double[1] == 0) {
if (s2.d[0] == 0 && s2.d[1] == 0) {
return s1;
}
s2 = ngf8(s2);

3
mach/proto/fp/sft_ext.c
View file

@ -13,6 +13,7 @@
#include "FP_types.h"
void
sft_ext(e1,e2)
EXTEND *e1,*e2;
{
@ -34,5 +35,5 @@ EXTEND *e1,*e2;
s = e2;
s->exp += diff;
b64_sft(&(s->m1), diff);
b64_sft(&(s->mantissa), diff);
}

5
mach/proto/fp/shifter.c
View file

@ -5,8 +5,9 @@
/* $Header$ */
# include "adder.h"
# include "FP_types.h"
void
b64_sft(e1,n)
B64 *e1;
int n;
@ -53,6 +54,7 @@ int n;
}
}
void
b64_lsft(e1)
B64 *e1;
{
@ -62,6 +64,7 @@ B64 *e1;
e1->l_32 <<= 1;
}
void
b64_rsft(e1)
B64 *e1;
{

5
mach/proto/fp/sub_ext.c
View file

@ -11,6 +11,7 @@
#include "FP_types.h"
void
sub_ext(e1,e2)
EXTEND *e1,*e2;
{
@ -25,8 +26,8 @@ EXTEND *e1,*e2;
sft_ext(e1, e2);
if (e1->sign != e2->sign) {
/* e1 - e2 = e1 + (-e2) */
if (b64_add(&e1->m1,&e2->m1)) { /* addition carry */
b64_rsft(&e1->m1); /* shift mantissa one bit RIGHT */
if (b64_add(&e1->mantissa,&e2->mantissa)) { /* addition carry */
b64_rsft(&e1->mantissa); /* shift mantissa one bit RIGHT */
e1->m1 |= 0x80000000L; /* set max bit */
e1->exp++; /* increase the exponent */
}

5
mach/proto/fp/zrf4.c
View file

@ -9,8 +9,11 @@
return a zero float (ZRF 4)
*/
#include "FP_types.h"
void
zrf4(l)
long *l;
SINGLE *l;
{
*l = 0L;
}

7
mach/proto/fp/zrf8.c
View file

@ -11,10 +11,11 @@
#include "FP_types.h"
void
zrf8(z)
_double *z;
DOUBLE *z;
{
z->__double[0] = 0L;
z->__double[1] = 0L;
z->d[0] = 0L;
z->d[1] = 0L;
}

1
mach/proto/fp/zrf_ext.c
View file

@ -11,6 +11,7 @@
#include "FP_types.h"
void
zrf_ext(e)
EXTEND *e;
{