[unix-history] / usr / src / old / as.vax / bignum1.c

/*
 * Copyright (c) 1982 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)bignum1.c	5.1 (Berkeley) %G%";
#endif not lint

#include <errno.h>
#include <stdio.h>
#include "as.h"

/*
 *	Construct a floating point number
 */
Bignum as_atof(numbuf, radix, ovfp)
	char	*numbuf;
	int	radix;
	Ovf	*ovfp;
{
	Bignum	number;
	extern	int	errno;
	double	atof();

	number = Znumber;
	errno = 0;
	switch(radix){
	case TYPF:
	case TYPD:
		number.num_tag = TYPD;
		*ovfp = 0;
		number.num_num.numFd_float.Fd_value = atof(numbuf);
		break;
	case TYPG:
	case TYPH:
		number = bigatof(numbuf, radix);
		break;
	}
	if (errno == ERANGE && passno == 2){
		yywarning("Floating conversion over/underflowed\n");
	}
	return(number);
}

/*
 *	Construct an integer.
 */

Bignum as_atoi(ccp, radix, ovfp)
	reg	char	*ccp;		/* character cp */
		int	radix;
		Ovf	*ovfp;
{
	reg	chptr	bcp;
		chptr	tcp;
	reg	int	i;
		int	val;
		Bignum	n_n;
		Bignum	t_n;
		int	sign;
		Ovf	ovf;

	ovf = 0;
	sign = 0;
	for (; *ccp; ccp++){
		switch(*ccp){
		case '0':
		case '+':	continue;
		case '-':	sign ^= 1;
				continue;
		}
		break;
	}

	n_n = Znumber;
	t_n = Znumber;
	bcp = CH_FIELD(n_n); (void)numclear(bcp);
	tcp = CH_FIELD(t_n); (void)numclear(tcp);
	for (; *ccp; ccp++){
		switch(*ccp){
		case '8': case '9':
			if (radix < 10)
				goto done;
			/*FALLTHROUGH*/
		case '0': case '1': case '2': case '3': case '4':
		case '5': case '6': case '7':
			val = *ccp - '0';
			break;
		case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
			if (radix < 16)
				goto done;
			val = *ccp - 'A' + 10;
			break;
		case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
			if (radix < 16)
				goto done;
			val = *ccp - 'a' + 10;
			break;
		default:
			goto done;
		}
		switch(radix){
		case 8:
			ovf |= numshift(3, bcp, bcp);
			break;
		case 16:
			ovf |= numshift(4, bcp, bcp);
			break;
		case 10:
			ovf |= numshift(1, tcp, bcp);
			ovf |= numshift(3, bcp, bcp);
			ovf |= numaddv(bcp, tcp, bcp);
			break;
		}
		ovf |= numaddd(bcp, bcp, val);
	}
  done: ;
	ovf |= posovf(bcp);
	if (sign){
		if (ovf & OVF_MAXINT) {
			ovf &= ~(OVF_MAXINT | OVF_POSOVF);
		} else {
			ovf |= numnegate(bcp, bcp);
		}
	}
	/*
	 *	find the highest set unit of the number
	 */
	val = sign ? -1 : 0;
	for (i = 0; i < CH_N; i++){
		if (bcp[i] == val)
			break;
	}
	{
		static u_char tagtab[4][16] = {
		{	TYPB,
			TYPW,
			TYPL, TYPL,
			TYPQ, TYPQ, TYPQ, TYPQ,
			TYPO, TYPO, TYPO, TYPO, TYPO, TYPO, TYPO, TYPO},
		{	TYPW,
			TYPL,
			TYPQ, TYPQ,
			TYPO, TYPO, TYPO, TYPO},
		{   0   },
		{	TYPL,
			TYPQ,
			TYPO, TYPO }
		};
		/*
		 *	i indexes to the null chunk; make it point to the
		 *	last non null chunk
		 */
		i -= 1;
		if (i < 0)
			i = 0;
		n_n.num_tag = tagtab[HOC][i];
		assert(n_n.num_tag != 0, "Botch width computation");
	}
	*ovfp = ovf;
	return(n_n);
}

