![[BACK]](/icons/back.gif){kind=icon}
Return to fcnvfx.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / spmath|
Return to fcnvfx.c CVS log | Up to [local] / sys / arch / hppa / spmath |
1.1 nbrk 1: /* $OpenBSD: fcnvfx.c,v 1.7 2003/04/10 17:27:58 mickey Exp $ */
2: /*
3: (c) Copyright 1986 HEWLETT-PACKARD COMPANY
4: To anyone who acknowledges that this file is provided "AS IS"
5: without any express or implied warranty:
6: permission to use, copy, modify, and distribute this file
7: for any purpose is hereby granted without fee, provided that
8: the above copyright notice and this notice appears in all
9: copies, and that the name of Hewlett-Packard Company not be
10: used in advertising or publicity pertaining to distribution
11: of the software without specific, written prior permission.
12: Hewlett-Packard Company makes no representations about the
13: suitability of this software for any purpose.
14: */
15: /* @(#)fcnvfx.c: Revision: 2.8.88.2 Date: 93/12/08 13:27:29 */
16:
17: #include "float.h"
18: #include "sgl_float.h"
19: #include "dbl_float.h"
20: #include "cnv_float.h"
21:
22: /*
23: * Single Floating-point to Single Fixed-point
24: */
25: /*ARGSUSED*/
26: int
27: sgl_to_sgl_fcnvfx(srcptr, null, dstptr, status)
28: sgl_floating_point *srcptr, *null;
29: int *dstptr;
30: unsigned int *status;
31: {
32: register unsigned int src, temp;
33: register int src_exponent, result;
34: register int inexact = FALSE;
35:
36: src = *srcptr;
37: src_exponent = Sgl_exponent(src) - SGL_BIAS;
38:
39: /*
40: * Test for overflow
41: */
42: if (src_exponent > SGL_FX_MAX_EXP) {
43: /* check for MININT */
44: if ((src_exponent > SGL_FX_MAX_EXP + 1) ||
45: Sgl_isnotzero_mantissa(src) || Sgl_iszero_sign(src)) {
46: if( Sgl_isnan(src) )
47: /*
48: * On NaN go unimplemented.
49: */
50: return(UNIMPLEMENTEDEXCEPTION);
51: else {
52: if (Sgl_iszero_sign(src)) result = 0x7fffffff;
53: else result = 0x80000000;
54:
55: if (Is_overflowtrap_enabled()) {
56: if (Is_inexacttrap_enabled())
57: return(OVERFLOWEXCEPTION|INEXACTEXCEPTION);
58: else Set_inexactflag();
59: return(OVERFLOWEXCEPTION);
60: }
61: Set_overflowflag();
62: *dstptr = result;
63: if (Is_inexacttrap_enabled() )
64: return(INEXACTEXCEPTION);
65: else Set_inexactflag();
66: return(NOEXCEPTION);
67: }
68: }
69: }
70: /*
71: * Generate result
72: */
73: if (src_exponent >= 0) {
74: temp = src;
75: Sgl_clear_signexponent_set_hidden(temp);
76: Int_from_sgl_mantissa(temp,src_exponent);
77: if (Sgl_isone_sign(src)) result = -Sgl_all(temp);
78: else result = Sgl_all(temp);
79:
80: /* check for inexact */
81: if (Sgl_isinexact_to_fix(src,src_exponent)) {
82: inexact = TRUE;
83: /* round result */
84: switch (Rounding_mode()) {
85: case ROUNDPLUS:
86: if (Sgl_iszero_sign(src)) result++;
87: break;
88: case ROUNDMINUS:
89: if (Sgl_isone_sign(src)) result--;
90: break;
91: case ROUNDNEAREST:
92: if (Sgl_isone_roundbit(src,src_exponent)) {
93: if (Sgl_isone_stickybit(src,src_exponent)
94: || (Sgl_isone_lowmantissa(temp))) {
95: if (Sgl_iszero_sign(src)) result++;
96: else result--;
97: }
98: }
99: }
100: }
101: }
102: else {
103: result = 0;
104:
105: /* check for inexact */
106: if (Sgl_isnotzero_exponentmantissa(src)) {
107: inexact = TRUE;
108: /* round result */
109: switch (Rounding_mode()) {
110: case ROUNDPLUS:
111: if (Sgl_iszero_sign(src)) result++;
112: break;
113: case ROUNDMINUS:
114: if (Sgl_isone_sign(src)) result--;
115: break;
116: case ROUNDNEAREST:
117: if (src_exponent == -1)
118: if (Sgl_isnotzero_mantissa(src)) {
119: if (Sgl_iszero_sign(src)) result++;
120: else result--;
121: }
122: }
123: }
124: }
125: *dstptr = result;
126: if (inexact) {
127: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
128: else Set_inexactflag();
129: }
130: return(NOEXCEPTION);
131: }
132:
133: /*
134: * Single Floating-point to Double Fixed-point
135: */
136: /*ARGSUSED*/
137: int
138: sgl_to_dbl_fcnvfx(srcptr, null, dstptr, status)
139: sgl_floating_point *srcptr, *null;
140: dbl_integer *dstptr;
141: unsigned int *status;
142: {
143: register int src_exponent, resultp1;
144: register unsigned int src, temp, resultp2;
145: register int inexact = FALSE;
146:
147: src = *srcptr;
148: src_exponent = Sgl_exponent(src) - SGL_BIAS;
149:
150: /*
151: * Test for overflow
152: */
153: if (src_exponent > DBL_FX_MAX_EXP) {
154: /* check for MININT */
155: if ((src_exponent > DBL_FX_MAX_EXP + 1) ||
156: Sgl_isnotzero_mantissa(src) || Sgl_iszero_sign(src)) {
157: if( Sgl_isnan(src) )
158: /*
159: * On NaN go unimplemented.
160: */
161: return(UNIMPLEMENTEDEXCEPTION);
162: else {
163: if (Sgl_iszero_sign(src)) {
164: resultp1 = 0x7fffffff;
165: resultp2 = 0xffffffff;
166: }
167: else {
168: resultp1 = 0x80000000;
169: resultp2 = 0;
170: }
171: if (Is_overflowtrap_enabled()) {
172: if (Is_inexacttrap_enabled())
173: return(OVERFLOWEXCEPTION|INEXACTEXCEPTION);
174: else Set_inexactflag();
175: return(OVERFLOWEXCEPTION);
176: }
177: Set_overflowflag();
178: Dint_copytoptr(resultp1,resultp2,dstptr);
179: if (Is_inexacttrap_enabled() )
180: return(INEXACTEXCEPTION);
181: else Set_inexactflag();
182: return(NOEXCEPTION);
183: }
184: }
185: Dint_set_minint(resultp1,resultp2);
186: Dint_copytoptr(resultp1,resultp2,dstptr);
187: return(NOEXCEPTION);
188: }
189: /*
190: * Generate result
191: */
192: if (src_exponent >= 0) {
193: temp = src;
194: Sgl_clear_signexponent_set_hidden(temp);
195: Dint_from_sgl_mantissa(temp,src_exponent,resultp1,resultp2);
196: if (Sgl_isone_sign(src)) {
197: Dint_setone_sign(resultp1,resultp2);
198: }
199:
200: /* check for inexact */
201: if (Sgl_isinexact_to_fix(src,src_exponent)) {
202: inexact = TRUE;
203: /* round result */
204: switch (Rounding_mode()) {
205: case ROUNDPLUS:
206: if (Sgl_iszero_sign(src)) {
207: Dint_increment(resultp1,resultp2);
208: }
209: break;
210: case ROUNDMINUS:
211: if (Sgl_isone_sign(src)) {
212: Dint_decrement(resultp1,resultp2);
213: }
214: break;
215: case ROUNDNEAREST:
216: if (Sgl_isone_roundbit(src,src_exponent))
217: if (Sgl_isone_stickybit(src,src_exponent) ||
218: (Dint_isone_lowp2(resultp2))) {
219: if (Sgl_iszero_sign(src)) {
220: Dint_increment(resultp1,resultp2);
221: }
222: else {
223: Dint_decrement(resultp1,resultp2);
224: }
225: }
226: }
227: }
228: }
229: else {
230: Dint_setzero(resultp1,resultp2);
231:
232: /* check for inexact */
233: if (Sgl_isnotzero_exponentmantissa(src)) {
234: inexact = TRUE;
235: /* round result */
236: switch (Rounding_mode()) {
237: case ROUNDPLUS:
238: if (Sgl_iszero_sign(src)) {
239: Dint_increment(resultp1,resultp2);
240: }
241: break;
242: case ROUNDMINUS:
243: if (Sgl_isone_sign(src)) {
244: Dint_decrement(resultp1,resultp2);
245: }
246: break;
247: case ROUNDNEAREST:
248: if (src_exponent == -1)
249: if (Sgl_isnotzero_mantissa(src)) {
250: if (Sgl_iszero_sign(src)) {
251: Dint_increment(resultp1,resultp2);
252: }
253: else {
254: Dint_decrement(resultp1,resultp2);
255: }
256: }
257: }
258: }
259: }
260: Dint_copytoptr(resultp1,resultp2,dstptr);
261: if (inexact) {
262: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
263: else Set_inexactflag();
264: }
265: return(NOEXCEPTION);
266: }
267:
268: /*
269: * Double Floating-point to Single Fixed-point
270: */
271: /*ARGSUSED*/
272: int
273: dbl_to_sgl_fcnvfx(srcptr, null, dstptr, status)
274: dbl_floating_point *srcptr, *null;
275: int *dstptr;
276: unsigned int *status;
277: {
278: register unsigned int srcp1,srcp2, tempp1,tempp2;
279: register int src_exponent, result;
280: register int inexact = FALSE;
281:
282: Dbl_copyfromptr(srcptr,srcp1,srcp2);
283: src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
284:
285: /*
286: * Test for overflow
287: */
288: if (src_exponent > SGL_FX_MAX_EXP) {
289: /* check for MININT */
290: if (Dbl_isoverflow_to_int(src_exponent,srcp1,srcp2)) {
291: if( Dbl_isnan(srcp1,srcp2) )
292: /*
293: * On NaN go unimplemented.
294: */
295: return(UNIMPLEMENTEDEXCEPTION);
296: else {
297: if (Dbl_iszero_sign(srcp1)) result = 0x7fffffff;
298: else result = 0x80000000;
299:
300: if (Is_overflowtrap_enabled()) {
301: if (Is_inexacttrap_enabled())
302: return(OVERFLOWEXCEPTION|INEXACTEXCEPTION);
303: else Set_inexactflag();
304: return(OVERFLOWEXCEPTION);
305: }
306: Set_overflowflag();
307: *dstptr = result;
308: if (Is_inexacttrap_enabled() )
309: return(INEXACTEXCEPTION);
310: else Set_inexactflag();
311: return(NOEXCEPTION);
312: }
313: }
314: }
315: /*
316: * Generate result
317: */
318: if (src_exponent >= 0) {
319: tempp1 = srcp1;
320: tempp2 = srcp2;
321: Dbl_clear_signexponent_set_hidden(tempp1);
322: Int_from_dbl_mantissa(tempp1,tempp2,src_exponent);
323: if (Dbl_isone_sign(srcp1) && (src_exponent <= SGL_FX_MAX_EXP))
324: result = -Dbl_allp1(tempp1);
325: else result = Dbl_allp1(tempp1);
326:
327: /* check for inexact */
328: if (Dbl_isinexact_to_fix(srcp1,srcp2,src_exponent)) {
329: inexact = TRUE;
330: /* round result */
331: switch (Rounding_mode()) {
332: case ROUNDPLUS:
333: if (Dbl_iszero_sign(srcp1))
334: result++;
335: break;
336: case ROUNDMINUS:
337: if (Dbl_isone_sign(srcp1)) result--;
338: break;
339: case ROUNDNEAREST:
340: if (Dbl_isone_roundbit(srcp1,srcp2,src_exponent))
341: if (Dbl_isone_stickybit(srcp1,srcp2,src_exponent) ||
342: (Dbl_isone_lowmantissap1(tempp1))) {
343: if (Dbl_iszero_sign(srcp1)) result++;
344: else result--;
345: }
346: }
347: /* check for overflow */
348: if ((Dbl_iszero_sign(srcp1) && result < 0) ||
349: (Dbl_isone_sign(srcp1) && result > 0)) {
350:
351: if (Dbl_iszero_sign(srcp1))
352: result = 0x7fffffff;
353: else
354: result = 0x80000000;
355:
356: if (Is_overflowtrap_enabled()) {
357: if (Is_inexacttrap_enabled())
358: return(OVERFLOWEXCEPTION|INEXACTEXCEPTION);
359: else Set_inexactflag();
360: return(OVERFLOWEXCEPTION);
361: }
362: Set_overflowflag();
363: *dstptr = result;
364: if (Is_inexacttrap_enabled() )
365: return(INEXACTEXCEPTION);
366: else Set_inexactflag();
367: return(NOEXCEPTION);
368: }
369: }
370: }
371: else {
372: result = 0;
373:
374: /* check for inexact */
375: if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
376: inexact = TRUE;
377: /* round result */
378: switch (Rounding_mode()) {
379: case ROUNDPLUS:
380: if (Dbl_iszero_sign(srcp1)) result++;
381: break;
382: case ROUNDMINUS:
383: if (Dbl_isone_sign(srcp1)) result--;
384: break;
385: case ROUNDNEAREST:
386: if (src_exponent == -1)
387: if (Dbl_isnotzero_mantissa(srcp1,srcp2)) {
388: if (Dbl_iszero_sign(srcp1)) result++;
389: else result--;
390: }
391: }
392: }
393: }
394: *dstptr = result;
395: if (inexact) {
396: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
397: else Set_inexactflag();
398: }
399: return(NOEXCEPTION);
400: }
401:
402: /*
403: * Double Floating-point to Double Fixed-point
404: */
405: /*ARGSUSED*/
406: int
407: dbl_to_dbl_fcnvfx(srcptr, null, dstptr, status)
408: dbl_floating_point *srcptr, *null;
409: dbl_integer *dstptr;
410: unsigned int *status;
411: {
412: register int src_exponent, resultp1;
413: register unsigned int srcp1, srcp2, tempp1, tempp2, resultp2;
414: register int inexact = FALSE;
415:
416: Dbl_copyfromptr(srcptr,srcp1,srcp2);
417: src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
418:
419: /*
420: * Test for overflow
421: */
422: if (src_exponent > DBL_FX_MAX_EXP) {
423: /* check for MININT */
424: if ((src_exponent > DBL_FX_MAX_EXP + 1) ||
425: Dbl_isnotzero_mantissa(srcp1,srcp2) || Dbl_iszero_sign(srcp1)) {
426: if( Dbl_isnan(srcp1,srcp2) )
427: /*
428: * On NaN go unimplemented.
429: */
430: return(UNIMPLEMENTEDEXCEPTION);
431: else {
432: if (Dbl_iszero_sign(srcp1)) {
433: resultp1 = 0x7fffffff;
434: resultp2 = 0xffffffff;
435: }
436: else {
437: resultp1 = 0x80000000;
438: resultp2 = 0;
439: }
440: if (Is_overflowtrap_enabled()) {
441: if (Is_inexacttrap_enabled())
442: return(OVERFLOWEXCEPTION|INEXACTEXCEPTION);
443: else Set_inexactflag();
444: return(OVERFLOWEXCEPTION);
445: }
446: Set_overflowflag();
447: Dint_copytoptr(resultp1,resultp2,dstptr);
448: if (Is_inexacttrap_enabled() )
449: return(INEXACTEXCEPTION);
450: else Set_inexactflag();
451: return(NOEXCEPTION);
452: }
453: }
454: }
455:
456: /*
457: * Generate result
458: */
459: if (src_exponent >= 0) {
460: tempp1 = srcp1;
461: tempp2 = srcp2;
462: Dbl_clear_signexponent_set_hidden(tempp1);
463: Dint_from_dbl_mantissa(tempp1,tempp2,src_exponent,
464: resultp1, resultp2);
465: if (Dbl_isone_sign(srcp1)) {
466: Dint_setone_sign(resultp1,resultp2);
467: }
468:
469: /* check for inexact */
470: if (Dbl_isinexact_to_fix(srcp1,srcp2,src_exponent)) {
471: inexact = TRUE;
472: /* round result */
473: switch (Rounding_mode()) {
474: case ROUNDPLUS:
475: if (Dbl_iszero_sign(srcp1)) {
476: Dint_increment(resultp1,resultp2);
477: }
478: break;
479: case ROUNDMINUS:
480: if (Dbl_isone_sign(srcp1)) {
481: Dint_decrement(resultp1,resultp2);
482: }
483: break;
484: case ROUNDNEAREST:
485: if (Dbl_isone_roundbit(srcp1,srcp2,src_exponent))
486: if (Dbl_isone_stickybit(srcp1,srcp2,src_exponent) ||
487: (Dint_isone_lowp2(resultp2))) {
488: if (Dbl_iszero_sign(srcp1)) {
489: Dint_increment(resultp1,resultp2);
490: }
491: else {
492: Dint_decrement(resultp1,resultp2);
493: }
494: }
495: }
496: }
497: }
498: else {
499: Dint_setzero(resultp1,resultp2);
500:
501: /* check for inexact */
502: if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
503: inexact = TRUE;
504: /* round result */
505: switch (Rounding_mode()) {
506: case ROUNDPLUS:
507: if (Dbl_iszero_sign(srcp1)) {
508: Dint_increment(resultp1,resultp2);
509: }
510: break;
511: case ROUNDMINUS:
512: if (Dbl_isone_sign(srcp1)) {
513: Dint_decrement(resultp1,resultp2);
514: }
515: break;
516: case ROUNDNEAREST:
517: if (src_exponent == -1)
518: if (Dbl_isnotzero_mantissa(srcp1,srcp2)) {
519: if (Dbl_iszero_sign(srcp1)) {
520: Dint_increment(resultp1,resultp2);
521: }
522: else {
523: Dint_decrement(resultp1,resultp2);
524: }
525: }
526: }
527: }
528: }
529: Dint_copytoptr(resultp1,resultp2,dstptr);
530: if (inexact) {
531: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
532: else Set_inexactflag();
533: }
534: return(NOEXCEPTION);
535: }