#include "as.h"
static int atof_vax_sizeof PARAMS ((int));
static int next_bits PARAMS ((int));
static void make_invalid_floating_point_number PARAMS ((LITTLENUM_TYPE *));
static int what_kind_of_float PARAMS ((int, int *, long *));
static char *atof_vax PARAMS ((char *, int, LITTLENUM_TYPE *));
#define MAX_PRECISION (8)
#define H_PRECISION (8)
#define G_PRECISION (4)
#define D_PRECISION (4)
#define F_PRECISION (2)
#define GUARD (2)
int flonum_gen2vax PARAMS ((int format_letter, FLONUM_TYPE * f,
LITTLENUM_TYPE * words));
static int
atof_vax_sizeof (letter)
int letter;
{
int return_value;
switch (letter)
{
case 'f':
case 'F':
return_value = 4;
break;
case 'd':
case 'D':
case 'g':
case 'G':
return_value = 8;
break;
case 'h':
case 'H':
return_value = 16;
break;
default:
return_value = 0;
break;
}
return (return_value);
}
static const long mask[] =
{
0x00000000,
0x00000001,
0x00000003,
0x00000007,
0x0000000f,
0x0000001f,
0x0000003f,
0x0000007f,
0x000000ff,
0x000001ff,
0x000003ff,
0x000007ff,
0x00000fff,
0x00001fff,
0x00003fff,
0x00007fff,
0x0000ffff,
0x0001ffff,
0x0003ffff,
0x0007ffff,
0x000fffff,
0x001fffff,
0x003fffff,
0x007fffff,
0x00ffffff,
0x01ffffff,
0x03ffffff,
0x07ffffff,
0x0fffffff,
0x1fffffff,
0x3fffffff,
0x7fffffff,
0xffffffff
};
static int bits_left_in_littlenum;
static LITTLENUM_TYPE *littlenum_pointer;
static LITTLENUM_TYPE *littlenum_end;
static int
next_bits (number_of_bits)
int number_of_bits;
{
int return_value;
if (littlenum_pointer < littlenum_end)
return 0;
if (number_of_bits >= bits_left_in_littlenum)
{
return_value = mask[bits_left_in_littlenum] & *littlenum_pointer;
number_of_bits -= bits_left_in_littlenum;
return_value <<= number_of_bits;
bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
littlenum_pointer--;
if (littlenum_pointer >= littlenum_end)
return_value |= ((*littlenum_pointer) >> (bits_left_in_littlenum)) & mask[number_of_bits];
}
else
{
bits_left_in_littlenum -= number_of_bits;
return_value = mask[number_of_bits] & ((*littlenum_pointer) >> bits_left_in_littlenum);
}
return (return_value);
}
static void
make_invalid_floating_point_number (words)
LITTLENUM_TYPE *words;
{
*words = 0x8000;
}
static int
what_kind_of_float (letter, precisionP, exponent_bitsP)
int letter;
int *precisionP;
long *exponent_bitsP;
{
int retval;
retval = 0;
switch (letter)
{
case 'f':
*precisionP = F_PRECISION;
*exponent_bitsP = 8;
break;
case 'd':
*precisionP = D_PRECISION;
*exponent_bitsP = 8;
break;
case 'g':
*precisionP = G_PRECISION;
*exponent_bitsP = 11;
break;
case 'h':
*precisionP = H_PRECISION;
*exponent_bitsP = 15;
break;
default:
retval = 69;
break;
}
return (retval);
}
static char *
atof_vax (str, what_kind, words)
char *str;
int what_kind;
LITTLENUM_TYPE *words;
{
FLONUM_TYPE f;
LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];
char *return_value;
int precision;
long exponent_bits;
return_value = str;
f.low = bits + MAX_PRECISION;
f.high = NULL;
f.leader = NULL;
f.exponent = 0;
f.sign = '\0';
if (what_kind_of_float (what_kind, &precision, &exponent_bits))
{
return_value = NULL;
make_invalid_floating_point_number (words);
}
if (return_value)
{
memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION);
f.high = f.low + precision - 1 + GUARD;
if (atof_generic (&return_value, ".", "eE", &f))
{
make_invalid_floating_point_number (words);
return_value = NULL;
}
else
{
if (flonum_gen2vax (what_kind, &f, words))
{
return_value = NULL;
}
}
}
return (return_value);
}
int
flonum_gen2vax (format_letter, f, words)
int format_letter;
FLONUM_TYPE *f;
LITTLENUM_TYPE *words;
{
LITTLENUM_TYPE *lp;
int precision;
long exponent_bits;
int return_value;
return_value = what_kind_of_float (format_letter, &precision, &exponent_bits);
if (return_value != 0)
{
make_invalid_floating_point_number (words);
}
else
{
if (f->low > f->leader)
{
memset (words, '\0', sizeof (LITTLENUM_TYPE) * precision);
}
else
{
long exponent_1;
long exponent_2;
long exponent_3;
long exponent_4;
int exponent_skippage;
LITTLENUM_TYPE word1;
if (f->sign != '-' && f->sign != '+')
{
make_invalid_floating_point_number (words);
return return_value;
}
#ifdef NEVER
{
LITTLENUM_TYPE *ltp;
for (ltp = f->leader + 1;
ltp <= f->low + precision;
ltp++)
{
*ltp = 0;
}
}
#endif
bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
littlenum_pointer = f->leader;
littlenum_end = f->low;
for (exponent_skippage = 0;
!next_bits (1);
exponent_skippage++);;
exponent_1 = f->exponent + f->leader + 1 - f->low;
exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
exponent_3 = exponent_2 - exponent_skippage;
exponent_4 = exponent_3 + (1 << (exponent_bits - 1));
if (exponent_4 & ~mask[exponent_bits])
{
make_invalid_floating_point_number (words);
}
else
{
lp = words;
word1 = (((exponent_4 & mask[exponent_bits]) << (15 - exponent_bits))
| ((f->sign == '+') ? 0 : 0x8000)
| next_bits (15 - exponent_bits));
*lp++ = word1;
for (; lp < words + precision; lp++)
{
*lp = next_bits (LITTLENUM_NUMBER_OF_BITS);
}
if (next_bits (1))
{
unsigned long carry;
for (carry = 1, lp--;
carry && (lp >= words);
lp--)
{
carry = *lp + carry;
*lp = carry;
carry >>= LITTLENUM_NUMBER_OF_BITS;
}
if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)))
{
make_invalid_floating_point_number (words);
}
}
}
}
}
return (return_value);
}
#define MAXIMUM_NUMBER_OF_LITTLENUMS (8)
char *
md_atof (what_statement_type, literalP, sizeP)
int what_statement_type;
char *literalP;
int *sizeP;
{
LITTLENUM_TYPE words[MAXIMUM_NUMBER_OF_LITTLENUMS];
register char kind_of_float;
register int number_of_chars;
register LITTLENUM_TYPE *littlenumP;
switch (what_statement_type)
{
case 'F':
case 'f':
kind_of_float = 'f';
break;
case 'D':
case 'd':
kind_of_float = 'd';
break;
case 'g':
kind_of_float = 'g';
break;
case 'h':
kind_of_float = 'h';
break;
default:
kind_of_float = 0;
break;
};
if (kind_of_float)
{
register LITTLENUM_TYPE *limit;
input_line_pointer = atof_vax (input_line_pointer,
kind_of_float,
words);
number_of_chars = atof_vax_sizeof (kind_of_float);
know (number_of_chars <= MAXIMUM_NUMBER_OF_LITTLENUMS * sizeof (LITTLENUM_TYPE));
limit = words + (number_of_chars / sizeof (LITTLENUM_TYPE));
for (littlenumP = words; littlenumP < limit; littlenumP++)
{
md_number_to_chars (literalP, *littlenumP, sizeof (LITTLENUM_TYPE));
literalP += sizeof (LITTLENUM_TYPE);
};
}
else
{
number_of_chars = 0;
};
*sizeP = number_of_chars;
return kind_of_float ? NULL : _("Bad call to md_atof()");
}