Ovf posovf(src)
	reg	chptr	src;
{
	reg	int	i;
	Ovf	overflow = 0;

	if (src[HOC] & SIGNBIT)
		overflow = OVF_POSOVF;
	if (src[HOC] == SIGNBIT){
		for (i = HOC - 1; i >= 0; --i){
			if (src[i] != 0)
				return(overflow);
		}
		overflow |= OVF_MAXINT;
	}
	return(overflow);
}

/*
 *	check if the number is clear
 */
int isclear(dst)
	reg	chptr	dst;
{
	return(!isunequal(dst, CH_FIELD(Znumber)));
}

int isunequal(src1, src2)
	reg	chptr	src1, src2;
{
	reg	int	i;

	i = CH_N;
	do{
		if (*src1++ != *src2++)
			return(i);
	}while(--i);
	return(0);
}

Ovf numclear(dst)
	reg	chptr	dst;
{
	reg	int	i;
	i = CH_N;
	do{
		*dst++ = 0;
	}while(--i);
	return(0);
}

Ovf numshift(n, dst, src)
		int	n;
	reg	chptr	dst, src;
{
	reg	int	i;
	reg	u_int	carryi, carryo;
	reg	u_int	mask;
	reg	u_int	value;

	i = CH_N;
	if (n == 0){
		do{
			*dst++ = *src++;
		} while(--i);
		return(0);
	}

	carryi = 0;
	mask = ONES(n);

	if (n > 0){
		do{
			value = *src++;
			carryo = (value >> (CH_BITS - n)) & mask; 
			value <<= n;
			value &= ~mask;
			*dst++ = value | carryi;
			carryi = carryo;
		} while (--i);
		return(carryi ? OVF_LSHIFT : 0);
	} else {
		n = -n;
		src += CH_N;
		dst += CH_N;
		do{
			value = *--src;
			carryo = value & mask; 
			value >>= n;
			value &= ONES(CH_BITS - n);
			*--dst = value | carryi;
			carryi = carryo << (CH_BITS - n);
		} while (--i);
		return(carryi ? OVF_LSHIFT : 0);
	}
}

Ovf numaddd(dst, src1, val)
	chptr	dst, src1;
	int	val;
{
	static	Bignum	work;

	work.num_uchar[0] = val;
	return (numaddv(dst, src1, CH_FIELD(work)));
}

Ovf numaddv(dst, src1, src2)
	reg	chptr	dst, src1, src2;
{
	reg	int	i;
	reg	int	carry;
	reg	u_int	A,B,value;

	carry = 0;
	i = CH_N;
	do{
		A = *src1++;
		B = *src2++;
		value = A + B + carry;
		*dst++ = value;
		carry = 0;
		if (value < A || value < B)
			carry = 1;
	} while (--i);
	return(carry ? OVF_ADDV : 0);
}

Ovf numnegate(dst, src)
	chptr	dst, src;
{
	Ovf	ovf;

	ovf = num1comp(dst, src) ;
	ovf |= numaddd(dst, dst, 1);
	return(ovf);
}

Ovf num1comp(dst, src)
	reg	chptr	dst, src;
{
	reg	int	i;
	i = CH_N;
	do{
		*dst++ = ~ *src++;
	}while (--i);
	return(0);
}

/*
 *	Determine if floating point numbers are
 *	capable of being represented as a one byte immediate literal constant
 *	If it is, then stuff the value into *valuep.
 *	argtype is how the instruction will interpret the number.
 */
int slitflt(number, argtype, valuep)
	Bignum	number;		/* number presented */
	int	argtype;	/* what the instruction expects */
	int	*valuep;
{
#define	EXPPREC 3
#define	MANTPREC 3

		int	mask;
	reg	int	i;
		Bignum	unpacked;
		Ovf	ovf;

	*valuep = 0;
	if (!ty_float[argtype])
		return(0);
	unpacked = bignumunpack(number, &ovf);
	assert(ovf == 0, "overflow in unpacking floating #!?");
	if (unpacked.num_sign)
		return(0);
	if (unpacked.num_exponent < 0)
		return(0);
	if (unpacked.num_exponent > ONES(EXPPREC))
		return(0);
	for (i = 0; i < HOC; i++){
		if (CH_FIELD(unpacked)[i])
			return(0);
	}
	if ((CH_FIELD(unpacked)[HOC]) & ONES(CH_BITS - MANTPREC))
		return(0);
	*valuep = (unpacked.num_exponent & ONES(EXPPREC)) << MANTPREC;
	mask = (CH_FIELD(unpacked)[HOC]) >> (CH_BITS - MANTPREC);
	mask &= ONES(MANTPREC);
	*valuep |= mask;
	*valuep &= ONES(MANTPREC + EXPPREC);
	return(1);
}

