Mercurial > hg > CbC > CbC_gcc

comparison libgcc/config/libbid/bid128_string.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 04ced10e8804
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
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 /*****************************************************************************
25 * BID128_to_string
26 ****************************************************************************/
27
28 #define BID_128RES
29 #include <stdio.h>
30 #include "bid_internal.h"
31 #include "bid128_2_str.h"
32 #include "bid128_2_str_macros.h"
33
34 extern int bid128_coeff_2_string (UINT64 X_hi, UINT64 X_lo,
35 char *char_ptr);
36
37 #if DECIMAL_CALL_BY_REFERENCE
38
39 void
40 bid128_to_string (char *str,
41 UINT128 *
42 px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
43 _EXC_INFO_PARAM) {
44 UINT128 x;
45 #else
46
47 void
48 bid128_to_string (char *str, UINT128 x
49 _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
50 #endif
51 UINT64 x_sign;
52 UINT64 x_exp;
53 int exp; // unbiased exponent
54 // Note: C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (all are UINT64)
55 int ind;
56 UINT128 C1;
57 unsigned int k = 0; // pointer in the string
58 unsigned int d0, d123;
59 UINT64 HI_18Dig, LO_18Dig, Tmp;
60 UINT32 MiDi[12], *ptr;
61 char *c_ptr_start, *c_ptr;
62 int midi_ind, k_lcv, len;
63
64 #if DECIMAL_CALL_BY_REFERENCE
65 x = *px;
66 #endif
67
68 BID_SWAP128(x);
69 // check for NaN or Infinity
70 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) {
71 // x is special
72 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
73 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN
74 // set invalid flag
75 str[0] = ((SINT64)x.w[1]<0)? '-':'+';
76 str[1] = 'S';
77 str[2] = 'N';
78 str[3] = 'a';
79 str[4] = 'N';
80 str[5] = '\0';
81 } else { // x is QNaN
82 str[0] = ((SINT64)x.w[1]<0)? '-':'+';
83 str[1] = 'Q';
84 str[2] = 'N';
85 str[3] = 'a';
86 str[4] = 'N';
87 str[5] = '\0';
88 }
89 } else { // x is not a NaN, so it must be infinity
90 if ((x.w[1] & MASK_SIGN) == 0x0ull) { // x is +inf
91 str[0] = '+';
92 str[1] = 'I';
93 str[2] = 'n';
94 str[3] = 'f';
95 str[4] = '\0';
96 } else { // x is -inf
97 str[0] = '-';
98 str[1] = 'I';
99 str[2] = 'n';
100 str[3] = 'f';
101 str[4] = '\0';
102 }
103 }
104 return;
105 } else if (((x.w[1] & MASK_COEFF) == 0x0ull) && (x.w[0] == 0x0ull)) {
106 // x is 0
107 len = 0;
108
109 //determine if +/-
110 if (x.w[1] & MASK_SIGN)
111 str[len++] = '-';
112 else
113 str[len++] = '+';
114 str[len++] = '0';
115 str[len++] = 'E';
116
117 // extract the exponent and print
118 exp = (int) (((x.w[1] & MASK_EXP) >> 49) - 6176);
119 if(exp > (((0x5ffe)>>1) - (6176))) {
120 exp = (int) ((((x.w[1]<<2) & MASK_EXP) >> 49) - 6176);
121 }
122 if (exp >= 0) {
123 str[len++] = '+';
124 len += sprintf (str + len, "%u", exp);// should not use sprintf (should
125 // use sophisticated algorithm, since we know range of exp is limited)
126 str[len++] = '\0';
127 } else {
128 len += sprintf (str + len, "%d", exp);// should not use sprintf (should
129 // use sophisticated algorithm, since we know range of exp is limited)
130 str[len++] = '\0';
131 }
132 return;
133 } else { // x is not special and is not zero
134 // unpack x
135 x_sign = x.w[1] & MASK_SIGN;// 0 for positive, MASK_SIGN for negative
136 x_exp = x.w[1] & MASK_EXP;// biased and shifted left 49 bit positions
137 if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)
138 x_exp = (x.w[1]<<2) & MASK_EXP;// biased and shifted left 49 bit positions
139 C1.w[1] = x.w[1] & MASK_COEFF;
140 C1.w[0] = x.w[0];
141 exp = (x_exp >> 49) - 6176;
142
143 // determine sign's representation as a char
144 if (x_sign)
145 str[k++] = '-';// negative number
146 else
147 str[k++] = '+';// positive number
148
149 // determine coefficient's representation as a decimal string
150
151 // if zero or non-canonical, set coefficient to '0'
152 if ((C1.w[1] > 0x0001ed09bead87c0ull) ||
153 (C1.w[1] == 0x0001ed09bead87c0ull &&
154 (C1.w[0] > 0x378d8e63ffffffffull)) ||
155 ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) ||
156 ((C1.w[1] == 0) && (C1.w[0] == 0))) {
157 str[k++] = '0';
158 } else {
159 /* ****************************************************
160 This takes a bid coefficient in C1.w[1],C1.w[0]
161 and put the converted character sequence at location
162 starting at &(str[k]). The function returns the number
163 of MiDi returned. Note that the character sequence
164 does not have leading zeros EXCEPT when the input is of
165 zero value. It will then output 1 character '0'
166 The algorithm essentailly tries first to get a sequence of
167 Millenial Digits "MiDi" and then uses table lookup to get the
168 character strings of these MiDis.
169 **************************************************** */
170 /* Algorithm first decompose possibly 34 digits in hi and lo
171 18 digits. (The high can have at most 16 digits). It then
172 uses macro that handle 18 digit portions.
173 The first step is to get hi and lo such that
174 2^(64) C1.w[1] + C1.w[0] = hi * 10^18 + lo, 0 <= lo < 10^18.
175 We use a table lookup method to obtain the hi and lo 18 digits.
176 [C1.w[1],C1.w[0]] = c_8 2^(107) + c_7 2^(101) + ... + c_0 2^(59) + d
177 where 0 <= d < 2^59 and each c_j has 6 bits. Because d fits in
178 18 digits, we set hi = 0, and lo = d to begin with.
179 We then retrieve from a table, for j = 0, 1, ..., 8
180 that gives us A and B where c_j 2^(59+6j) = A * 10^18 + B.
181 hi += A ; lo += B; After each accumulation into lo, we normalize
182 immediately. So at the end, we have the decomposition as we need. */
183
184 Tmp = C1.w[0] >> 59;
185 LO_18Dig = (C1.w[0] << 5) >> 5;
186 Tmp += (C1.w[1] << 5);
187 HI_18Dig = 0;
188 k_lcv = 0;
189 // Tmp = {C1.w[1]{49:0}, C1.w[0]{63:59}}
190 // Lo_18Dig = {C1.w[0]{58:0}}
191
192 while (Tmp) {
193 midi_ind = (int) (Tmp & 0x000000000000003FLL);
194 midi_ind <<= 1;
195 Tmp >>= 6;
196 HI_18Dig += mod10_18_tbl[k_lcv][midi_ind++];
197 LO_18Dig += mod10_18_tbl[k_lcv++][midi_ind];
198 __L0_Normalize_10to18 (HI_18Dig, LO_18Dig);
199 }
200 ptr = MiDi;
201 if (HI_18Dig == 0LL) {
202 __L1_Split_MiDi_6_Lead (LO_18Dig, ptr);
203 } else {
204 __L1_Split_MiDi_6_Lead (HI_18Dig, ptr);
205 __L1_Split_MiDi_6 (LO_18Dig, ptr);
206 }
207 len = ptr - MiDi;
208 c_ptr_start = &(str[k]);
209 c_ptr = c_ptr_start;
210
211 /* now convert the MiDi into character strings */
212 __L0_MiDi2Str_Lead (MiDi[0], c_ptr);
213 for (k_lcv = 1; k_lcv < len; k_lcv++) {
214 __L0_MiDi2Str (MiDi[k_lcv], c_ptr);
215 }
216 k = k + (c_ptr - c_ptr_start);
217 }
218
219 // print E and sign of exponent
220 str[k++] = 'E';
221 if (exp < 0) {
222 exp = -exp;
223 str[k++] = '-';
224 } else {
225 str[k++] = '+';
226 }
227
228 // determine exponent's representation as a decimal string
229 // d0 = exp / 1000;
230 // Use Property 1
231 d0 = (exp * 0x418a) >> 24;// 0x418a * 2^-24 = (10^(-3))RP,15
232 d123 = exp - 1000 * d0;
233
234 if (d0) { // 1000 <= exp <= 6144 => 4 digits to return
235 str[k++] = d0 + 0x30;// ASCII for decimal digit d0
236 ind = 3 * d123;
237 str[k++] = char_table3[ind];
238 str[k++] = char_table3[ind + 1];
239 str[k++] = char_table3[ind + 2];
240 } else { // 0 <= exp <= 999 => d0 = 0
241 if (d123 < 10) { // 0 <= exp <= 9 => 1 digit to return
242 str[k++] = d123 + 0x30;// ASCII
243 } else if (d123 < 100) { // 10 <= exp <= 99 => 2 digits to return
244 ind = 2 * (d123 - 10);
245 str[k++] = char_table2[ind];
246 str[k++] = char_table2[ind + 1];
247 } else { // 100 <= exp <= 999 => 3 digits to return
248 ind = 3 * d123;
249 str[k++] = char_table3[ind];
250 str[k++] = char_table3[ind + 1];
251 str[k++] = char_table3[ind + 2];
252 }
253 }
254 str[k] = '\0';
255
256 }
257 return;
258
259 }
260
261
262 #define MAX_FORMAT_DIGITS_128 34
263 #define MAX_STRING_DIGITS_128 100
264 #define MAX_SEARCH MAX_STRING_DIGITS_128-MAX_FORMAT_DIGITS_128-1
265
266
267 #if DECIMAL_CALL_BY_REFERENCE
268
269 void
270 bid128_from_string (UINT128 * pres,
271 char *ps _RND_MODE_PARAM _EXC_FLAGS_PARAM
272 _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
273 #else
274
275 UINT128
276 bid128_from_string (char *ps _RND_MODE_PARAM _EXC_FLAGS_PARAM
277 _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
278 #endif
279 UINT128 CX, res;
280 UINT64 sign_x, coeff_high, coeff_low, coeff2, coeff_l2, carry = 0x0ull,
281 scale_high, right_radix_leading_zeros;
282 int ndigits_before, ndigits_after, ndigits_total, dec_expon, sgn_exp,
283 i, d2, rdx_pt_enc;
284 char c, buffer[MAX_STRING_DIGITS_128];
285 int save_rnd_mode;
286 int save_fpsf;
287
288 #if DECIMAL_CALL_BY_REFERENCE
289 #if !DECIMAL_GLOBAL_ROUNDING
290 _IDEC_round rnd_mode = *prnd_mode;
291 #endif
292 #endif
293
294 save_rnd_mode = rnd_mode; // dummy
295 save_fpsf = *pfpsf; // dummy
296
297 right_radix_leading_zeros = rdx_pt_enc = 0;
298
299 // if null string, return NaN
300 if (!ps) {
301 res.w[1] = 0x7c00000000000000ull;
302 res.w[0] = 0;
303 BID_RETURN (res);
304 }
305 // eliminate leading white space
306 while ((*ps == ' ') || (*ps == '\t'))
307 ps++;
308
309 // c gets first character
310 c = *ps;
311
312
313 // if c is null or not equal to a (radix point, negative sign,
314 // positive sign, or number) it might be SNaN, sNaN, Infinity
315 if (!c
316 || (c != '.' && c != '-' && c != '+'
317 && ((unsigned) (c - '0') > 9))) {
318 res.w[0] = 0;
319 // Infinity?
320 if ((tolower_macro (ps[0]) == 'i' && tolower_macro (ps[1]) == 'n'
321 && tolower_macro (ps[2]) == 'f')
322 && (!ps[3]
323 || (tolower_macro (ps[3]) == 'i'
324 && tolower_macro (ps[4]) == 'n'
325 && tolower_macro (ps[5]) == 'i'
326 && tolower_macro (ps[6]) == 't'
327 && tolower_macro (ps[7]) == 'y' && !ps[8])
328 )) {
329 res.w[1] = 0x7800000000000000ull;
330 BID_RETURN (res);
331 }
332 // return sNaN
333 if (tolower_macro (ps[0]) == 's' && tolower_macro (ps[1]) == 'n' &&
334 tolower_macro (ps[2]) == 'a' && tolower_macro (ps[3]) == 'n') {
335 // case insensitive check for snan
336 res.w[1] = 0x7e00000000000000ull;
337 BID_RETURN (res);
338 } else {
339 // return qNaN
340 res.w[1] = 0x7c00000000000000ull;
341 BID_RETURN (res);
342 }
343 }
344 // if +Inf, -Inf, +Infinity, or -Infinity (case insensitive check for inf)
345 if ((tolower_macro (ps[1]) == 'i' && tolower_macro (ps[2]) == 'n' &&
346 tolower_macro (ps[3]) == 'f') && (!ps[4] ||
347 (tolower_macro (ps[4]) == 'i' && tolower_macro (ps[5]) == 'n' &&
348 tolower_macro (ps[6]) == 'i' && tolower_macro (ps[7]) == 't' &&
349 tolower_macro (ps[8]) == 'y' && !ps[9]))) { // ci check for infinity
350 res.w[0] = 0;
351
352 if (c == '+')
353 res.w[1] = 0x7800000000000000ull;
354 else if (c == '-')
355 res.w[1] = 0xf800000000000000ull;
356 else
357 res.w[1] = 0x7c00000000000000ull;
358
359 BID_RETURN (res);
360 }
361 // if +sNaN, +SNaN, -sNaN, or -SNaN
362 if (tolower_macro (ps[1]) == 's' && tolower_macro (ps[2]) == 'n'
363 && tolower_macro (ps[3]) == 'a' && tolower_macro (ps[4]) == 'n') {
364 res.w[0] = 0;
365 if (c == '-')
366 res.w[1] = 0xfe00000000000000ull;
367 else
368 res.w[1] = 0x7e00000000000000ull;
369 BID_RETURN (res);
370 }
371 // set up sign_x to be OR'ed with the upper word later
372 if (c == '-')
373 sign_x = 0x8000000000000000ull;
374 else
375 sign_x = 0;
376
377 // go to next character if leading sign
378 if (c == '-' || c == '+')
379 ps++;
380
381 c = *ps;
382
383 // if c isn't a decimal point or a decimal digit, return NaN
384 if (c != '.' && ((unsigned) (c - '0') > 9)) {
385 res.w[1] = 0x7c00000000000000ull | sign_x;
386 res.w[0] = 0;
387 BID_RETURN (res);
388 }
389 // detect zero (and eliminate/ignore leading zeros)
390 if (*(ps) == '0') {
391
392 // if all numbers are zeros (with possibly 1 radix point, the number is zero
393 // should catch cases such as: 000.0
394 while (*ps == '0') {
395
396 ps++;
397
398 // for numbers such as 0.0000000000000000000000000000000000001001,
399 // we want to count the leading zeros
400 if (rdx_pt_enc) {
401 right_radix_leading_zeros++;
402 }
403 // if this character is a radix point, make sure we haven't already
404 // encountered one
405 if (*(ps) == '.') {
406 if (rdx_pt_enc == 0) {
407 rdx_pt_enc = 1;
408 // if this is the first radix point, and the next character is NULL,
409 // we have a zero
410 if (!*(ps + 1)) {
411 res.w[1] =
412 (0x3040000000000000ull -
413 (right_radix_leading_zeros << 49)) | sign_x;
414 res.w[0] = 0;
415 BID_RETURN (res);
416 }
417 ps = ps + 1;
418 } else {
419 // if 2 radix points, return NaN
420 res.w[1] = 0x7c00000000000000ull | sign_x;
421 res.w[0] = 0;
422 BID_RETURN (res);
423 }
424 } else if (!*(ps)) {
425 //res.w[1] = 0x3040000000000000ull | sign_x;
426 res.w[1] =
427 (0x3040000000000000ull -
428 (right_radix_leading_zeros << 49)) | sign_x;
429 res.w[0] = 0;
430 BID_RETURN (res);
431 }
432 }
433 }
434
435 c = *ps;
436
437 // initialize local variables
438 ndigits_before = ndigits_after = ndigits_total = 0;
439 sgn_exp = 0;
440 // pstart_coefficient = ps;
441
442 if (!rdx_pt_enc) {
443 // investigate string (before radix point)
444 while ((unsigned) (c - '0') <= 9
445 && ndigits_before < MAX_STRING_DIGITS_128) {
446 buffer[ndigits_before] = c;
447 ps++;
448 c = *ps;
449 ndigits_before++;
450 }
451
452 ndigits_total = ndigits_before;
453 if (c == '.') {
454 ps++;
455 if ((c = *ps)) {
456
457 // investigate string (after radix point)
458 while ((unsigned) (c - '0') <= 9
459 && ndigits_total < MAX_STRING_DIGITS_128) {
460 buffer[ndigits_total] = c;
461 ps++;
462 c = *ps;
463 ndigits_total++;
464 }
465 ndigits_after = ndigits_total - ndigits_before;
466 }
467 }
468 } else {
469 // we encountered a radix point while detecting zeros
470 //if (c = *ps){
471
472 c = *ps;
473 ndigits_total = 0;
474 // investigate string (after radix point)
475 while ((unsigned) (c - '0') <= 9
476 && ndigits_total < MAX_STRING_DIGITS_128) {
477 buffer[ndigits_total] = c;
478 ps++;
479 c = *ps;
480 ndigits_total++;
481 }
482 ndigits_after = ndigits_total - ndigits_before;
483 }
484
485 // get exponent
486 dec_expon = 0;
487 if (ndigits_total < MAX_STRING_DIGITS_128) {
488 if (c) {
489 if (c != 'e' && c != 'E') {
490 // return NaN
491 res.w[1] = 0x7c00000000000000ull;
492 res.w[0] = 0;
493 BID_RETURN (res);
494 }
495 ps++;
496 c = *ps;
497
498 if (((unsigned) (c - '0') > 9)
499 && ((c != '+' && c != '-') || (unsigned) (ps[1] - '0') > 9)) {
500 // return NaN
501 res.w[1] = 0x7c00000000000000ull;
502 res.w[0] = 0;
503 BID_RETURN (res);
504 }
505
506 if (c == '-') {
507 sgn_exp = -1;
508 ps++;
509 c = *ps;
510 } else if (c == '+') {
511 ps++;
512 c = *ps;
513 }
514
515 dec_expon = c - '0';
516 i = 1;
517 ps++;
518 c = *ps - '0';
519 while (((unsigned) c) <= 9 && i < 7) {
520 d2 = dec_expon + dec_expon;
521 dec_expon = (d2 << 2) + d2 + c;
522 ps++;
523 c = *ps - '0';
524 i++;
525 }
526 }
527
528 dec_expon = (dec_expon + sgn_exp) ^ sgn_exp;
529 }
530
531
532 if (ndigits_total <= MAX_FORMAT_DIGITS_128) {
533 dec_expon +=
534 DECIMAL_EXPONENT_BIAS_128 - ndigits_after -
535 right_radix_leading_zeros;
536 if (dec_expon < 0) {
537 res.w[1] = 0 | sign_x;
538 res.w[0] = 0;
539 }
540 if (ndigits_total == 0) {
541 CX.w[0] = 0;
542 CX.w[1] = 0;
543 } else if (ndigits_total <= 19) {
544 coeff_high = buffer[0] - '0';
545 for (i = 1; i < ndigits_total; i++) {
546 coeff2 = coeff_high + coeff_high;
547 coeff_high = (coeff2 << 2) + coeff2 + buffer[i] - '0';
548 }
549 CX.w[0] = coeff_high;
550 CX.w[1] = 0;
551 } else {
552 coeff_high = buffer[0] - '0';
553 for (i = 1; i < ndigits_total - 17; i++) {
554 coeff2 = coeff_high + coeff_high;
555 coeff_high = (coeff2 << 2) + coeff2 + buffer[i] - '0';
556 }
557 coeff_low = buffer[i] - '0';
558 i++;
559 for (; i < ndigits_total; i++) {
560 coeff_l2 = coeff_low + coeff_low;
561 coeff_low = (coeff_l2 << 2) + coeff_l2 + buffer[i] - '0';
562 }
563 // now form the coefficient as coeff_high*10^19+coeff_low+carry
564 scale_high = 100000000000000000ull;
565 __mul_64x64_to_128_fast (CX, coeff_high, scale_high);
566
567 CX.w[0] += coeff_low;
568 if (CX.w[0] < coeff_low)
569 CX.w[1]++;
570 }
571 get_BID128 (&res, sign_x, dec_expon, CX,&rnd_mode,pfpsf);
572 BID_RETURN (res);
573 } else {
574 // simply round using the digits that were read
575
576 dec_expon +=
577 ndigits_before + DECIMAL_EXPONENT_BIAS_128 -
578 MAX_FORMAT_DIGITS_128 - right_radix_leading_zeros;
579
580 if (dec_expon < 0) {
581 res.w[1] = 0 | sign_x;
582 res.w[0] = 0;
583 }
584
585 coeff_high = buffer[0] - '0';
586 for (i = 1; i < MAX_FORMAT_DIGITS_128 - 17; i++) {
587 coeff2 = coeff_high + coeff_high;
588 coeff_high = (coeff2 << 2) + coeff2 + buffer[i] - '0';
589 }
590 coeff_low = buffer[i] - '0';
591 i++;
592 for (; i < MAX_FORMAT_DIGITS_128; i++) {
593 coeff_l2 = coeff_low + coeff_low;
594 coeff_low = (coeff_l2 << 2) + coeff_l2 + buffer[i] - '0';
595 }
596 switch(rnd_mode) {
597 case ROUNDING_TO_NEAREST:
598 carry = ((unsigned) ('4' - buffer[i])) >> 31;
599 if ((buffer[i] == '5' && !(coeff_low & 1)) || dec_expon < 0) {
600 if (dec_expon >= 0) {
601 carry = 0;
602 i++;
603 }
604 for (; i < ndigits_total; i++) {
605 if (buffer[i] > '0') {
606 carry = 1;
607 break;
608 }
609 }
610 }
611 break;
612
613 case ROUNDING_DOWN:
614 if(sign_x)
615 for (; i < ndigits_total; i++) {
616 if (buffer[i] > '0') {
617 carry = 1;
618 break;
619 }
620 }
621 break;
622 case ROUNDING_UP:
623 if(!sign_x)
624 for (; i < ndigits_total; i++) {
625 if (buffer[i] > '0') {
626 carry = 1;
627 break;
628 }
629 }
630 break;
631 case ROUNDING_TO_ZERO:
632 carry=0;
633 break;
634 case ROUNDING_TIES_AWAY:
635 carry = ((unsigned) ('4' - buffer[i])) >> 31;
636 if (dec_expon < 0) {
637 for (; i < ndigits_total; i++) {
638 if (buffer[i] > '0') {
639 carry = 1;
640 break;
641 }
642 }
643 }
644 break;
645
646
647 }
648 // now form the coefficient as coeff_high*10^17+coeff_low+carry
649 scale_high = 100000000000000000ull;
650 if (dec_expon < 0) {
651 if (dec_expon > -MAX_FORMAT_DIGITS_128) {
652 scale_high = 1000000000000000000ull;
653 coeff_low = (coeff_low << 3) + (coeff_low << 1);
654 dec_expon--;
655 }
656 if (dec_expon == -MAX_FORMAT_DIGITS_128
657 && coeff_high > 50000000000000000ull)
658 carry = 0;
659 }
660
661 __mul_64x64_to_128_fast (CX, coeff_high, scale_high);
662
663 coeff_low += carry;
664 CX.w[0] += coeff_low;
665 if (CX.w[0] < coeff_low)
666 CX.w[1]++;
667
668
669 get_BID128(&res, sign_x, dec_expon, CX, &rnd_mode, pfpsf);
670 BID_RETURN (res);
671 }
672 }