[deliverable/binutils-gdb.git] / gas / config / atof-vax.c

/* atof_vax.c - turn a Flonum into a VAX floating point number
   Copyright (C) 1987, 1992, 93, 95, 1997, 1998 Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GAS; see the file COPYING.  If not, write to the Free
   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

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

/* Precision in LittleNums. */
#define MAX_PRECISION (8)
#define H_PRECISION (8)
#define G_PRECISION (4)
#define D_PRECISION (4)
#define F_PRECISION (2)

/* Length in LittleNums of guard bits. */
#define GUARD (2)

int flonum_gen2vax PARAMS ((int format_letter, FLONUM_TYPE * f,
			    LITTLENUM_TYPE * words));

/* Number of chars in flonum type 'letter'. */
static int
atof_vax_sizeof (letter)
     int letter;
{
  int return_value;

  /*
   * Permitting uppercase letters is probably a bad idea.
   * Please use only lower-cased letters in case the upper-cased
   * ones become unsupported!
   */
  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);
}				/* atof_vax_sizeof */

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
};
\f

/* Shared between flonum_gen2vax and next_bits */
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;		/* Floating Reserved Operand Code */
}
\f
static int			/* 0 means letter is OK. */
what_kind_of_float (letter, precisionP, exponent_bitsP)
     int letter;		/* In: lowercase please. What kind of float? */
     int *precisionP;		/* Number of 16-bit words in the float. */
     long *exponent_bitsP;	/* Number of exponent bits. */
{
  int retval;			/* 0: OK. */

  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);
}
\f
/***********************************************************************\
 *									*
 *	Warning: this returns 16-bit LITTLENUMs, because that is	*
 *	what the VAX thinks in. It is up to the caller to figure	*
 *	out any alignment problems and to conspire for the bytes/word	*
 *	to be emitted in the right order. Bigendians beware!		*
 *									*
 \***********************************************************************/

static char *				/* Return pointer past text consumed. */
atof_vax (str, what_kind, words)
     char *str;			/* Text to convert to binary. */
     int what_kind;		/* 'd', 'f', 'g', 'h' */
     LITTLENUM_TYPE *words;	/* Build the binary here. */
{
  FLONUM_TYPE f;
  LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];
  /* Extra bits for zeroed low-order bits. */
  /* The 1st MAX_PRECISION are zeroed, */
  /* the last contain flonum bits. */
  char *return_value;
  int precision;		/* Number of 16-bit words in the format. */
  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;	/* We lost. */
      make_invalid_floating_point_number (words);
    }

  if (return_value)
    {
      memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION);

      /* Use more LittleNums than seems */
      /* necessary: the highest flonum may have */
      /* 15 leading 0 bits, so could be useless. */
      f.high = f.low + precision - 1 + GUARD;

      if (atof_generic (&return_value, ".", "eE", &f))
	{
	  make_invalid_floating_point_number (words);
	  return_value = NULL;	/* we lost */
	}
      else
	{
	  if (flonum_gen2vax (what_kind, &f, words))
	    {
	      return_value = NULL;
	    }
	}
    }
  return (return_value);
}				/* atof_vax() */
\f
/*
 * In: a flonum, a vax floating point format.
 * Out: a vax floating-point bit pattern.
 */

