|
0
|
1 /* Copyright (C) 2007, 2009 Free Software Foundation, Inc.
|
|
|
2
|
|
|
3 This file is part of GCC.
|
|
|
4
|
|
|
5 GCC is free software; you can redistribute it and/or modify it under
|
|
|
6 the terms of the GNU General Public License as published by the Free
|
|
|
7 Software Foundation; either version 3, or (at your option) any later
|
|
|
8 version.
|
|
|
9
|
|
|
10 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
13 for more details.
|
|
|
14
|
|
|
15 Under Section 7 of GPL version 3, you are granted additional
|
|
|
16 permissions described in the GCC Runtime Library Exception, version
|
|
|
17 3.1, as published by the Free Software Foundation.
|
|
|
18
|
|
|
19 You should have received a copy of the GNU General Public License and
|
|
|
20 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
21 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
22 <http://www.gnu.org/licenses/>. */
|
|
|
23
|
|
|
24 #include <ctype.h>
|
|
|
25 #include "bid_internal.h"
|
|
|
26 #include "bid128_2_str.h"
|
|
|
27 #include "bid128_2_str_macros.h"
|
|
|
28
|
|
|
29 #define MAX_FORMAT_DIGITS 16
|
|
|
30 #define DECIMAL_EXPONENT_BIAS 398
|
|
|
31 #define MAX_DECIMAL_EXPONENT 767
|
|
|
32
|
|
|
33 #if DECIMAL_CALL_BY_REFERENCE
|
|
|
34
|
|
|
35 void
|
|
|
36 bid64_to_string (char *ps, UINT64 * px
|
|
|
37 _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
|
|
|
38 UINT64 x;
|
|
|
39 #else
|
|
|
40
|
|
|
41 void
|
|
|
42 bid64_to_string (char *ps, UINT64 x
|
|
|
43 _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
|
|
|
44 #endif
|
|
|
45 // the destination string (pointed to by ps) must be pre-allocated
|
|
|
46 UINT64 sign_x, coefficient_x, D, ER10;
|
|
|
47 int istart, exponent_x, j, digits_x, bin_expon_cx;
|
|
|
48 int_float tempx;
|
|
|
49 UINT32 MiDi[12], *ptr;
|
|
|
50 UINT64 HI_18Dig, LO_18Dig, Tmp;
|
|
|
51 char *c_ptr_start, *c_ptr;
|
|
|
52 int midi_ind, k_lcv, len;
|
|
|
53 unsigned int save_fpsf;
|
|
|
54
|
|
|
55 #if DECIMAL_CALL_BY_REFERENCE
|
|
|
56 x = *px;
|
|
|
57 #endif
|
|
|
58
|
|
|
59 save_fpsf = *pfpsf; // place holder only
|
|
|
60 // unpack arguments, check for NaN or Infinity
|
|
|
61 if (!unpack_BID64 (&sign_x, &exponent_x, &coefficient_x, x)) {
|
|
|
62 // x is Inf. or NaN or 0
|
|
|
63
|
|
|
64 // Inf or NaN?
|
|
|
65 if ((x & 0x7800000000000000ull) == 0x7800000000000000ull) {
|
|
|
66 if ((x & 0x7c00000000000000ull) == 0x7c00000000000000ull) {
|
|
|
67 ps[0] = (sign_x) ? '-' : '+';
|
|
|
68 ps[1] = ((x & MASK_SNAN) == MASK_SNAN)? 'S':'Q';
|
|
|
69 ps[2] = 'N';
|
|
|
70 ps[3] = 'a';
|
|
|
71 ps[4] = 'N';
|
|
|
72 ps[5] = 0;
|
|
|
73 return;
|
|
|
74 }
|
|
|
75 // x is Inf
|
|
|
76 ps[0] = (sign_x) ? '-' : '+';
|
|
|
77 ps[1] = 'I';
|
|
|
78 ps[2] = 'n';
|
|
|
79 ps[3] = 'f';
|
|
|
80 ps[4] = 0;
|
|
|
81 return;
|
|
|
82 }
|
|
|
83 // 0
|
|
|
84 istart = 0;
|
|
|
85 if (sign_x) {
|
|
|
86 ps[istart++] = '-';
|
|
|
87 }
|
|
|
88
|
|
|
89 ps[istart++] = '0';
|
|
|
90 ps[istart++] = 'E';
|
|
|
91
|
|
|
92 exponent_x -= 398;
|
|
|
93 if (exponent_x < 0) {
|
|
|
94 ps[istart++] = '-';
|
|
|
95 exponent_x = -exponent_x;
|
|
|
96 } else
|
|
|
97 ps[istart++] = '+';
|
|
|
98
|
|
|
99 if (exponent_x) {
|
|
|
100 // get decimal digits in coefficient_x
|
|
|
101 tempx.d = (float) exponent_x;
|
|
|
102 bin_expon_cx = ((tempx.i >> 23) & 0xff) - 0x7f;
|
|
|
103 digits_x = estimate_decimal_digits[bin_expon_cx];
|
|
|
104 if ((UINT64)exponent_x >= power10_table_128[digits_x].w[0])
|
|
|
105 digits_x++;
|
|
|
106
|
|
|
107 j = istart + digits_x - 1;
|
|
|
108 istart = j + 1;
|
|
|
109
|
|
|
110 // 2^32/10
|
|
|
111 ER10 = 0x1999999a;
|
|
|
112
|
|
|
113 while (exponent_x > 9) {
|
|
|
114 D = (UINT64) exponent_x *ER10;
|
|
|
115 D >>= 32;
|
|
|
116 exponent_x = exponent_x - (D << 1) - (D << 3);
|
|
|
117
|
|
|
118 ps[j--] = '0' + (char) exponent_x;
|
|
|
119 exponent_x = D;
|
|
|
120 }
|
|
|
121 ps[j] = '0' + (char) exponent_x;
|
|
|
122 } else {
|
|
|
123 ps[istart++] = '0';
|
|
|
124 }
|
|
|
125
|
|
|
126 ps[istart] = 0;
|
|
|
127
|
|
|
128 return;
|
|
|
129 }
|
|
|
130 // convert expon, coeff to ASCII
|
|
|
131 exponent_x -= DECIMAL_EXPONENT_BIAS;
|
|
|
132
|
|
|
133 ER10 = 0x1999999a;
|
|
|
134
|
|
|
135 istart = 0;
|
|
|
136 if (sign_x) {
|
|
|
137 ps[0] = '-';
|
|
|
138 istart = 1;
|
|
|
139 }
|
|
|
140 // if zero or non-canonical, set coefficient to '0'
|
|
|
141 if ((coefficient_x > 9999999999999999ull) || // non-canonical
|
|
|
142 ((coefficient_x == 0)) // significand is zero
|
|
|
143 ) {
|
|
|
144 ps[istart++] = '0';
|
|
|
145 } else {
|
|
|
146 /* ****************************************************
|
|
|
147 This takes a bid coefficient in C1.w[1],C1.w[0]
|
|
|
148 and put the converted character sequence at location
|
|
|
149 starting at &(str[k]). The function returns the number
|
|
|
150 of MiDi returned. Note that the character sequence
|
|
|
151 does not have leading zeros EXCEPT when the input is of
|
|
|
152 zero value. It will then output 1 character '0'
|
|
|
153 The algorithm essentailly tries first to get a sequence of
|
|
|
154 Millenial Digits "MiDi" and then uses table lookup to get the
|
|
|
155 character strings of these MiDis.
|
|
|
156 **************************************************** */
|
|
|
157 /* Algorithm first decompose possibly 34 digits in hi and lo
|
|
|
158 18 digits. (The high can have at most 16 digits). It then
|
|
|
159 uses macro that handle 18 digit portions.
|
|
|
160 The first step is to get hi and lo such that
|
|
|
161 2^(64) C1.w[1] + C1.w[0] = hi * 10^18 + lo, 0 <= lo < 10^18.
|
|
|
162 We use a table lookup method to obtain the hi and lo 18 digits.
|
|
|
163 [C1.w[1],C1.w[0]] = c_8 2^(107) + c_7 2^(101) + ... + c_0 2^(59) + d
|
|
|
164 where 0 <= d < 2^59 and each c_j has 6 bits. Because d fits in
|
|
|
165 18 digits, we set hi = 0, and lo = d to begin with.
|
|
|
166 We then retrieve from a table, for j = 0, 1, ..., 8
|
|
|
167 that gives us A and B where c_j 2^(59+6j) = A * 10^18 + B.
|
|
|
168 hi += A ; lo += B; After each accumulation into lo, we normalize
|
|
|
169 immediately. So at the end, we have the decomposition as we need. */
|
|
|
170
|
|
|
171 Tmp = coefficient_x >> 59;
|
|
|
172 LO_18Dig = (coefficient_x << 5) >> 5;
|
|
|
173 HI_18Dig = 0;
|
|
|
174 k_lcv = 0;
|
|
|
175
|
|
|
176 while (Tmp) {
|
|
|
177 midi_ind = (int) (Tmp & 0x000000000000003FLL);
|
|
|
178 midi_ind <<= 1;
|
|
|
179 Tmp >>= 6;
|
|
|
180 HI_18Dig += mod10_18_tbl[k_lcv][midi_ind++];
|
|
|
181 LO_18Dig += mod10_18_tbl[k_lcv++][midi_ind];
|
|
|
182 __L0_Normalize_10to18 (HI_18Dig, LO_18Dig);
|
|
|
183 }
|
|
|
184
|
|
|
185 ptr = MiDi;
|
|
|
186 __L1_Split_MiDi_6_Lead (LO_18Dig, ptr);
|
|
|
187 len = ptr - MiDi;
|
|
|
188 c_ptr_start = &(ps[istart]);
|
|
|
189 c_ptr = c_ptr_start;
|
|
|
190
|
|
|
191 /* now convert the MiDi into character strings */
|
|
|
192 __L0_MiDi2Str_Lead (MiDi[0], c_ptr);
|
|
|
193 for (k_lcv = 1; k_lcv < len; k_lcv++) {
|
|
|
194 __L0_MiDi2Str (MiDi[k_lcv], c_ptr);
|
|
|
195 }
|
|
|
196 istart = istart + (c_ptr - c_ptr_start);
|
|
|
197 }
|
|
|
198
|
|
|
199 ps[istart++] = 'E';
|
|
|
200
|
|
|
201 if (exponent_x < 0) {
|
|
|
202 ps[istart++] = '-';
|
|
|
203 exponent_x = -exponent_x;
|
|
|
204 } else
|
|
|
205 ps[istart++] = '+';
|
|
|
206
|
|
|
207 if (exponent_x) {
|
|
|
208 // get decimal digits in coefficient_x
|
|
|
209 tempx.d = (float) exponent_x;
|
|
|
210 bin_expon_cx = ((tempx.i >> 23) & 0xff) - 0x7f;
|
|
|
211 digits_x = estimate_decimal_digits[bin_expon_cx];
|
|
|
212 if ((UINT64)exponent_x >= power10_table_128[digits_x].w[0])
|
|
|
213 digits_x++;
|
|
|
214
|
|
|
215 j = istart + digits_x - 1;
|
|
|
216 istart = j + 1;
|
|
|
217
|
|
|
218 // 2^32/10
|
|
|
219 ER10 = 0x1999999a;
|
|
|
220
|
|
|
221 while (exponent_x > 9) {
|
|
|
222 D = (UINT64) exponent_x *ER10;
|
|
|
223 D >>= 32;
|
|
|
224 exponent_x = exponent_x - (D << 1) - (D << 3);
|
|
|
225
|
|
|
226 ps[j--] = '0' + (char) exponent_x;
|
|
|
227 exponent_x = D;
|
|
|
228 }
|
|
|
229 ps[j] = '0' + (char) exponent_x;
|
|
|
230 } else {
|
|
|
231 ps[istart++] = '0';
|
|
|
232 }
|
|
|
233
|
|
|
234 ps[istart] = 0;
|
|
|
235
|
|
|
236 return;
|
|
|
237
|
|
|
238 }
|
|
|
239
|
|
|
240
|
|
|
241 #if DECIMAL_CALL_BY_REFERENCE
|
|
|
242 void
|
|
|
243 bid64_from_string (UINT64 * pres, char *ps
|
|
|
244 _RND_MODE_PARAM _EXC_FLAGS_PARAM
|
|
|
245 _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
|
|
|
246 #else
|
|
|
247 UINT64
|
|
|
248 bid64_from_string (char *ps
|
|
|
249 _RND_MODE_PARAM _EXC_FLAGS_PARAM
|
|
|
250 _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
|
|
|
251 #endif
|
|
|
252 UINT64 sign_x, coefficient_x = 0, rounded = 0, res;
|
|
|
253 int expon_x = 0, sgn_expon, ndigits, add_expon = 0, midpoint =
|
|
|
254 0, rounded_up = 0;
|
|
|
255 int dec_expon_scale = 0, right_radix_leading_zeros = 0, rdx_pt_enc =
|
|
|
256 0;
|
|
|
257 unsigned fpsc;
|
|
|
258 char c;
|
|
|
259 unsigned int save_fpsf;
|
|
|
260
|
|
|
261 #if DECIMAL_CALL_BY_REFERENCE
|
|
|
262 #if !DECIMAL_GLOBAL_ROUNDING
|
|
|
263 _IDEC_round rnd_mode = *prnd_mode;
|
|
|
264 #endif
|
|
|
265 #endif
|
|
|
266
|
|
|
267 save_fpsf = *pfpsf; // place holder only
|
|
|
268 // eliminate leading whitespace
|
|
|
269 while (((*ps == ' ') || (*ps == '\t')) && (*ps))
|
|
|
270 ps++;
|
|
|
271
|
|
|
272 // get first non-whitespace character
|
|
|
273 c = *ps;
|
|
|
274
|
|
|
275 // detect special cases (INF or NaN)
|
|
|
276 if (!c || (c != '.' && c != '-' && c != '+' && (c < '0' || c > '9'))) {
|
|
|
277 // Infinity?
|
|
|
278 if ((tolower_macro (ps[0]) == 'i' && tolower_macro (ps[1]) == 'n' &&
|
|
|
279 tolower_macro (ps[2]) == 'f') && (!ps[3] ||
|
|
|
280 (tolower_macro (ps[3]) == 'i' &&
|
|
|
281 tolower_macro (ps[4]) == 'n' && tolower_macro (ps[5]) == 'i' &&
|
|
|
282 tolower_macro (ps[6]) == 't' && tolower_macro (ps[7]) == 'y' &&
|
|
|
283 !ps[8]))) {
|
|
|
284 res = 0x7800000000000000ull;
|
|
|
285 BID_RETURN (res);
|
|
|
286 }
|
|
|
287 // return sNaN
|
|
|
288 if (tolower_macro (ps[0]) == 's' && tolower_macro (ps[1]) == 'n' &&
|
|
|
289 tolower_macro (ps[2]) == 'a' && tolower_macro (ps[3]) == 'n') {
|
|
|
290 // case insensitive check for snan
|
|
|
291 res = 0x7e00000000000000ull;
|
|
|
292 BID_RETURN (res);
|
|
|
293 } else {
|
|
|
294 // return qNaN
|
|
|
295 res = 0x7c00000000000000ull;
|
|
|
296 BID_RETURN (res);
|
|
|
297 }
|
|
|
298 }
|
|
|
299 // detect +INF or -INF
|
|
|
300 if ((tolower_macro (ps[1]) == 'i' && tolower_macro (ps[2]) == 'n' &&
|
|
|
301 tolower_macro (ps[3]) == 'f') && (!ps[4] ||
|
|
|
302 (tolower_macro (ps[4]) == 'i' && tolower_macro (ps[5]) == 'n' &&
|
|
|
303 tolower_macro (ps[6]) == 'i' && tolower_macro (ps[7]) == 't' &&
|
|
|
304 tolower_macro (ps[8]) == 'y' && !ps[9]))) {
|
|
|
305 if (c == '+')
|
|
|
306 res = 0x7800000000000000ull;
|
|
|
307 else if (c == '-')
|
|
|
308 res = 0xf800000000000000ull;
|
|
|
309 else
|
|
|
310 res = 0x7c00000000000000ull;
|
|
|
311 BID_RETURN (res);
|
|
|
312 }
|
|
|
313 // if +sNaN, +SNaN, -sNaN, or -SNaN
|
|
|
314 if (tolower_macro (ps[1]) == 's' && tolower_macro (ps[2]) == 'n'
|
|
|
315 && tolower_macro (ps[3]) == 'a' && tolower_macro (ps[4]) == 'n') {
|
|
|
316 if (c == '-')
|
|
|
317 res = 0xfe00000000000000ull;
|
|
|
318 else
|
|
|
319 res = 0x7e00000000000000ull;
|
|
|
320 BID_RETURN (res);
|
|
|
321 }
|
|
|
322 // determine sign
|
|
|
323 if (c == '-')
|
|
|
324 sign_x = 0x8000000000000000ull;
|
|
|
325 else
|
|
|
326 sign_x = 0;
|
|
|
327
|
|
|
328 // get next character if leading +/- sign
|
|
|
329 if (c == '-' || c == '+') {
|
|
|
330 ps++;
|
|
|
331 c = *ps;
|
|
|
332 }
|
|
|
333 // if c isn't a decimal point or a decimal digit, return NaN
|
|
|
334 if (c != '.' && (c < '0' || c > '9')) {
|
|
|
335 // return NaN
|
|
|
336 res = 0x7c00000000000000ull | sign_x;
|
|
|
337 BID_RETURN (res);
|
|
|
338 }
|
|
|
339
|
|
|
340 rdx_pt_enc = 0;
|
|
|
341
|
|
|
342 // detect zero (and eliminate/ignore leading zeros)
|
|
|
343 if (*(ps) == '0' || *(ps) == '.') {
|
|
|
344
|
|
|
345 if (*(ps) == '.') {
|
|
|
346 rdx_pt_enc = 1;
|
|
|
347 ps++;
|
|
|
348 }
|
|
|
349 // if all numbers are zeros (with possibly 1 radix point, the number is zero
|
|
|
350 // should catch cases such as: 000.0
|
|
|
351 while (*ps == '0') {
|
|
|
352 ps++;
|
|
|
353 // for numbers such as 0.0000000000000000000000000000000000001001,
|
|
|
354 // we want to count the leading zeros
|
|
|
355 if (rdx_pt_enc) {
|
|
|
356 right_radix_leading_zeros++;
|
|
|
357 }
|
|
|
358 // if this character is a radix point, make sure we haven't already
|
|
|
359 // encountered one
|
|
|
360 if (*(ps) == '.') {
|
|
|
361 if (rdx_pt_enc == 0) {
|
|
|
362 rdx_pt_enc = 1;
|
|
|
363 // if this is the first radix point, and the next character is NULL,
|
|
|
364 // we have a zero
|
|
|
365 if (!*(ps + 1)) {
|
|
|
366 res =
|
|
|
367 ((UINT64) (398 - right_radix_leading_zeros) << 53) |
|
|
|
368 sign_x;
|
|
|
369 BID_RETURN (res);
|
|
|
370 }
|
|
|
371 ps = ps + 1;
|
|
|
372 } else {
|
|
|
373 // if 2 radix points, return NaN
|
|
|
374 res = 0x7c00000000000000ull | sign_x;
|
|
|
375 BID_RETURN (res);
|
|
|
376 }
|
|
|
377 } else if (!*(ps)) {
|
|
|
378 //pres->w[1] = 0x3040000000000000ull | sign_x;
|
|
|
379 res =
|
|
|
380 ((UINT64) (398 - right_radix_leading_zeros) << 53) | sign_x;
|
|
|
381 BID_RETURN (res);
|
|
|
382 }
|
|
|
383 }
|
|
|
384 }
|
|
|
385
|
|
|
386 c = *ps;
|
|
|
387
|
|
|
388 ndigits = 0;
|
|
|
389 while ((c >= '0' && c <= '9') || c == '.') {
|
|
|
390 if (c == '.') {
|
|
|
391 if (rdx_pt_enc) {
|
|
|
392 // return NaN
|
|
|
393 res = 0x7c00000000000000ull | sign_x;
|
|
|
394 BID_RETURN (res);
|
|
|
395 }
|
|
|
396 rdx_pt_enc = 1;
|
|
|
397 ps++;
|
|
|
398 c = *ps;
|
|
|
399 continue;
|
|
|
400 }
|
|
|
401 dec_expon_scale += rdx_pt_enc;
|
|
|
402
|
|
|
403 ndigits++;
|
|
|
404 if (ndigits <= 16) {
|
|
|
405 coefficient_x = (coefficient_x << 1) + (coefficient_x << 3);
|
|
|
406 coefficient_x += (UINT64) (c - '0');
|
|
|
407 } else if (ndigits == 17) {
|
|
|
408 // coefficient rounding
|
|
|
409 switch(rnd_mode){
|
|
|
410 case ROUNDING_TO_NEAREST:
|
|
|
411 midpoint = (c == '5' && !(coefficient_x & 1)) ? 1 : 0;
|
|
|
412 // if coefficient is even and c is 5, prepare to round up if
|
|
|
413 // subsequent digit is nonzero
|
|
|
414 // if str[MAXDIG+1] > 5, we MUST round up
|
|
|
415 // if str[MAXDIG+1] == 5 and coefficient is ODD, ROUND UP!
|
|
|
416 if (c > '5' || (c == '5' && (coefficient_x & 1))) {
|
|
|
417 coefficient_x++;
|
|
|
418 rounded_up = 1;
|
|
|
419 break;
|
|
|
420
|
|
|
421 case ROUNDING_DOWN:
|
|
|
422 if(sign_x) { coefficient_x++; rounded_up=1; }
|
|
|
423 break;
|
|
|
424 case ROUNDING_UP:
|
|
|
425 if(!sign_x) { coefficient_x++; rounded_up=1; }
|
|
|
426 break;
|
|
|
427 case ROUNDING_TIES_AWAY:
|
|
|
428 if(c>='5') { coefficient_x++; rounded_up=1; }
|
|
|
429 break;
|
|
|
430 }
|
|
|
431 if (coefficient_x == 10000000000000000ull) {
|
|
|
432 coefficient_x = 1000000000000000ull;
|
|
|
433 add_expon = 1;
|
|
|
434 }
|
|
|
435 }
|
|
|
436 if (c > '0')
|
|
|
437 rounded = 1;
|
|
|
438 add_expon += 1;
|
|
|
439 } else { // ndigits > 17
|
|
|
440 add_expon++;
|
|
|
441 if (midpoint && c > '0') {
|
|
|
442 coefficient_x++;
|
|
|
443 midpoint = 0;
|
|
|
444 rounded_up = 1;
|
|
|
445 }
|
|
|
446 if (c > '0')
|
|
|
447 rounded = 1;
|
|
|
448 }
|
|
|
449 ps++;
|
|
|
450 c = *ps;
|
|
|
451 }
|
|
|
452
|
|
|
453 add_expon -= (dec_expon_scale + right_radix_leading_zeros);
|
|
|
454
|
|
|
455 if (!c) {
|
|
|
456 res =
|
|
|
457 fast_get_BID64_check_OF (sign_x,
|
|
|
458 add_expon + DECIMAL_EXPONENT_BIAS,
|
|
|
459 coefficient_x, 0, &fpsc);
|
|
|
460 BID_RETURN (res);
|
|
|
461 }
|
|
|
462
|
|
|
463 if (c != 'E' && c != 'e') {
|
|
|
464 // return NaN
|
|
|
465 res = 0x7c00000000000000ull | sign_x;
|
|
|
466 BID_RETURN (res);
|
|
|
467 }
|
|
|
468 ps++;
|
|
|
469 c = *ps;
|
|
|
470 sgn_expon = (c == '-') ? 1 : 0;
|
|
|
471 if (c == '-' || c == '+') {
|
|
|
472 ps++;
|
|
|
473 c = *ps;
|
|
|
474 }
|
|
|
475 if (!c || c < '0' || c > '9') {
|
|
|
476 // return NaN
|
|
|
477 res = 0x7c00000000000000ull | sign_x;
|
|
|
478 BID_RETURN (res);
|
|
|
479 }
|
|
|
480
|
|
|
481 while (c >= '0' && c <= '9') {
|
|
|
482 expon_x = (expon_x << 1) + (expon_x << 3);
|
|
|
483 expon_x += (int) (c - '0');
|
|
|
484
|
|
|
485 ps++;
|
|
|
486 c = *ps;
|
|
|
487 }
|
|
|
488
|
|
|
489 if (c) {
|
|
|
490 // return NaN
|
|
|
491 res = 0x7c00000000000000ull | sign_x;
|
|
|
492 BID_RETURN (res);
|
|
|
493 }
|
|
|
494
|
|
|
495 if (sgn_expon)
|
|
|
496 expon_x = -expon_x;
|
|
|
497
|
|
|
498 expon_x += add_expon + DECIMAL_EXPONENT_BIAS;
|
|
|
499
|
|
|
500 if (expon_x < 0) {
|
|
|
501 if (rounded_up)
|
|
|
502 coefficient_x--;
|
|
|
503 rnd_mode = 0;
|
|
|
504 res =
|
|
|
505 get_BID64_UF (sign_x, expon_x, coefficient_x, rounded, rnd_mode,
|
|
|
506 &fpsc);
|
|
|
507 BID_RETURN (res);
|
|
|
508 }
|
|
|
509 res = get_BID64 (sign_x, expon_x, coefficient_x, rnd_mode, &fpsc);
|
|
|
510 BID_RETURN (res);
|
|
|
511 }
|
