![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bignum.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / as.tahoe|
Return to bignum.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / as.tahoe |
1.1 root 1: /*
2: * Copyright (c) 1982 Regents of the University of California
3: */
4: #ifndef lint
5: static char sccsid[] = "@(#)bignum1.c 4.4 6/30/83";
6: #endif not lint
7:
8: #include <errno.h>
9: #include <stdio.h>
10: #include "as.h"
11:
12: Bignum Znumber;
13:
14: /*
15: * Construct an integer.
16: */
17:
18: Bignum as_atoi(ccp, radix, ovfp)
19: reg char *ccp; /* character cp */
20: int radix;
21: Ovf *ovfp;
22: {
23: reg chptr bcp;
24: chptr tcp;
25: reg int i;
26: int val;
27: Bignum n_n;
28: Bignum t_n;
29: int sign;
30: Ovf ovf;
31:
32: ovf = 0;
33: sign = 0;
34: for (; *ccp; ccp++){
35: switch(*ccp){
36: case '0':
37: case '+': continue;
38: case '-': sign ^= 1;
39: continue;
40: }
41: break;
42: }
43:
44: n_n = Znumber;
45: t_n = Znumber;
46: bcp = CH_FIELD(n_n); (void)numclear(bcp);
47: tcp = CH_FIELD(t_n); (void)numclear(tcp);
48: for (; *ccp; ccp++){
49: switch(*ccp){
50: case '8': case '9':
51: if (radix < 10)
52: goto done;
53: /*FALLTHROUGH*/
54: case '0': case '1': case '2': case '3': case '4':
55: case '5': case '6': case '7':
56: val = *ccp - '0';
57: break;
58: case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
59: if (radix < 16)
60: goto done;
61: val = *ccp - 'A' + 10;
62: break;
63: case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
64: if (radix < 16)
65: goto done;
66: val = *ccp - 'a' + 10;
67: break;
68: default:
69: goto done;
70: }
71: switch(radix){
72: case 8:
73: ovf |= numshift(3, bcp, bcp);
74: break;
75: case 16:
76: ovf |= numshift(4, bcp, bcp);
77: break;
78: case 10:
79: ovf |= numshift(1, tcp, bcp);
80: ovf |= numshift(3, bcp, bcp);
81: ovf |= numaddv(bcp, tcp, bcp);
82: break;
83: }
84: ovf |= numaddd(bcp, bcp, val);
85: }
86: done: ;
87: ovf |= posovf(bcp);
88: if (sign){
89: if (ovf & OVF_MAXINT) {
90: ovf &= ~(OVF_MAXINT | OVF_POSOVF);
91: } else {
92: ovf |= numnegate(bcp, bcp);
93: }
94: }
95: /*
96: * find the highest set unit of the number
97: */
98: val = sign ? -1 : 0;
99: for (i = 0; i < CH_N; i++){
100: if (bcp[i] == val)
101: break;
102: }
103: {
104: static u_char tagtab[4][8] = {
105: { TYPB,
106: TYPW,
107: TYPL, TYPL,
108: TYPQ, TYPQ, TYPQ, TYPQ },
109: { TYPW,
110: TYPL,
111: TYPQ, TYPQ },
112: { 0 },
113: { TYPL,
114: TYPQ }
115: };
116: /*
117: * i indexes to the null chunk; make it point to the
118: * last non null chunk
119: */
120: i -= 1;
121: if (i < 0)
122: i = 0;
123: n_n.num_tag = tagtab[HOC][i];
124: assert(n_n.num_tag != 0, " Botch width computation");
125: }
126: *ovfp = ovf;
127: return(n_n);
128: }
129:
130: Bignum as_atof (numbuf, radix)
131: char *numbuf;
132: {
133: double atof ();
134: Bignum number;
135:
136: number = Znumber;
137: number.num_tag = radix;
138: switch (radix)
139: {
140: case TYPD:
141: number.num_num.numFd_float.Fd_value = atof (numbuf);
142: break;
143: case TYPF:
144: number.num_num.numFf_float.Ff_value = atof (numbuf);
145: break;
146: }
147:
148: return (number);
149: }
150:
151: Ovf posovf(src)
152: reg chptr src;
153: {
154: reg int i;
155: Ovf overflow = 0;
156:
157: if (src[HOC] & SIGNBIT)
158: overflow = OVF_POSOVF;
159: if (src[HOC] == SIGNBIT){
160: for (i = HOC - 1; i >= 0; --i){
161: if (src[i] != 0)
162: return(overflow);
163: }
164: overflow |= OVF_MAXINT;
165: }
166: return(overflow);
167: }
168:
169: /*
170: * check if the number is clear
171: */
172: int isclear(dst)
173: reg chptr dst;
174: {
175: return(!isunequal(dst, CH_FIELD(Znumber)));
176: }
177:
178: int isunequal(src1, src2)
179: reg chptr src1, src2;
180: {
181: reg int i;
182:
183: i = CH_N;
184: do{
185: if (*src1++ != *src2++)
186: return(i);
187: }while(--i);
188: return(0);
189: }
190:
191: Ovf numclear(dst)
192: reg chptr dst;
193: {
194: reg int i;
195: i = CH_N;
196: do{
197: *dst++ = 0;
198: }while(--i);
199: return(0);
200: }
201:
202: Ovf numshift(n, dst, src)
203: int n;
204: reg chptr dst, src;
205: {
206: reg int i;
207: reg u_int carryi, carryo;
208: reg u_int mask;
209: reg u_int value;
210:
211: i = CH_N;
212: if (n == 0){
213: do{
214: *dst++ = *src++;
215: } while(--i);
216: return(0);
217: }
218:
219: carryi = 0;
220: mask = ONES(n);
221:
222: if (n > 0){
223: do{
224: value = *src++;
225: carryo = (value >> (CH_BITS - n)) & mask;
226: value <<= n;
227: value &= ~mask;
228: *dst++ = value | carryi;
229: carryi = carryo;
230: } while (--i);
231: return(carryi ? OVF_LSHIFT : 0);
232: } else {
233: n = -n;
234: src += CH_N;
235: dst += CH_N;
236: do{
237: value = *--src;
238: carryo = value & mask;
239: value >>= n;
240: value &= ONES(CH_BITS - n);
241: *--dst = value | carryi;
242: carryi = carryo << (CH_BITS - n);
243: } while (--i);
244: return(carryi ? OVF_LSHIFT : 0);
245: }
246: }
247:
248: Ovf numaddd(dst, src1, val)
249: chptr dst, src1;
250: int val;
251: {
252: static Bignum work;
253:
254: work.num_uchar[3] = val;
255: return (numaddv(dst, src1, CH_FIELD(work)));
256: }
257:
258: Ovf numaddv(dst, src1, src2)
259: reg chptr dst, src1, src2;
260: {
261: reg int i;
262: reg int carry;
263: reg u_int A,B,value;
264:
265: carry = 0;
266: i = CH_N;
267: do{
268: A = *src1++;
269: B = *src2++;
270: value = A + B + carry;
271: *dst++ = value;
272: carry = 0;
273: if (value < A || value < B)
274: carry = 1;
275: } while (--i);
276: return(carry ? OVF_ADDV : 0);
277: }
278:
279: Ovf numnegate(dst, src)
280: chptr dst, src;
281: {
282: Ovf ovf;
283:
284: ovf = num1comp(dst, src) ;
285: ovf |= numaddd(dst, dst, 1);
286: return(ovf);
287: }
288:
289: Ovf num1comp(dst, src)
290: reg chptr dst, src;
291: {
292: reg int i;
293: i = CH_N;
294: do{
295: *dst++ = ~ *src++;
296: }while (--i);
297: return(0);
298: }
299:
300: bignumprint(number)
301: Bignum number; /* number presented */
302: {
303: switch (num_type)
304: {
305: case TYPQ:
306: printf ("val[msd] = 0x%x, val[lsd] = 0x%x.",
307: number.num_num.numIq_int.Iq_ulong[1],
308: number.num_num.numIq_int.Iq_ulong[0]);
309: break;
310: case TYPF:
311: printf ("value %20.17f",
312: number.num_num.numFf_float.Ff_value);
313: break;
314: case TYPD:
315: printf ("value %20.17f",
316: number.num_num.numFd_float.Fd_value);
317: break;
318: default:
319: break;
320: }
321: }
322:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.