int				/* 0: OK. */
flonum_gen2vax (format_letter, f, words)
     char format_letter;	/* One of 'd' 'f' 'g' 'h'. */
     FLONUM_TYPE *f;
     LITTLENUM_TYPE *words;	/* Deliver answer here. */
{
  LITTLENUM_TYPE *lp;
  int precision;
  long exponent_bits;
  int return_value;		/* 0 == OK. */

  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)
	{
	  /* 0.0e0 seen. */
	  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;

	  /* JF: Deal with new Nan, +Inf and -Inf codes */
	  if (f->sign != '-' && f->sign != '+')
	    {
	      make_invalid_floating_point_number (words);
	      return return_value;
	    }
	  /*
			 * All vaxen floating_point formats (so far) have:
			 * Bit 15 is sign bit.
			 * Bits 14:n are excess-whatever exponent.
			 * Bits n-1:0 (if any) are most significant bits of fraction.
			 * Bits 15:0 of the next word are the next most significant bits.
			 * And so on for each other word.
			 *
			 * All this to be compatible with a KF11?? (Which is still faster
			 * than lots of vaxen I can think of, but it also has higher
			 * maintenance costs ... sigh).
			 *
			 * So we need: number of bits of exponent, number of bits of
			 * mantissa.
			 */

#ifdef NEVER			/******* This zeroing seems redundant - Dean 3may86 **********/
	  /*
			 * No matter how few bits we got back from the atof()
			 * routine, add enough zero littlenums so the rest of the
			 * code won't run out of "significant" bits in the mantissa.
			 */
	  {
	    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;
	  /* Seek (and forget) 1st significant bit */
	  for (exponent_skippage = 0;
	       !next_bits (1);
	       exponent_skippage++);;

	  exponent_1 = f->exponent + f->leader + 1 - f->low;
	  /* Radix LITTLENUM_RADIX, point just higher than f->leader. */
	  exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
	  /* Radix 2. */
	  exponent_3 = exponent_2 - exponent_skippage;
	  /* Forget leading zeros, forget 1st bit. */
	  exponent_4 = exponent_3 + (1 << (exponent_bits - 1));
	  /* Offset exponent. */

	  if (exponent_4 & ~mask[exponent_bits])
	    {
	      /*
				 * Exponent overflow. Lose immediately.
				 */

	      make_invalid_floating_point_number (words);

	      /*
				 * We leave return_value alone: admit we read the
				 * number, but return a floating exception
				 * because we can't encode the number.
				 */
	    }
	  else
	    {
	      lp = words;

	      /* Word 1. Sign, exponent and perhaps high bits. */
	      /* Assume 2's complement integers. */
	      word1 = (((exponent_4 & mask[exponent_bits]) << (15 - exponent_bits))
		       | ((f->sign == '+') ? 0 : 0x8000)
		       | next_bits (15 - exponent_bits));
	      *lp++ = word1;

	      /* The rest of the words are just mantissa bits. */
	      for (; lp < words + precision; lp++)
		{
		  *lp = next_bits (LITTLENUM_NUMBER_OF_BITS);
		}

	      if (next_bits (1))
		{
		  /*
					 * Since the NEXT bit is a 1, round UP the mantissa.
					 * The cunning design of these hidden-1 floats permits
					 * us to let the mantissa overflow into the exponent, and
					 * it 'does the right thing'. However, we lose if the
					 * highest-order bit of the lowest-order word flips.
					 * Is that clear?
					 */

		  unsigned long carry;

		  /*
					  #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
					  Please allow at least 1 more bit in carry than is in a LITTLENUM.
					  We need that extra bit to hold a carry during a LITTLENUM carry
					  propagation. Another extra bit (kept 0) will assure us that we
					  don't get a sticky sign bit after shifting right, and that
					  permits us to propagate the carry without any masking of bits.
					  #endif
					  */
		  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);
		      /*
						 * We leave return_value alone: admit we read the
						 * number, but return a floating exception
						 * because we can't encode the number.
						 */
		    }
		}		/* if (we needed to round up) */
	    }			/* if (exponent overflow) */
	}			/* if (0.0e0) */
    }				/* if (float_type was OK) */
  return (return_value);
}				/* flonum_gen2vax() */


/* JF this used to be in vax.c but this looks like a better place for it */

/*
 *		md_atof()
 *
 * In:	input_line_pointer->the 1st character of a floating-point
 *		number.
 *	1 letter denoting the type of statement that wants a
 *		binary floating point number returned.
 *	Address of where to build floating point literal.
 *		Assumed to be 'big enough'.
 *	Address of where to return size of literal (in chars).
 *
 * Out:	Input_line_pointer->of next char after floating number.
 *	Error message, or 0.
 *	Floating point literal.
 *	Number of chars we used for the literal.
 */

