![[BACK]](/icons/back.gif){kind=icon}
Return to fcnvfxt.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / spmath|
Return to fcnvfxt.c CVS log | Up to [local] / sys / arch / hppa / spmath |
1.1 nbrk 1: /* $OpenBSD: fcnvfxt.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: /* @(#)fcnvfxt.c: Revision: 2.8.88.2 Date: 93/12/08 13:27:34 */
16:
17: #include "float.h"
18: #include "sgl_float.h"
19: #include "dbl_float.h"
20: #include "cnv_float.h"
21:
22: /*
23: * Convert single floating-point to single fixed-point format
24: * with truncated result
25: */
26: /*ARGSUSED*/
27: int
28: sgl_to_sgl_fcnvfxt(srcptr, null, dstptr, status)
29: sgl_floating_point *srcptr, *null;
30: int *dstptr;
31: unsigned int *status;
32: {
33: register unsigned int src, temp;
34: register int src_exponent, result;
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: *dstptr = result;
80:
81: /* check for inexact */
82: if (Sgl_isinexact_to_fix(src,src_exponent)) {
83: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
84: else Set_inexactflag();
85: }
86: }
87: else {
88: *dstptr = 0;
89:
90: /* check for inexact */
91: if (Sgl_isnotzero_exponentmantissa(src)) {
92: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
93: else Set_inexactflag();
94: }
95: }
96: return(NOEXCEPTION);
97: }
98:
99: /*
100: * Single Floating-point to Double Fixed-point
101: */
102: /*ARGSUSED*/
103: int
104: sgl_to_dbl_fcnvfxt(srcptr, null, dstptr, status)
105: sgl_floating_point *srcptr, *null;
106: dbl_integer *dstptr;
107: unsigned int *status;
108: {
109: register int src_exponent, resultp1;
110: register unsigned int src, temp, resultp2;
111:
112: src = *srcptr;
113: src_exponent = Sgl_exponent(src) - SGL_BIAS;
114:
115: /*
116: * Test for overflow
117: */
118: if (src_exponent > DBL_FX_MAX_EXP) {
119: /* check for MININT */
120: if ((src_exponent > DBL_FX_MAX_EXP + 1) ||
121: Sgl_isnotzero_mantissa(src) || Sgl_iszero_sign(src)) {
122: if( Sgl_isnan(src) )
123: /*
124: * On NaN go unimplemented.
125: */
126: return(UNIMPLEMENTEDEXCEPTION);
127: else {
128: if (Sgl_iszero_sign(src)) {
129: resultp1 = 0x7fffffff;
130: resultp2 = 0xffffffff;
131: }
132: else {
133: resultp1 = 0x80000000;
134: resultp2 = 0;
135: }
136: if (Is_overflowtrap_enabled()) {
137: if (Is_inexacttrap_enabled())
138: return(OVERFLOWEXCEPTION|INEXACTEXCEPTION);
139: else Set_inexactflag();
140: return(OVERFLOWEXCEPTION);
141: }
142: Set_overflowflag();
143: Dint_copytoptr(resultp1,resultp2,dstptr);
144: if (Is_inexacttrap_enabled() )
145: return(INEXACTEXCEPTION);
146: else Set_inexactflag();
147: return(NOEXCEPTION);
148: }
149: }
150: Dint_set_minint(resultp1,resultp2);
151: Dint_copytoptr(resultp1,resultp2,dstptr);
152: return(NOEXCEPTION);
153: }
154: /*
155: * Generate result
156: */
157: if (src_exponent >= 0) {
158: temp = src;
159: Sgl_clear_signexponent_set_hidden(temp);
160: Dint_from_sgl_mantissa(temp,src_exponent,resultp1,resultp2);
161: if (Sgl_isone_sign(src)) {
162: Dint_setone_sign(resultp1,resultp2);
163: }
164: Dint_copytoptr(resultp1,resultp2,dstptr);
165:
166: /* check for inexact */
167: if (Sgl_isinexact_to_fix(src,src_exponent)) {
168: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
169: else Set_inexactflag();
170: }
171: }
172: else {
173: Dint_setzero(resultp1,resultp2);
174: Dint_copytoptr(resultp1,resultp2,dstptr);
175:
176: /* check for inexact */
177: if (Sgl_isnotzero_exponentmantissa(src)) {
178: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
179: else Set_inexactflag();
180: }
181: }
182: return(NOEXCEPTION);
183: }
184:
185: /*
186: * Double Floating-point to Single Fixed-point
187: */
188: /*ARGSUSED*/
189: int
190: dbl_to_sgl_fcnvfxt(srcptr, null, dstptr, status)
191: dbl_floating_point *srcptr, *null;
192: int *dstptr;
193: unsigned int *status;
194: {
195: register unsigned int srcp1, srcp2, tempp1, tempp2;
196: register int src_exponent, result;
197:
198: Dbl_copyfromptr(srcptr,srcp1,srcp2);
199: src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
200:
201: /*
202: * Test for overflow
203: */
204: if (src_exponent > SGL_FX_MAX_EXP) {
205: /* check for MININT */
206: if (Dbl_isoverflow_to_int(src_exponent,srcp1,srcp2)) {
207: if( Dbl_isnan(srcp1,srcp2) )
208: /*
209: * On NaN go unimplemented.
210: */
211: return(UNIMPLEMENTEDEXCEPTION);
212: else {
213: if (Dbl_iszero_sign(srcp1)) result = 0x7fffffff;
214: else result = 0x80000000;
215:
216: if (Is_overflowtrap_enabled()) {
217: if (Is_inexacttrap_enabled())
218: return(OVERFLOWEXCEPTION|INEXACTEXCEPTION);
219: else Set_inexactflag();
220: return(OVERFLOWEXCEPTION);
221: }
222: Set_overflowflag();
223: *dstptr = result;
224: if (Is_inexacttrap_enabled() )
225: return(INEXACTEXCEPTION);
226: else Set_inexactflag();
227: return(NOEXCEPTION);
228: }
229: }
230: }
231: /*
232: * Generate result
233: */
234: if (src_exponent >= 0) {
235: tempp1 = srcp1;
236: tempp2 = srcp2;
237: Dbl_clear_signexponent_set_hidden(tempp1);
238: Int_from_dbl_mantissa(tempp1,tempp2,src_exponent);
239: if (Dbl_isone_sign(srcp1) && (src_exponent <= SGL_FX_MAX_EXP))
240: result = -Dbl_allp1(tempp1);
241: else result = Dbl_allp1(tempp1);
242: *dstptr = result;
243:
244: /* check for inexact */
245: if (Dbl_isinexact_to_fix(srcp1,srcp2,src_exponent)) {
246: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
247: else Set_inexactflag();
248: }
249: }
250: else {
251: *dstptr = 0;
252:
253: /* check for inexact */
254: if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
255: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
256: else Set_inexactflag();
257: }
258: }
259: return(NOEXCEPTION);
260: }
261:
262: /*
263: * Double Floating-point to Double Fixed-point
264: */
265: /*ARGSUSED*/
266: int
267: dbl_to_dbl_fcnvfxt(srcptr, null, dstptr, status)
268: dbl_floating_point *srcptr, *null;
269: dbl_integer *dstptr;
270: unsigned int *status;
271: {
272: register int src_exponent, resultp1;
273: register unsigned int srcp1, srcp2, tempp1, tempp2, resultp2;
274:
275: Dbl_copyfromptr(srcptr,srcp1,srcp2);
276: src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
277:
278: /*
279: * Test for overflow
280: */
281: if (src_exponent > DBL_FX_MAX_EXP) {
282: /* check for MININT */
283: if ((src_exponent > DBL_FX_MAX_EXP + 1) ||
284: Dbl_isnotzero_mantissa(srcp1,srcp2) || Dbl_iszero_sign(srcp1)) {
285: if( Dbl_isnan(srcp1,srcp2) )
286: /*
287: * On NaN go unimplemented.
288: */
289: return(UNIMPLEMENTEDEXCEPTION);
290: else {
291: if (Dbl_iszero_sign(srcp1)) {
292: resultp1 = 0x7fffffff;
293: resultp2 = 0xffffffff;
294: }
295: else {
296: resultp1 = 0x80000000;
297: resultp2 = 0;
298: }
299: if (Is_overflowtrap_enabled()) {
300: if (Is_inexacttrap_enabled())
301: return(OVERFLOWEXCEPTION|INEXACTEXCEPTION);
302: else Set_inexactflag();
303: return(OVERFLOWEXCEPTION);
304: }
305: Set_overflowflag();
306: Dint_copytoptr(resultp1,resultp2,dstptr);
307: if (Is_inexacttrap_enabled() )
308: return(INEXACTEXCEPTION);
309: else Set_inexactflag();
310: return(NOEXCEPTION);
311: }
312: }
313: }
314: /*
315: * Generate result
316: */
317: if (src_exponent >= 0) {
318: tempp1 = srcp1;
319: tempp2 = srcp2;
320: Dbl_clear_signexponent_set_hidden(tempp1);
321: Dint_from_dbl_mantissa(tempp1,tempp2,src_exponent,
322: resultp1,resultp2);
323: if (Dbl_isone_sign(srcp1)) {
324: Dint_setone_sign(resultp1,resultp2);
325: }
326: Dint_copytoptr(resultp1,resultp2,dstptr);
327:
328: /* check for inexact */
329: if (Dbl_isinexact_to_fix(srcp1,srcp2,src_exponent)) {
330: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
331: else Set_inexactflag();
332: }
333: }
334: else {
335: Dint_setzero(resultp1,resultp2);
336: Dint_copytoptr(resultp1,resultp2,dstptr);
337:
338: /* check for inexact */
339: if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
340: if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
341: else Set_inexactflag();
342: }
343: }
344: return(NOEXCEPTION);
345: }