meson: convert hw/vfio
[qemu.git] / libdecnumber / dpd / decimal128.c
1 /* Decimal 128-bit format module for the decNumber C Library.
2 Copyright (C) 2005, 2007 Free Software Foundation, Inc.
3 Contributed by IBM Corporation. Author Mike Cowlishaw.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 In addition to the permissions in the GNU General Public License,
13 the Free Software Foundation gives you unlimited permission to link
14 the compiled version of this file into combinations with other
15 programs, and to distribute those combinations without any
16 restriction coming from the use of this file. (The General Public
17 License restrictions do apply in other respects; for example, they
18 cover modification of the file, and distribution when not linked
19 into a combine executable.)
20
21 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
22 WARRANTY; without even the implied warranty of MERCHANTABILITY or
23 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
24 for more details.
25
26 You should have received a copy of the GNU General Public License
27 along with GCC; see the file COPYING. If not, write to the Free
28 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
29 02110-1301, USA. */
30
31 /* ------------------------------------------------------------------ */
32 /* Decimal 128-bit format module */
33 /* ------------------------------------------------------------------ */
34 /* This module comprises the routines for decimal128 format numbers. */
35 /* Conversions are supplied to and from decNumber and String. */
36 /* */
37 /* This is used when decNumber provides operations, either for all */
38 /* operations or as a proxy between decNumber and decSingle. */
39 /* */
40 /* Error handling is the same as decNumber (qv.). */
41 /* ------------------------------------------------------------------ */
42 #include "qemu/osdep.h"
43
44 #include "libdecnumber/dconfig.h"
45 #define DECNUMDIGITS 34 /* make decNumbers with space for 34 */
46 #include "libdecnumber/decNumber.h"
47 #include "libdecnumber/decNumberLocal.h"
48 #include "libdecnumber/dpd/decimal128.h"
49
50 /* Utility routines and tables [in decimal64.c] */
51 extern const uInt COMBEXP[32], COMBMSD[32];
52 extern const uByte BIN2CHAR[4001];
53
54 extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
55 extern void decDigitsToDPD(const decNumber *, uInt *, Int);
56
57 #if DECTRACE || DECCHECK
58 void decimal128Show(const decimal128 *); /* for debug */
59 extern void decNumberShow(const decNumber *); /* .. */
60 #endif
61
62 /* Useful macro */
63 /* Clear a structure (e.g., a decNumber) */
64 #define DEC_clear(d) memset(d, 0, sizeof(*d))
65
66 /* ------------------------------------------------------------------ */
67 /* decimal128FromNumber -- convert decNumber to decimal128 */
68 /* */
69 /* ds is the target decimal128 */
70 /* dn is the source number (assumed valid) */
71 /* set is the context, used only for reporting errors */
72 /* */
73 /* The set argument is used only for status reporting and for the */
74 /* rounding mode (used if the coefficient is more than DECIMAL128_Pmax*/
75 /* digits or an overflow is detected). If the exponent is out of the */
76 /* valid range then Overflow or Underflow will be raised. */
77 /* After Underflow a subnormal result is possible. */
78 /* */
79 /* DEC_Clamped is set if the number has to be 'folded down' to fit, */
80 /* by reducing its exponent and multiplying the coefficient by a */
81 /* power of ten, or if the exponent on a zero had to be clamped. */
82 /* ------------------------------------------------------------------ */
83 decimal128 * decimal128FromNumber(decimal128 *d128, const decNumber *dn,
84 decContext *set) {
85 uInt status=0; /* status accumulator */
86 Int ae; /* adjusted exponent */
87 decNumber dw; /* work */
88 decContext dc; /* .. */
89 uInt *pu; /* .. */
90 uInt comb, exp; /* .. */
91 uInt targar[4]={0,0,0,0}; /* target 128-bit */
92 #define targhi targar[3] /* name the word with the sign */
93 #define targmh targar[2] /* name the words */
94 #define targml targar[1] /* .. */
95 #define targlo targar[0] /* .. */
96
97 /* If the number has too many digits, or the exponent could be */
98 /* out of range then reduce the number under the appropriate */
99 /* constraints. This could push the number to Infinity or zero, */
100 /* so this check and rounding must be done before generating the */
101 /* decimal128] */
102 ae=dn->exponent+dn->digits-1; /* [0 if special] */
103 if (dn->digits>DECIMAL128_Pmax /* too many digits */
104 || ae>DECIMAL128_Emax /* likely overflow */
105 || ae<DECIMAL128_Emin) { /* likely underflow */
106 decContextDefault(&dc, DEC_INIT_DECIMAL128); /* [no traps] */
107 dc.round=set->round; /* use supplied rounding */
108 decNumberPlus(&dw, dn, &dc); /* (round and check) */
109 /* [this changes -0 to 0, so enforce the sign...] */
110 dw.bits|=dn->bits&DECNEG;
111 status=dc.status; /* save status */
112 dn=&dw; /* use the work number */
113 } /* maybe out of range */
114
115 if (dn->bits&DECSPECIAL) { /* a special value */
116 if (dn->bits&DECINF) targhi=DECIMAL_Inf<<24;
117 else { /* sNaN or qNaN */
118 if ((*dn->lsu!=0 || dn->digits>1) /* non-zero coefficient */
119 && (dn->digits<DECIMAL128_Pmax)) { /* coefficient fits */
120 decDigitsToDPD(dn, targar, 0);
121 }
122 if (dn->bits&DECNAN) targhi|=DECIMAL_NaN<<24;
123 else targhi|=DECIMAL_sNaN<<24;
124 } /* a NaN */
125 } /* special */
126
127 else { /* is finite */
128 if (decNumberIsZero(dn)) { /* is a zero */
129 /* set and clamp exponent */
130 if (dn->exponent<-DECIMAL128_Bias) {
131 exp=0; /* low clamp */
132 status|=DEC_Clamped;
133 }
134 else {
135 exp=dn->exponent+DECIMAL128_Bias; /* bias exponent */
136 if (exp>DECIMAL128_Ehigh) { /* top clamp */
137 exp=DECIMAL128_Ehigh;
138 status|=DEC_Clamped;
139 }
140 }
141 comb=(exp>>9) & 0x18; /* msd=0, exp top 2 bits .. */
142 }
143 else { /* non-zero finite number */
144 uInt msd; /* work */
145 Int pad=0; /* coefficient pad digits */
146
147 /* the dn is known to fit, but it may need to be padded */
148 exp=(uInt)(dn->exponent+DECIMAL128_Bias); /* bias exponent */
149 if (exp>DECIMAL128_Ehigh) { /* fold-down case */
150 pad=exp-DECIMAL128_Ehigh;
151 exp=DECIMAL128_Ehigh; /* [to maximum] */
152 status|=DEC_Clamped;
153 }
154
155 /* [fastpath for common case is not a win, here] */
156 decDigitsToDPD(dn, targar, pad);
157 /* save and clear the top digit */
158 msd=targhi>>14;
159 targhi&=0x00003fff;
160
161 /* create the combination field */
162 if (msd>=8) comb=0x18 | ((exp>>11) & 0x06) | (msd & 0x01);
163 else comb=((exp>>9) & 0x18) | msd;
164 }
165 targhi|=comb<<26; /* add combination field .. */
166 targhi|=(exp&0xfff)<<14; /* .. and exponent continuation */
167 } /* finite */
168
169 if (dn->bits&DECNEG) targhi|=0x80000000; /* add sign bit */
170
171 /* now write to storage; this is endian */
172 pu=(uInt *)d128->bytes; /* overlay */
173 if (DECLITEND) {
174 pu[0]=targlo; /* directly store the low int */
175 pu[1]=targml; /* then the mid-low */
176 pu[2]=targmh; /* then the mid-high */
177 pu[3]=targhi; /* then the high int */
178 }
179 else {
180 pu[0]=targhi; /* directly store the high int */
181 pu[1]=targmh; /* then the mid-high */
182 pu[2]=targml; /* then the mid-low */
183 pu[3]=targlo; /* then the low int */
184 }
185
186 if (status!=0) decContextSetStatus(set, status); /* pass on status */
187 /* decimal128Show(d128); */
188 return d128;
189 } /* decimal128FromNumber */
190
191 /* ------------------------------------------------------------------ */
192 /* decimal128ToNumber -- convert decimal128 to decNumber */
193 /* d128 is the source decimal128 */
194 /* dn is the target number, with appropriate space */
195 /* No error is possible. */
196 /* ------------------------------------------------------------------ */
197 decNumber * decimal128ToNumber(const decimal128 *d128, decNumber *dn) {
198 uInt msd; /* coefficient MSD */
199 uInt exp; /* exponent top two bits */
200 uInt comb; /* combination field */
201 const uInt *pu; /* work */
202 Int need; /* .. */
203 uInt sourar[4]; /* source 128-bit */
204 #define sourhi sourar[3] /* name the word with the sign */
205 #define sourmh sourar[2] /* and the mid-high word */
206 #define sourml sourar[1] /* and the mod-low word */
207 #define sourlo sourar[0] /* and the lowest word */
208
209 /* load source from storage; this is endian */
210 pu=(const uInt *)d128->bytes; /* overlay */
211 if (DECLITEND) {
212 sourlo=pu[0]; /* directly load the low int */
213 sourml=pu[1]; /* then the mid-low */
214 sourmh=pu[2]; /* then the mid-high */
215 sourhi=pu[3]; /* then the high int */
216 }
217 else {
218 sourhi=pu[0]; /* directly load the high int */
219 sourmh=pu[1]; /* then the mid-high */
220 sourml=pu[2]; /* then the mid-low */
221 sourlo=pu[3]; /* then the low int */
222 }
223
224 comb=(sourhi>>26)&0x1f; /* combination field */
225
226 decNumberZero(dn); /* clean number */
227 if (sourhi&0x80000000) dn->bits=DECNEG; /* set sign if negative */
228
229 msd=COMBMSD[comb]; /* decode the combination field */
230 exp=COMBEXP[comb]; /* .. */
231
232 if (exp==3) { /* is a special */
233 if (msd==0) {
234 dn->bits|=DECINF;
235 return dn; /* no coefficient needed */
236 }
237 else if (sourhi&0x02000000) dn->bits|=DECSNAN;
238 else dn->bits|=DECNAN;
239 msd=0; /* no top digit */
240 }
241 else { /* is a finite number */
242 dn->exponent=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; /* unbiased */
243 }
244
245 /* get the coefficient */
246 sourhi&=0x00003fff; /* clean coefficient continuation */
247 if (msd) { /* non-zero msd */
248 sourhi|=msd<<14; /* prefix to coefficient */
249 need=12; /* process 12 declets */
250 }
251 else { /* msd=0 */
252 if (sourhi) need=11; /* declets to process */
253 else if (sourmh) need=10;
254 else if (sourml) need=7;
255 else if (sourlo) need=4;
256 else return dn; /* easy: coefficient is 0 */
257 } /*msd=0 */
258
259 decDigitsFromDPD(dn, sourar, need); /* process declets */
260 /* decNumberShow(dn); */
261 return dn;
262 } /* decimal128ToNumber */
263
264 /* ------------------------------------------------------------------ */
265 /* to-scientific-string -- conversion to numeric string */
266 /* to-engineering-string -- conversion to numeric string */
267 /* */
268 /* decimal128ToString(d128, string); */
269 /* decimal128ToEngString(d128, string); */
270 /* */
271 /* d128 is the decimal128 format number to convert */
272 /* string is the string where the result will be laid out */
273 /* */
274 /* string must be at least 24 characters */
275 /* */
276 /* No error is possible, and no status can be set. */
277 /* ------------------------------------------------------------------ */
278 char * decimal128ToEngString(const decimal128 *d128, char *string){
279 decNumber dn; /* work */
280 decimal128ToNumber(d128, &dn);
281 decNumberToEngString(&dn, string);
282 return string;
283 } /* decimal128ToEngString */
284
285 char * decimal128ToString(const decimal128 *d128, char *string){
286 uInt msd; /* coefficient MSD */
287 Int exp; /* exponent top two bits or full */
288 uInt comb; /* combination field */
289 char *cstart; /* coefficient start */
290 char *c; /* output pointer in string */
291 const uInt *pu; /* work */
292 char *s, *t; /* .. (source, target) */
293 Int dpd; /* .. */
294 Int pre, e; /* .. */
295 const uByte *u; /* .. */
296
297 uInt sourar[4]; /* source 128-bit */
298 #define sourhi sourar[3] /* name the word with the sign */
299 #define sourmh sourar[2] /* and the mid-high word */
300 #define sourml sourar[1] /* and the mod-low word */
301 #define sourlo sourar[0] /* and the lowest word */
302
303 /* load source from storage; this is endian */
304 pu=(const uInt *)d128->bytes; /* overlay */
305 if (DECLITEND) {
306 sourlo=pu[0]; /* directly load the low int */
307 sourml=pu[1]; /* then the mid-low */
308 sourmh=pu[2]; /* then the mid-high */
309 sourhi=pu[3]; /* then the high int */
310 }
311 else {
312 sourhi=pu[0]; /* directly load the high int */
313 sourmh=pu[1]; /* then the mid-high */
314 sourml=pu[2]; /* then the mid-low */
315 sourlo=pu[3]; /* then the low int */
316 }
317
318 c=string; /* where result will go */
319 if (((Int)sourhi)<0) *c++='-'; /* handle sign */
320
321 comb=(sourhi>>26)&0x1f; /* combination field */
322 msd=COMBMSD[comb]; /* decode the combination field */
323 exp=COMBEXP[comb]; /* .. */
324
325 if (exp==3) {
326 if (msd==0) { /* infinity */
327 strcpy(c, "Inf");
328 strcpy(c+3, "inity");
329 return string; /* easy */
330 }
331 if (sourhi&0x02000000) *c++='s'; /* sNaN */
332 strcpy(c, "NaN"); /* complete word */
333 c+=3; /* step past */
334 if (sourlo==0 && sourml==0 && sourmh==0
335 && (sourhi&0x0003ffff)==0) return string; /* zero payload */
336 /* otherwise drop through to add integer; set correct exp */
337 exp=0; msd=0; /* setup for following code */
338 }
339 else exp=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; /* unbiased */
340
341 /* convert 34 digits of significand to characters */
342 cstart=c; /* save start of coefficient */
343 if (msd) *c++='0'+(char)msd; /* non-zero most significant digit */
344
345 /* Now decode the declets. After extracting each one, it is */
346 /* decoded to binary and then to a 4-char sequence by table lookup; */
347 /* the 4-chars are a 1-char length (significant digits, except 000 */
348 /* has length 0). This allows us to left-align the first declet */
349 /* with non-zero content, then remaining ones are full 3-char */
350 /* length. We use fixed-length memcpys because variable-length */
351 /* causes a subroutine call in GCC. (These are length 4 for speed */
352 /* and are safe because the array has an extra terminator byte.) */
353 #define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4]; \
354 if (c!=cstart) {memcpy(c, u+1, 4); c+=3;} \
355 else if (*u) {memcpy(c, u+4-*u, 4); c+=*u;}
356 dpd=(sourhi>>4)&0x3ff; /* declet 1 */
357 dpd2char;
358 dpd=((sourhi&0xf)<<6) | (sourmh>>26); /* declet 2 */
359 dpd2char;
360 dpd=(sourmh>>16)&0x3ff; /* declet 3 */
361 dpd2char;
362 dpd=(sourmh>>6)&0x3ff; /* declet 4 */
363 dpd2char;
364 dpd=((sourmh&0x3f)<<4) | (sourml>>28); /* declet 5 */
365 dpd2char;
366 dpd=(sourml>>18)&0x3ff; /* declet 6 */
367 dpd2char;
368 dpd=(sourml>>8)&0x3ff; /* declet 7 */
369 dpd2char;
370 dpd=((sourml&0xff)<<2) | (sourlo>>30); /* declet 8 */
371 dpd2char;
372 dpd=(sourlo>>20)&0x3ff; /* declet 9 */
373 dpd2char;
374 dpd=(sourlo>>10)&0x3ff; /* declet 10 */
375 dpd2char;
376 dpd=(sourlo)&0x3ff; /* declet 11 */
377 dpd2char;
378
379 if (c==cstart) *c++='0'; /* all zeros -- make 0 */
380
381 if (exp==0) { /* integer or NaN case -- easy */
382 *c='\0'; /* terminate */
383 return string;
384 }
385
386 /* non-0 exponent */
387 e=0; /* assume no E */
388 pre=c-cstart+exp;
389 /* [here, pre-exp is the digits count (==1 for zero)] */
390 if (exp>0 || pre<-5) { /* need exponential form */
391 e=pre-1; /* calculate E value */
392 pre=1; /* assume one digit before '.' */
393 } /* exponential form */
394
395 /* modify the coefficient, adding 0s, '.', and E+nn as needed */
396 s=c-1; /* source (LSD) */
397 if (pre>0) { /* ddd.ddd (plain), perhaps with E */
398 char *dotat=cstart+pre;
399 if (dotat<c) { /* if embedded dot needed... */
400 t=c; /* target */
401 for (; s>=dotat; s--, t--) *t=*s; /* open the gap; leave t at gap */
402 *t='.'; /* insert the dot */
403 c++; /* length increased by one */
404 }
405
406 /* finally add the E-part, if needed; it will never be 0, and has */
407 /* a maximum length of 4 digits */
408 if (e!=0) {
409 *c++='E'; /* starts with E */
410 *c++='+'; /* assume positive */
411 if (e<0) {
412 *(c-1)='-'; /* oops, need '-' */
413 e=-e; /* uInt, please */
414 }
415 if (e<1000) { /* 3 (or fewer) digits case */
416 u=&BIN2CHAR[e*4]; /* -> length byte */
417 memcpy(c, u+4-*u, 4); /* copy fixed 4 characters [is safe] */
418 c+=*u; /* bump pointer appropriately */
419 }
420 else { /* 4-digits */
421 Int thou=((e>>3)*1049)>>17; /* e/1000 */
422 Int rem=e-(1000*thou); /* e%1000 */
423 *c++='0'+(char)thou;
424 u=&BIN2CHAR[rem*4]; /* -> length byte */
425 memcpy(c, u+1, 4); /* copy fixed 3+1 characters [is safe] */
426 c+=3; /* bump pointer, always 3 digits */
427 }
428 }
429 *c='\0'; /* add terminator */
430 /*printf("res %s\n", string); */
431 return string;
432 } /* pre>0 */
433
434 /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
435 t=c+1-pre;
436 *(t+1)='\0'; /* can add terminator now */
437 for (; s>=cstart; s--, t--) *t=*s; /* shift whole coefficient right */
438 c=cstart;
439 *c++='0'; /* always starts with 0. */
440 *c++='.';
441 for (; pre<0; pre++) *c++='0'; /* add any 0's after '.' */
442 /*printf("res %s\n", string); */
443 return string;
444 } /* decimal128ToString */
445
446 /* ------------------------------------------------------------------ */
447 /* to-number -- conversion from numeric string */
448 /* */
449 /* decimal128FromString(result, string, set); */
450 /* */
451 /* result is the decimal128 format number which gets the result of */
452 /* the conversion */
453 /* *string is the character string which should contain a valid */
454 /* number (which may be a special value) */
455 /* set is the context */
456 /* */
457 /* The context is supplied to this routine is used for error handling */
458 /* (setting of status and traps) and for the rounding mode, only. */
459 /* If an error occurs, the result will be a valid decimal128 NaN. */
460 /* ------------------------------------------------------------------ */
461 decimal128 * decimal128FromString(decimal128 *result, const char *string,
462 decContext *set) {
463 decContext dc; /* work */
464 decNumber dn; /* .. */
465
466 decContextDefault(&dc, DEC_INIT_DECIMAL128); /* no traps, please */
467 dc.round=set->round; /* use supplied rounding */
468
469 decNumberFromString(&dn, string, &dc); /* will round if needed */
470 decimal128FromNumber(result, &dn, &dc);
471 if (dc.status!=0) { /* something happened */
472 decContextSetStatus(set, dc.status); /* .. pass it on */
473 }
474 return result;
475 } /* decimal128FromString */
476
477 /* ------------------------------------------------------------------ */
478 /* decimal128IsCanonical -- test whether encoding is canonical */
479 /* d128 is the source decimal128 */
480 /* returns 1 if the encoding of d128 is canonical, 0 otherwise */
481 /* No error is possible. */
482 /* ------------------------------------------------------------------ */
483 uint32_t decimal128IsCanonical(const decimal128 *d128) {
484 decNumber dn; /* work */
485 decimal128 canon; /* .. */
486 decContext dc; /* .. */
487 decContextDefault(&dc, DEC_INIT_DECIMAL128);
488 decimal128ToNumber(d128, &dn);
489 decimal128FromNumber(&canon, &dn, &dc);/* canon will now be canonical */
490 return memcmp(d128, &canon, DECIMAL128_Bytes)==0;
491 } /* decimal128IsCanonical */
492
493 /* ------------------------------------------------------------------ */
494 /* decimal128Canonical -- copy an encoding, ensuring it is canonical */
495 /* d128 is the source decimal128 */
496 /* result is the target (may be the same decimal128) */
497 /* returns result */
498 /* No error is possible. */
499 /* ------------------------------------------------------------------ */
500 decimal128 * decimal128Canonical(decimal128 *result, const decimal128 *d128) {
501 decNumber dn; /* work */
502 decContext dc; /* .. */
503 decContextDefault(&dc, DEC_INIT_DECIMAL128);
504 decimal128ToNumber(d128, &dn);
505 decimal128FromNumber(result, &dn, &dc);/* result will now be canonical */
506 return result;
507 } /* decimal128Canonical */
508
509 #if DECTRACE || DECCHECK
510 /* Macros for accessing decimal128 fields. These assume the argument
511 is a reference (pointer) to the decimal128 structure, and the
512 decimal128 is in network byte order (big-endian) */
513 /* Get sign */
514 #define decimal128Sign(d) ((unsigned)(d)->bytes[0]>>7)
515
516 /* Get combination field */
517 #define decimal128Comb(d) (((d)->bytes[0] & 0x7c)>>2)
518
519 /* Get exponent continuation [does not remove bias] */
520 #define decimal128ExpCon(d) ((((d)->bytes[0] & 0x03)<<10) \
521 | ((unsigned)(d)->bytes[1]<<2) \
522 | ((unsigned)(d)->bytes[2]>>6))
523
524 /* Set sign [this assumes sign previously 0] */
525 #define decimal128SetSign(d, b) { \
526 (d)->bytes[0]|=((unsigned)(b)<<7);}
527
528 /* Set exponent continuation [does not apply bias] */
529 /* This assumes range has been checked and exponent previously 0; */
530 /* type of exponent must be unsigned */
531 #define decimal128SetExpCon(d, e) { \
532 (d)->bytes[0]|=(uint8_t)((e)>>10); \
533 (d)->bytes[1] =(uint8_t)(((e)&0x3fc)>>2); \
534 (d)->bytes[2]|=(uint8_t)(((e)&0x03)<<6);}
535
536 /* ------------------------------------------------------------------ */
537 /* decimal128Show -- display a decimal128 in hexadecimal [debug aid] */
538 /* d128 -- the number to show */
539 /* ------------------------------------------------------------------ */
540 /* Also shows sign/cob/expconfields extracted */
541 void decimal128Show(const decimal128 *d128) {
542 char buf[DECIMAL128_Bytes*2+1];
543 Int i, j=0;
544
545 if (DECLITEND) {
546 for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
547 sprintf(&buf[j], "%02x", d128->bytes[15-i]);
548 }
549 printf(" D128> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
550 d128->bytes[15]>>7, (d128->bytes[15]>>2)&0x1f,
551 ((d128->bytes[15]&0x3)<<10)|(d128->bytes[14]<<2)|
552 (d128->bytes[13]>>6));
553 }
554 else {
555 for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
556 sprintf(&buf[j], "%02x", d128->bytes[i]);
557 }
558 printf(" D128> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
559 decimal128Sign(d128), decimal128Comb(d128),
560 decimal128ExpCon(d128));
561 }
562 } /* decimal128Show */
563 #endif