#define MAXIMUM_NUMBER_OF_LITTLENUMS (8)	/* For .hfloats. */

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':			/* .float */
    case 'f':			/* .ffloat */
      kind_of_float = 'f';
      break;

    case 'D':			/* .double */
    case 'd':			/* .dfloat */
      kind_of_float = 'd';
      break;

    case 'g':			/* .gfloat */
      kind_of_float = 'g';
      break;

    case 'h':			/* .hfloat */
      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);
      /*
       * The atof_vax() builds up 16-bit numbers.
       * Since the assembler may not be running on
       * a little-endian machine, be very careful about
       * converting words to chars.
       */
      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 ? 0 : _("Bad call to md_atof()");
}

/* end of atof-vax.c */
Commit	Line	Data
252b5132 RH	1	/* atof_vax.c - turn a Flonum into a VAX floating point number
	2	Copyright (C) 1987, 1992, 93, 95, 1997, 1998 Free Software Foundation, Inc.
	3
	4	This file is part of GAS, the GNU Assembler.
	5
	6	GAS is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2, or (at your option)
	9	any later version.
	10
	11	GAS is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GAS; see the file COPYING. If not, write to the Free
	18	Software Foundation, 59 Temple Place - Suite 330, Boston, MA
	19	02111-1307, USA. */
	20
	21	#include "as.h"
	22
	23	static int atof_vax_sizeof PARAMS ((int));
	24	static int next_bits PARAMS ((int));
	25	static void make_invalid_floating_point_number PARAMS ((LITTLENUM_TYPE *));
	26	static int what_kind_of_float PARAMS ((int, int , long ));
	27	static char atof_vax PARAMS ((char , int, LITTLENUM_TYPE *));
	28
	29	/* Precision in LittleNums. */
	30	#define MAX_PRECISION (8)
	31	#define H_PRECISION (8)
	32	#define G_PRECISION (4)
	33	#define D_PRECISION (4)
	34	#define F_PRECISION (2)
	35
	36	/* Length in LittleNums of guard bits. */
	37	#define GUARD (2)
	38
	39	int flonum_gen2vax PARAMS ((int format_letter, FLONUM_TYPE * f,
	40	LITTLENUM_TYPE * words));
	41
	42	/* Number of chars in flonum type 'letter'. */
	43	static int
	44	atof_vax_sizeof (letter)
	45	int letter;
	46	{
	47	int return_value;
	48
	49	/*
	50	* Permitting uppercase letters is probably a bad idea.
	51	* Please use only lower-cased letters in case the upper-cased
	52	* ones become unsupported!
	53	*/
	54	switch (letter)
	55	{
	56	case 'f':
	57	case 'F':
	58	return_value = 4;
	59	break;
	60
	61	case 'd':
	62	case 'D':
	63	case 'g':
	64	case 'G':
65	return_value = 8;
66	break;
67
68	case 'h':
69	case 'H':
70	return_value = 16;
71	break;
72
73	default:
74	return_value = 0;
75	break;
76	}
77	return (return_value);
78	} /* atof_vax_sizeof */
79
80	static const long mask[] =
81	{
82	0x00000000,
83	0x00000001,
84	0x00000003,
85	0x00000007,
86	0x0000000f,
87	0x0000001f,
88	0x0000003f,
89	0x0000007f,
90	0x000000ff,
91	0x000001ff,
92	0x000003ff,
93	0x000007ff,
94	0x00000fff,
95	0x00001fff,
96	0x00003fff,
97	0x00007fff,
98	0x0000ffff,
99	0x0001ffff,
100	0x0003ffff,
101	0x0007ffff,
102	0x000fffff,
103	0x001fffff,
104	0x003fffff,
105	0x007fffff,
106	0x00ffffff,
107	0x01ffffff,
108	0x03ffffff,
109	0x07ffffff,
110	0x0fffffff,
111	0x1fffffff,
112	0x3fffffff,
113	0x7fffffff,
114	0xffffffff
115	};
116	\f
117
118	/* Shared between flonum_gen2vax and next_bits */
119	static int bits_left_in_littlenum;
120	static LITTLENUM_TYPE *littlenum_pointer;
121	static LITTLENUM_TYPE *littlenum_end;
122
123	static int
124	next_bits (number_of_bits)
125	int number_of_bits;
126	{
127	int return_value;
128
129	if (littlenum_pointer < littlenum_end)
130	return 0;
131	if (number_of_bits >= bits_left_in_littlenum)
132	{
133	return_value = mask[bits_left_in_littlenum] & *littlenum_pointer;
134	number_of_bits -= bits_left_in_littlenum;
135	return_value <<= number_of_bits;
136	bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
137	littlenum_pointer--;
138	if (littlenum_pointer >= littlenum_end)
139	return_value \|= ((*littlenum_pointer) >> (bits_left_in_littlenum)) & mask[number_of_bits];
140	}
141	else
142	{
143	bits_left_in_littlenum -= number_of_bits;
144	return_value = mask[number_of_bits] & ((*littlenum_pointer) >> bits_left_in_littlenum);
145	}
146	return (return_value);
147	}
148
149	static void
150	make_invalid_floating_point_number (words)
151	LITTLENUM_TYPE *words;
152	{
153	words = 0x8000; / Floating Reserved Operand Code */
154	}
155	\f
156	static int /* 0 means letter is OK. */
157	what_kind_of_float (letter, precisionP, exponent_bitsP)
158	int letter; /* In: lowercase please. What kind of float? */
159	int precisionP; / Number of 16-bit words in the float. */
160	long exponent_bitsP; / Number of exponent bits. */
161	{
162	int retval; /* 0: OK. */
163
164	retval = 0;
165	switch (letter)
166	{
167	case 'f':
168	*precisionP = F_PRECISION;
169	*exponent_bitsP = 8;
170	break;
171
172	case 'd':
173	*precisionP = D_PRECISION;
174	*exponent_bitsP = 8;
175	break;
176
177	case 'g':
178	*precisionP = G_PRECISION;
179	*exponent_bitsP = 11;
180	break;
181
182	case 'h':
183	*precisionP = H_PRECISION;
184	*exponent_bitsP = 15;
185	break;
186
187	default:
188	retval = 69;
189	break;
190	}
191	return (retval);
192	}
193	\f
194	/***********************************************************************\
195	* *
196	* Warning: this returns 16-bit LITTLENUMs, because that is *
197	* what the VAX thinks in. It is up to the caller to figure *
198	* out any alignment problems and to conspire for the bytes/word *
199	* to be emitted in the right order. Bigendians beware! *
200	* *
201	\***********************************************************************/
202
203	static char * /* Return pointer past text consumed. */
204	atof_vax (str, what_kind, words)
205	char str; / Text to convert to binary. */
206	int what_kind; /* 'd', 'f', 'g', 'h' */
207	LITTLENUM_TYPE words; / Build the binary here. */
208	{
209	FLONUM_TYPE f;
210	LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];
211	/* Extra bits for zeroed low-order bits. */
212	/* The 1st MAX_PRECISION are zeroed, */
213	/* the last contain flonum bits. */
214	char *return_value;
215	int precision; /* Number of 16-bit words in the format. */
216	long exponent_bits;
217
218	return_value = str;
219	f.low = bits + MAX_PRECISION;
220	f.high = NULL;
221	f.leader = NULL;
222	f.exponent = 0;
223	f.sign = '\0';
224
225	if (what_kind_of_float (what_kind, &precision, &exponent_bits))
226	{
227	return_value = NULL; /* We lost. */
228	make_invalid_floating_point_number (words);
229	}
230
231	if (return_value)
232	{
233	memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION);
234
235	/* Use more LittleNums than seems */
236	/* necessary: the highest flonum may have */
237	/* 15 leading 0 bits, so could be useless. */
238	f.high = f.low + precision - 1 + GUARD;
239
240	if (atof_generic (&return_value, ".", "eE", &f))
241	{
242	make_invalid_floating_point_number (words);
243	return_value = NULL; /* we lost */
244	}
245	else
246	{
247	if (flonum_gen2vax (what_kind, &f, words))
248	{
249	return_value = NULL;
250	}
251	}
252	}
253	return (return_value);
254	} /* atof_vax() */
255	\f
256	/*
257	* In: a flonum, a vax floating point format.
258	* Out: a vax floating-point bit pattern.
259	*/
260
261	int /* 0: OK. */
262	flonum_gen2vax (format_letter, f, words)
263	char format_letter; /* One of 'd' 'f' 'g' 'h'. */
264	FLONUM_TYPE *f;
265	LITTLENUM_TYPE words; / Deliver answer here. */
266	{
267	LITTLENUM_TYPE *lp;
268	int precision;
269	long exponent_bits;
270	int return_value; /* 0 == OK. */
271
272	return_value = what_kind_of_float (format_letter, &precision, &exponent_bits);
273
274	if (return_value != 0)
275	{
276	make_invalid_floating_point_number (words);
277	}
278	else
279	{
280	if (f->low > f->leader)
281	{
282	/* 0.0e0 seen. */
283	memset (words, '\0', sizeof (LITTLENUM_TYPE) * precision);
284	}
285	else
286	{
287	long exponent_1;
288	long exponent_2;
289	long exponent_3;
290	long exponent_4;
291	int exponent_skippage;
292	LITTLENUM_TYPE word1;
293
294	/* JF: Deal with new Nan, +Inf and -Inf codes */
295	if (f->sign != '-' && f->sign != '+')
296	{
297	make_invalid_floating_point_number (words);
298	return return_value;
299	}
300	/*
301	* All vaxen floating_point formats (so far) have:
302	* Bit 15 is sign bit.
303	* Bits 14:n are excess-whatever exponent.
304	* Bits n-1:0 (if any) are most significant bits of fraction.
305	* Bits 15:0 of the next word are the next most significant bits.
306	* And so on for each other word.
307	*
308	* All this to be compatible with a KF11?? (Which is still faster
309	* than lots of vaxen I can think of, but it also has higher
310	* maintenance costs ... sigh).
311	*
312	* So we need: number of bits of exponent, number of bits of
313	* mantissa.
314	*/
315
316	#ifdef NEVER /***** This zeroing seems redundant - Dean 3may86 ********/
317	/*
318	* No matter how few bits we got back from the atof()
319	* routine, add enough zero littlenums so the rest of the
320	* code won't run out of "significant" bits in the mantissa.
321	*/
322	{
323	LITTLENUM_TYPE *ltp;
324	for (ltp = f->leader + 1;
325	ltp <= f->low + precision;
326	ltp++)
327	{
328	*ltp = 0;
329	}
330	}
331	#endif
332
333	bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
334	littlenum_pointer = f->leader;
335	littlenum_end = f->low;
336	/* Seek (and forget) 1st significant bit */
337	for (exponent_skippage = 0;
338	!next_bits (1);
339	exponent_skippage++);;
340
341	exponent_1 = f->exponent + f->leader + 1 - f->low;
342	/* Radix LITTLENUM_RADIX, point just higher than f->leader. */
343	exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
344	/* Radix 2. */
345	exponent_3 = exponent_2 - exponent_skippage;
346	/* Forget leading zeros, forget 1st bit. */
347	exponent_4 = exponent_3 + (1 << (exponent_bits - 1));
348	/* Offset exponent. */
349
350	if (exponent_4 & ~mask[exponent_bits])
351	{
352	/*
353	* Exponent overflow. Lose immediately.
354	*/
355
356	make_invalid_floating_point_number (words);
357
358	/*
359	* We leave return_value alone: admit we read the
360	* number, but return a floating exception
361	* because we can't encode the number.
362	*/
363	}
364	else
365	{
366	lp = words;
367
368	/* Word 1. Sign, exponent and perhaps high bits. */
369	/* Assume 2's complement integers. */
370	word1 = (((exponent_4 & mask[exponent_bits]) << (15 - exponent_bits))
371	\| ((f->sign == '+') ? 0 : 0x8000)
372	\| next_bits (15 - exponent_bits));
373	*lp++ = word1;
374
375	/* The rest of the words are just mantissa bits. */
376	for (; lp < words + precision; lp++)
377	{
378	*lp = next_bits (LITTLENUM_NUMBER_OF_BITS);
379	}
380
381	if (next_bits (1))
382	{
383	/*
384	* Since the NEXT bit is a 1, round UP the mantissa.
385	* The cunning design of these hidden-1 floats permits
386	* us to let the mantissa overflow into the exponent, and
387	* it 'does the right thing'. However, we lose if the
388	* highest-order bit of the lowest-order word flips.
389	* Is that clear?
390	*/
391
392	unsigned long carry;
393
394	/*
395	#if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
396	Please allow at least 1 more bit in carry than is in a LITTLENUM.
397	We need that extra bit to hold a carry during a LITTLENUM carry
398	propagation. Another extra bit (kept 0) will assure us that we
399	don't get a sticky sign bit after shifting right, and that
400	permits us to propagate the carry without any masking of bits.
401	#endif
402	*/
403	for (carry = 1, lp--;
404	carry && (lp >= words);
405	lp--)
406	{
407	carry = *lp + carry;
408	*lp = carry;
409	carry >>= LITTLENUM_NUMBER_OF_BITS;
410	}
411
412	if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)))
413	{
414	make_invalid_floating_point_number (words);
415	/*
416	* We leave return_value alone: admit we read the
417	* number, but return a floating exception
418	* because we can't encode the number.
419	*/
420	}
421	} /* if (we needed to round up) */
422	} /* if (exponent overflow) */
423	} /* if (0.0e0) */
424	} /* if (float_type was OK) */
425	return (return_value);
426	} /* flonum_gen2vax() */
427
428
429	/* JF this used to be in vax.c but this looks like a better place for it */
430
431	/*
432	* md_atof()
433	*
434	* In: input_line_pointer->the 1st character of a floating-point
435	* number.
436	* 1 letter denoting the type of statement that wants a
437	* binary floating point number returned.
438	* Address of where to build floating point literal.
439	* Assumed to be 'big enough'.
440	* Address of where to return size of literal (in chars).
441	*
442	* Out: Input_line_pointer->of next char after floating number.
443	* Error message, or 0.
444	* Floating point literal.
445	* Number of chars we used for the literal.
446	*/
447
448	#define MAXIMUM_NUMBER_OF_LITTLENUMS (8) /* For .hfloats. */
449
450	char *
451	md_atof (what_statement_type, literalP, sizeP)
452	int what_statement_type;
453	char *literalP;
454	int *sizeP;
455	{
456	LITTLENUM_TYPE words[MAXIMUM_NUMBER_OF_LITTLENUMS];
457	register char kind_of_float;
458	register int number_of_chars;
459	register LITTLENUM_TYPE *littlenumP;
460
461	switch (what_statement_type)
462	{
463	case 'F': /* .float */
464	case 'f': /* .ffloat */
465	kind_of_float = 'f';
466	break;
467
468	case 'D': /* .double */
469	case 'd': /* .dfloat */
470	kind_of_float = 'd';
471	break;
472
473	case 'g': /* .gfloat */
474	kind_of_float = 'g';
475	break;
476
477	case 'h': /* .hfloat */
478	kind_of_float = 'h';
479	break;
480
481	default:
482	kind_of_float = 0;
483	break;
484	};
485
486	if (kind_of_float)
487	{
488	register LITTLENUM_TYPE *limit;
489
490	input_line_pointer = atof_vax (input_line_pointer,
491	kind_of_float,
492	words);
493	/*
494	* The atof_vax() builds up 16-bit numbers.
495	* Since the assembler may not be running on
496	* a little-endian machine, be very careful about
497	* converting words to chars.
498	*/
499	number_of_chars = atof_vax_sizeof (kind_of_float);
500	know (number_of_chars <= MAXIMUM_NUMBER_OF_LITTLENUMS * sizeof (LITTLENUM_TYPE));
501	limit = words + (number_of_chars / sizeof (LITTLENUM_TYPE));
502	for (littlenumP = words; littlenumP < limit; littlenumP++)
503	{
504	md_number_to_chars (literalP, *littlenumP, sizeof (LITTLENUM_TYPE));
505	literalP += sizeof (LITTLENUM_TYPE);
506	};
507	}
508	else
509	{
510	number_of_chars = 0;
511	};
512
513	*sizeP = number_of_chars;
514	return kind_of_float ? 0 : _("Bad call to md_atof()");
515	}
516
517	/* end of atof-vax.c */