#ifndef STANDALONE
/*
 *	Output a big number to txtfil
 *	Called only when passno == 2
 *
 *	The conversion specifies the width of the number to be written out.
 *	The width is supplied from either an initialized data directive
 *	(for example .float, .double), or from the operand size
 *	defined by an operator.
 *	If the number is of type quad or octal,
 *	we just write it out; this allows one to specify bit
 *	patterns for floating point numbers.
 *	If the number is one of the floating types and the conversion
 *	is not the same type, then we complain, but do the conversion anyway.
 *	The conversion is strict.
 */
bignumwrite(number, toconv)
	Bignum	number;
	int	toconv;		/* one of TYP[QO FDGH] */
{
	reg	u_int	*bp;

	if (passno != 2)
		return;

	bp = &number.num_uint[0];
	switch(number.num_tag){
	case TYPB:
	case TYPW:
	case TYPL:
	case TYPQ:
	case TYPO:
		number = intconvert(number, toconv);
		break;
	default:
		number = floatconvert(number, toconv);
		break;
	}
	bwrite((char *)bp, ty_nbyte[toconv], txtfil);
}
#endif STANDALONE
Commit	Line	Data
7c2b5c8d	1	/*
bcf1365c DF	2	* Copyright (c) 1982 Regents of the University of California.
	3	* All rights reserved. The Berkeley software License Agreement
	4	* specifies the terms and conditions for redistribution.
7c2b5c8d	5	*/
bcf1365c	6
7c2b5c8d	7	#ifndef lint
bcf1365c	8	static char sccsid[] = "@(#)bignum1.c 5.1 (Berkeley) %G%";
7c2b5c8d RH	9	#endif not lint
	10
	11	#include <errno.h>
	12	#include <stdio.h>
	13	#include "as.h"
	14
	15	/*
	16	* Construct a floating point number
	17	*/
	18	Bignum as_atof(numbuf, radix, ovfp)
	19	char *numbuf;
	20	int radix;
	21	Ovf *ovfp;
	22	{
	23	Bignum number;
	24	extern int errno;
	25	double atof();
	26
	27	number = Znumber;
	28	errno = 0;
	29	switch(radix){
	30	case TYPF:
	31	case TYPD:
	32	number.num_tag = TYPD;
	33	*ovfp = 0;
	34	number.num_num.numFd_float.Fd_value = atof(numbuf);
	35	break;
	36	case TYPG:
	37	case TYPH:
	38	number = bigatof(numbuf, radix);
	39	break;
	40	}
	41	if (errno == ERANGE && passno == 2){
	42	yywarning("Floating conversion over/underflowed\n");
	43	}
	44	return(number);
	45	}
	46
	47	/*
	48	* Construct an integer.
	49	*/
	50
	51	Bignum as_atoi(ccp, radix, ovfp)
	52	reg char ccp; / character cp */
	53	int radix;
	54	Ovf *ovfp;
	55	{
	56	reg chptr bcp;
	57	chptr tcp;
	58	reg int i;
	59	int val;
	60	Bignum n_n;
	61	Bignum t_n;
	62	int sign;
	63	Ovf ovf;
	64
	65	ovf = 0;
	66	sign = 0;
	67	for (; *ccp; ccp++){
	68	switch(*ccp){
	69	case '0':
	70	case '+': continue;
	71	case '-': sign ^= 1;
	72	continue;
73	}
74	break;
75	}
76
77	n_n = Znumber;
78	t_n = Znumber;
79	bcp = CH_FIELD(n_n); (void)numclear(bcp);
80	tcp = CH_FIELD(t_n); (void)numclear(tcp);
81	for (; *ccp; ccp++){
82	switch(*ccp){
83	case '8': case '9':
84	if (radix < 10)
85	goto done;
86	/FALLTHROUGH/
87	case '0': case '1': case '2': case '3': case '4':
88	case '5': case '6': case '7':
89	val = *ccp - '0';
90	break;
91	case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
92	if (radix < 16)
93	goto done;
94	val = *ccp - 'A' + 10;
95	break;
96	case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
97	if (radix < 16)
98	goto done;
99	val = *ccp - 'a' + 10;
100	break;
101	default:
102	goto done;
103	}
104	switch(radix){
105	case 8:
106	ovf \|= numshift(3, bcp, bcp);
107	break;
108	case 16:
109	ovf \|= numshift(4, bcp, bcp);
110	break;
111	case 10:
112	ovf \|= numshift(1, tcp, bcp);
113	ovf \|= numshift(3, bcp, bcp);
114	ovf \|= numaddv(bcp, tcp, bcp);
115	break;
116	}
117	ovf \|= numaddd(bcp, bcp, val);
118	}
119	done: ;
120	ovf \|= posovf(bcp);
121	if (sign){
122	if (ovf & OVF_MAXINT) {
123	ovf &= ~(OVF_MAXINT \| OVF_POSOVF);
124	} else {
125	ovf \|= numnegate(bcp, bcp);
126	}
127	}
128	/*
129	* find the highest set unit of the number
130	*/
131	val = sign ? -1 : 0;
132	for (i = 0; i < CH_N; i++){
133	if (bcp[i] == val)
134	break;
135	}
136	{
137	static u_char tagtab[4][16] = {
138	{ TYPB,
139	TYPW,
140	TYPL, TYPL,
141	TYPQ, TYPQ, TYPQ, TYPQ,
142	TYPO, TYPO, TYPO, TYPO, TYPO, TYPO, TYPO, TYPO},
143	{ TYPW,
144	TYPL,
145	TYPQ, TYPQ,
146	TYPO, TYPO, TYPO, TYPO},
147	{ 0 },
148	{ TYPL,
149	TYPQ,
150	TYPO, TYPO }
151	};
152	/*
153	* i indexes to the null chunk; make it point to the
154	* last non null chunk
155	*/
156	i -= 1;
157	if (i < 0)
158	i = 0;
159	n_n.num_tag = tagtab[HOC][i];
160	assert(n_n.num_tag != 0, "Botch width computation");
161	}
162	*ovfp = ovf;
163	return(n_n);
164	}
165
166	Ovf posovf(src)
167	reg chptr src;
168	{
169	reg int i;
170	Ovf overflow = 0;
171
172	if (src[HOC] & SIGNBIT)
173	overflow = OVF_POSOVF;
174	if (src[HOC] == SIGNBIT){
175	for (i = HOC - 1; i >= 0; --i){
176	if (src[i] != 0)
177	return(overflow);
178	}
179	overflow \|= OVF_MAXINT;
180	}
181	return(overflow);
182	}
183
184	/*
185	* check if the number is clear
186	*/
187	int isclear(dst)
188	reg chptr dst;
189	{
190	return(!isunequal(dst, CH_FIELD(Znumber)));
191	}
192
193	int isunequal(src1, src2)
194	reg chptr src1, src2;
195	{
196	reg int i;
197
198	i = CH_N;
199	do{
200	if (src1++ != src2++)
201	return(i);
202	}while(--i);
203	return(0);
204	}
205
206	Ovf numclear(dst)
207	reg chptr dst;
208	{
209	reg int i;
210	i = CH_N;
211	do{
212	*dst++ = 0;
213	}while(--i);
214	return(0);
215	}
216
217	Ovf numshift(n, dst, src)
218	int n;
219	reg chptr dst, src;
220	{
221	reg int i;
222	reg u_int carryi, carryo;
223	reg u_int mask;
224	reg u_int value;
225
226	i = CH_N;
227	if (n == 0){
228	do{
229	dst++ = src++;
230	} while(--i);
231	return(0);
232	}
233
234	carryi = 0;
235	mask = ONES(n);
236
237	if (n > 0){
238	do{
239	value = *src++;
240	carryo = (value >> (CH_BITS - n)) & mask;
241	value <<= n;
242	value &= ~mask;
243	*dst++ = value \| carryi;
244	carryi = carryo;
245	} while (--i);
246	return(carryi ? OVF_LSHIFT : 0);
247	} else {
248	n = -n;
249	src += CH_N;
250	dst += CH_N;
251	do{
252	value = *--src;
253	carryo = value & mask;
254	value >>= n;
255	value &= ONES(CH_BITS - n);
256	*--dst = value \| carryi;
257	carryi = carryo << (CH_BITS - n);
258	} while (--i);
259	return(carryi ? OVF_LSHIFT : 0);
260	}
261	}
262
263	Ovf numaddd(dst, src1, val)
264	chptr dst, src1;
265	int val;
266	{
267	static Bignum work;
268
269	work.num_uchar[0] = val;
270	return (numaddv(dst, src1, CH_FIELD(work)));
271	}
272
273	Ovf numaddv(dst, src1, src2)
274	reg chptr dst, src1, src2;
275	{
276	reg int i;
277	reg int carry;
278	reg u_int A,B,value;
279
280	carry = 0;
281	i = CH_N;
282	do{
283	A = *src1++;
284	B = *src2++;
285	value = A + B + carry;
286	*dst++ = value;
287	carry = 0;
288	if (value < A \|\| value < B)
289	carry = 1;
290	} while (--i);
291	return(carry ? OVF_ADDV : 0);
292	}
293
294	Ovf numnegate(dst, src)
295	chptr dst, src;
296	{
297	Ovf ovf;
298
299	ovf = num1comp(dst, src) ;
300	ovf \|= numaddd(dst, dst, 1);
301	return(ovf);
302	}
303
304	Ovf num1comp(dst, src)
305	reg chptr dst, src;
306	{
307	reg int i;
308	i = CH_N;
309	do{
310	dst++ = ~ src++;
311	}while (--i);
312	return(0);
313	}
314
315	/*
316	* Determine if floating point numbers are
317	* capable of being represented as a one byte immediate literal constant
318	* If it is, then stuff the value into *valuep.
319	* argtype is how the instruction will interpret the number.
320	*/
321	int slitflt(number, argtype, valuep)
322	Bignum number; /* number presented */
323	int argtype; /* what the instruction expects */
324	int *valuep;
325	{
326	#define EXPPREC 3
327	#define MANTPREC 3
328
329	int mask;
330	reg int i;
331	Bignum unpacked;
332	Ovf ovf;
333
334	*valuep = 0;
335	if (!ty_float[argtype])
336	return(0);
337	unpacked = bignumunpack(number, &ovf);
338	assert(ovf == 0, "overflow in unpacking floating #!?");
339	if (unpacked.num_sign)
340	return(0);
341	if (unpacked.num_exponent < 0)
342	return(0);
343	if (unpacked.num_exponent > ONES(EXPPREC))
344	return(0);
345	for (i = 0; i < HOC; i++){
346	if (CH_FIELD(unpacked)[i])
347	return(0);
348	}
349	if ((CH_FIELD(unpacked)[HOC]) & ONES(CH_BITS - MANTPREC))
350	return(0);
351	*valuep = (unpacked.num_exponent & ONES(EXPPREC)) << MANTPREC;
352	mask = (CH_FIELD(unpacked)[HOC]) >> (CH_BITS - MANTPREC);
353	mask &= ONES(MANTPREC);
354	*valuep \|= mask;
355	*valuep &= ONES(MANTPREC + EXPPREC);
356	return(1);
357	}
358
359	#ifndef STANDALONE
360	/*
361	* Output a big number to txtfil
362	* Called only when passno == 2
363	*
364	* The conversion specifies the width of the number to be written out.
365	* The width is supplied from either an initialized data directive
366	* (for example .float, .double), or from the operand size
367	* defined by an operator.
368	* If the number is of type quad or octal,
369	* we just write it out; this allows one to specify bit
370	* patterns for floating point numbers.
371	* If the number is one of the floating types and the conversion
372	* is not the same type, then we complain, but do the conversion anyway.
373	* The conversion is strict.
374	*/
375	bignumwrite(number, toconv)
376	Bignum number;
377	int toconv; /* one of TYP[QO FDGH] */
378	{
379	reg u_int *bp;
7c2b5c8d RH	380
	381	if (passno != 2)
	382	return;
	383
	384	bp = &number.num_uint[0];
	385	switch(number.num_tag){
	386	case TYPB:
	387	case TYPW:
	388	case TYPL:
	389	case TYPQ:
	390	case TYPO:
	391	number = intconvert(number, toconv);
	392	break;
	393	default:
	394	number = floatconvert(number, toconv);
	395	break;
	396	}
7c2b5c8d	397	bwrite((char *)bp, ty_nbyte[toconv], txtfil);
7c2b5c8d RH	398	}
7c2b5c8d RH	399	#endif STANDALONE