![[BACK]](/icons/back.gif){kind=icon}
Return to fcnvxf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / spmath|
Return to fcnvxf.c CVS log | Up to [local] / sys / arch / hppa / spmath |
1.1 nbrk 1: /* $OpenBSD: fcnvxf.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: /* @(#)fcnvxf.c: Revision: 2.7.88.1 Date: 93/12/07 15:06:16 */
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 fixed-point to single floating-point format
24: */
25: int
26: sgl_to_sgl_fcnvxf(srcptr, null, dstptr, status)
27: int *srcptr, *null;
28: sgl_floating_point *dstptr;
29: unsigned int *status;
30: {
31: register int src, dst_exponent;
32: register unsigned int result = 0;
33:
34: src = *srcptr;
35: /*
36: * set sign bit of result and get magnitude of source
37: */
38: if (src < 0) {
39: Sgl_setone_sign(result);
40: Int_negate(src);
41: }
42: else {
43: Sgl_setzero_sign(result);
44: /* Check for zero */
45: if (src == 0) {
46: Sgl_setzero(result);
47: *dstptr = result;
48: return(NOEXCEPTION);
49: }
50: }
51: /*
52: * Generate exponent and normalized mantissa
53: */
54: dst_exponent = 16; /* initialize for normalization */
55: /*
56: * Check word for most significant bit set. Returns
57: * a value in dst_exponent indicating the bit position,
58: * between -1 and 30.
59: */
60: Find_ms_one_bit(src,dst_exponent);
61: /* left justify source, with msb at bit position 1 */
62: if (dst_exponent >= 0) src <<= dst_exponent;
63: else src = 1 << 30;
64: Sgl_set_mantissa(result, src >> (SGL_EXP_LENGTH-1));
65: Sgl_set_exponent(result, 30+SGL_BIAS - dst_exponent);
66:
67: /* check for inexact */
68: if (Int_isinexact_to_sgl(src)) {
69: switch (Rounding_mode()) {
70: case ROUNDPLUS:
71: if (Sgl_iszero_sign(result))
72: Sgl_increment(result);
73: break;
74: case ROUNDMINUS:
75: if (Sgl_isone_sign(result))
76: Sgl_increment(result);
77: break;
78: case ROUNDNEAREST:
79: Sgl_roundnearest_from_int(src,result);
80: }
81: if (Is_inexacttrap_enabled()) {
82: *dstptr = result;
83: return(INEXACTEXCEPTION);
84: }
85: else Set_inexactflag();
86: }
87: *dstptr = result;
88: return(NOEXCEPTION);
89: }
90:
91: /*
92: * Single Fixed-point to Double Floating-point
93: */
94: int
95: sgl_to_dbl_fcnvxf(srcptr, null, dstptr, status)
96: int *srcptr, *null;
97: dbl_floating_point *dstptr;
98: unsigned int *status;
99: {
100: register int src, dst_exponent;
101: register unsigned int resultp1 = 0, resultp2 = 0;
102:
103: src = *srcptr;
104: /*
105: * set sign bit of result and get magnitude of source
106: */
107: if (src < 0) {
108: Dbl_setone_sign(resultp1);
109: Int_negate(src);
110: }
111: else {
112: Dbl_setzero_sign(resultp1);
113: /* Check for zero */
114: if (src == 0) {
115: Dbl_setzero(resultp1,resultp2);
116: Dbl_copytoptr(resultp1,resultp2,dstptr);
117: return(NOEXCEPTION);
118: }
119: }
120: /*
121: * Generate exponent and normalized mantissa
122: */
123: dst_exponent = 16; /* initialize for normalization */
124: /*
125: * Check word for most significant bit set. Returns
126: * a value in dst_exponent indicating the bit position,
127: * between -1 and 30.
128: */
129: Find_ms_one_bit(src,dst_exponent);
130: /* left justify source, with msb at bit position 1 */
131: if (dst_exponent >= 0) src <<= dst_exponent;
132: else src = 1 << 30;
133: Dbl_set_mantissap1(resultp1, (src >> (DBL_EXP_LENGTH - 1)));
134: Dbl_set_mantissap2(resultp2, (src << (33-DBL_EXP_LENGTH)));
135: Dbl_set_exponent(resultp1, (30+DBL_BIAS) - dst_exponent);
136: Dbl_copytoptr(resultp1,resultp2,dstptr);
137: return(NOEXCEPTION);
138: }
139:
140: /*
141: * Double Fixed-point to Single Floating-point
142: */
143: int
144: dbl_to_sgl_fcnvxf(srcptr, null, dstptr, status)
145: dbl_integer *srcptr, *null;
146: sgl_floating_point *dstptr;
147: unsigned int *status;
148: {
149: int dst_exponent, srcp1;
150: unsigned int result = 0, srcp2;
151:
152: Dint_copyfromptr(srcptr,srcp1,srcp2);
153: /*
154: * set sign bit of result and get magnitude of source
155: */
156: if (srcp1 < 0) {
157: Sgl_setone_sign(result);
158: Dint_negate(srcp1,srcp2);
159: }
160: else {
161: Sgl_setzero_sign(result);
162: /* Check for zero */
163: if (srcp1 == 0 && srcp2 == 0) {
164: Sgl_setzero(result);
165: *dstptr = result;
166: return(NOEXCEPTION);
167: }
168: }
169: /*
170: * Generate exponent and normalized mantissa
171: */
172: dst_exponent = 16; /* initialize for normalization */
173: if (srcp1 == 0) {
174: /*
175: * Check word for most significant bit set. Returns
176: * a value in dst_exponent indicating the bit position,
177: * between -1 and 30.
178: */
179: Find_ms_one_bit(srcp2,dst_exponent);
180: /* left justify source, with msb at bit position 1 */
181: if (dst_exponent >= 0) {
182: srcp1 = srcp2 << dst_exponent;
183: srcp2 = 0;
184: }
185: else {
186: srcp1 = srcp2 >> 1;
187: srcp2 <<= 31;
188: }
189: /*
190: * since msb set is in second word, need to
191: * adjust bit position count
192: */
193: dst_exponent += 32;
194: }
195: else {
196: /*
197: * Check word for most significant bit set. Returns
198: * a value in dst_exponent indicating the bit position,
199: * between -1 and 30.
200: *
201: */
202: Find_ms_one_bit(srcp1,dst_exponent);
203: /* left justify source, with msb at bit position 1 */
204: if (dst_exponent > 0) {
205: Variable_shift_double(srcp1,srcp2,(32-dst_exponent),
206: srcp1);
207: srcp2 <<= dst_exponent;
208: }
209: /*
210: * If dst_exponent = 0, we don't need to shift anything.
211: * If dst_exponent = -1, src = - 2**63 so we won't need to
212: * shift srcp2.
213: */
214: else srcp1 >>= -(dst_exponent);
215: }
216: Sgl_set_mantissa(result, (srcp1 >> (SGL_EXP_LENGTH - 1)));
217: Sgl_set_exponent(result, (62+SGL_BIAS) - dst_exponent);
218:
219: /* check for inexact */
220: if (Dint_isinexact_to_sgl(srcp1,srcp2)) {
221: switch (Rounding_mode()) {
222: case ROUNDPLUS:
223: if (Sgl_iszero_sign(result))
224: Sgl_increment(result);
225: break;
226: case ROUNDMINUS:
227: if (Sgl_isone_sign(result))
228: Sgl_increment(result);
229: break;
230: case ROUNDNEAREST:
231: Sgl_roundnearest_from_dint(srcp1,srcp2,result);
232: }
233: if (Is_inexacttrap_enabled()) {
234: *dstptr = result;
235: return(INEXACTEXCEPTION);
236: }
237: else Set_inexactflag();
238: }
239: *dstptr = result;
240: return(NOEXCEPTION);
241: }
242:
243: /*
244: * Double Fixed-point to Double Floating-point
245: */
246: int
247: dbl_to_dbl_fcnvxf(srcptr, null, dstptr, status)
248: dbl_integer *srcptr, *null;
249: dbl_floating_point *dstptr;
250: unsigned int *status;
251: {
252: register int srcp1, dst_exponent;
253: register unsigned int srcp2, resultp1 = 0, resultp2 = 0;
254:
255: Dint_copyfromptr(srcptr,srcp1,srcp2);
256: /*
257: * set sign bit of result and get magnitude of source
258: */
259: if (srcp1 < 0) {
260: Dbl_setone_sign(resultp1);
261: Dint_negate(srcp1,srcp2);
262: }
263: else {
264: Dbl_setzero_sign(resultp1);
265: /* Check for zero */
266: if (srcp1 == 0 && srcp2 ==0) {
267: Dbl_setzero(resultp1,resultp2);
268: Dbl_copytoptr(resultp1,resultp2,dstptr);
269: return(NOEXCEPTION);
270: }
271: }
272: /*
273: * Generate exponent and normalized mantissa
274: */
275: dst_exponent = 16; /* initialize for normalization */
276: if (srcp1 == 0) {
277: /*
278: * Check word for most significant bit set. Returns
279: * a value in dst_exponent indicating the bit position,
280: * between -1 and 30.
281: */
282: Find_ms_one_bit(srcp2,dst_exponent);
283: /* left justify source, with msb at bit position 1 */
284: if (dst_exponent >= 0) {
285: srcp1 = srcp2 << dst_exponent;
286: srcp2 = 0;
287: }
288: else {
289: srcp1 = srcp2 >> 1;
290: srcp2 <<= 31;
291: }
292: /*
293: * since msb set is in second word, need to
294: * adjust bit position count
295: */
296: dst_exponent += 32;
297: }
298: else {
299: /*
300: * Check word for most significant bit set. Returns
301: * a value in dst_exponent indicating the bit position,
302: * between -1 and 30.
303: */
304: Find_ms_one_bit(srcp1,dst_exponent);
305: /* left justify source, with msb at bit position 1 */
306: if (dst_exponent > 0) {
307: Variable_shift_double(srcp1,srcp2,(32-dst_exponent),
308: srcp1);
309: srcp2 <<= dst_exponent;
310: }
311: /*
312: * If dst_exponent = 0, we don't need to shift anything.
313: * If dst_exponent = -1, src = - 2**63 so we won't need to
314: * shift srcp2.
315: */
316: else srcp1 >>= -(dst_exponent);
317: }
318: Dbl_set_mantissap1(resultp1, srcp1 >> (DBL_EXP_LENGTH-1));
319: Shiftdouble(srcp1,srcp2,DBL_EXP_LENGTH-1,resultp2);
320: Dbl_set_exponent(resultp1, (62+DBL_BIAS) - dst_exponent);
321:
322: /* check for inexact */
323: if (Dint_isinexact_to_dbl(srcp2)) {
324: switch (Rounding_mode()) {
325: case ROUNDPLUS:
326: if (Dbl_iszero_sign(resultp1)) {
327: Dbl_increment(resultp1,resultp2);
328: }
329: break;
330: case ROUNDMINUS:
331: if (Dbl_isone_sign(resultp1)) {
332: Dbl_increment(resultp1,resultp2);
333: }
334: break;
335: case ROUNDNEAREST:
336: Dbl_roundnearest_from_dint(srcp2,resultp1,
337: resultp2);
338: }
339: if (Is_inexacttrap_enabled()) {
340: Dbl_copytoptr(resultp1,resultp2,dstptr);
341: return(INEXACTEXCEPTION);
342: }
343: else Set_inexactflag();
344: }
345: Dbl_copytoptr(resultp1,resultp2,dstptr);
346: return(NOEXCEPTION);
347: }