1/* Print floating point number in hexadecimal notation according to ISO C99.
2 Copyright (C) 1997-2022 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19#include <array_length.h>
20#include <ctype.h>
21#include <ieee754.h>
22#include <math.h>
23#include <printf.h>
24#include <stdlib.h>
25#include <stdio.h>
26#include <string.h>
27#include <wchar.h>
28#include <_itoa.h>
29#include <_itowa.h>
30#include <locale/localeinfo.h>
31#include <stdbool.h>
32#include <rounding-mode.h>
33
34#if __HAVE_DISTINCT_FLOAT128
35# include "ieee754_float128.h"
36# include <ldbl-128/printf_fphex_macros.h>
37# define PRINT_FPHEX_FLOAT128 \
38 PRINT_FPHEX (_Float128, fpnum.flt128, ieee854_float128, \
39 IEEE854_FLOAT128_BIAS)
40#endif
41
42/* #define NDEBUG 1*/ /* Undefine this for debugging assertions. */
43#include <assert.h>
44
45#include <libioP.h>
46#define PUT(f, s, n) _IO_sputn (f, s, n)
47#define PAD(f, c, n) (wide ? _IO_wpadn (f, c, n) : _IO_padn (f, c, n))
48#undef putc
49#define putc(c, f) (wide \
50 ? (int)_IO_putwc_unlocked (c, f) : _IO_putc_unlocked (c, f))
51
52
53/* Macros for doing the actual output. */
54
55#define outchar(ch) \
56 do \
57 { \
58 const int outc = (ch); \
59 if (putc (outc, fp) == EOF) \
60 return -1; \
61 ++done; \
62 } while (0)
63
64#define PRINT(ptr, wptr, len) \
65 do \
66 { \
67 size_t outlen = (len); \
68 if (wide) \
69 while (outlen-- > 0) \
70 outchar (*wptr++); \
71 else \
72 while (outlen-- > 0) \
73 outchar (*ptr++); \
74 } while (0)
75
76#define PADN(ch, len) \
77 do \
78 { \
79 if (PAD (fp, ch, len) != len) \
80 return -1; \
81 done += len; \
82 } \
83 while (0)
84
85#ifndef MIN
86# define MIN(a,b) ((a)<(b)?(a):(b))
87#endif
88
89
90int
91__printf_fphex (FILE *fp,
92 const struct printf_info *info,
93 const void *const *args)
94{
95 /* The floating-point value to output. */
96 union
97 {
98 union ieee754_double dbl;
99 long double ldbl;
100#if __HAVE_DISTINCT_FLOAT128
101 _Float128 flt128;
102#endif
103 }
104 fpnum;
105
106 /* This function always uses LC_NUMERIC. */
107 assert (info->extra == 0);
108
109 /* Locale-dependent representation of decimal point. Hexadecimal
110 formatting always using LC_NUMERIC (disregarding info->extra). */
111 const char *decimal = _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
112 wchar_t decimalwc = _NL_CURRENT_WORD (LC_NUMERIC,
113 _NL_NUMERIC_DECIMAL_POINT_WC);
114
115 /* The decimal point character must never be zero. */
116 assert (*decimal != '\0' && decimalwc != L'\0');
117
118 /* "NaN" or "Inf" for the special cases. */
119 const char *special = NULL;
120 const wchar_t *wspecial = NULL;
121
122 /* Buffer for the generated number string for the mantissa. The
123 maximal size for the mantissa is 128 bits. */
124 char numbuf[32];
125 char *numstr;
126 char *numend;
127 wchar_t wnumbuf[32];
128 wchar_t *wnumstr;
129 wchar_t *wnumend;
130 int negative;
131
132 /* The maximal exponent of two in decimal notation has 5 digits. */
133 char expbuf[5];
134 char *expstr;
135 wchar_t wexpbuf[5];
136 wchar_t *wexpstr;
137 int expnegative;
138 int exponent;
139
140 /* Non-zero is mantissa is zero. */
141 int zero_mantissa;
142
143 /* The leading digit before the decimal point. */
144 char leading;
145
146 /* Precision. */
147 int precision = info->prec;
148
149 /* Width. */
150 int width = info->width;
151
152 /* Number of characters written. */
153 int done = 0;
154
155 /* Nonzero if this is output on a wide character stream. */
156 int wide = info->wide;
157
158#define PRINTF_FPHEX_FETCH(FLOAT, VAR) \
159 { \
160 (VAR) = *(const FLOAT *) args[0]; \
161 \
162 /* Check for special values: not a number or infinity. */ \
163 if (isnan (VAR)) \
164 { \
165 if (isupper (info->spec)) \
166 { \
167 special = "NAN"; \
168 wspecial = L"NAN"; \
169 } \
170 else \
171 { \
172 special = "nan"; \
173 wspecial = L"nan"; \
174 } \
175 } \
176 else \
177 { \
178 if (isinf (VAR)) \
179 { \
180 if (isupper (info->spec)) \
181 { \
182 special = "INF"; \
183 wspecial = L"INF"; \
184 } \
185 else \
186 { \
187 special = "inf"; \
188 wspecial = L"inf"; \
189 } \
190 } \
191 } \
192 negative = signbit (VAR); \
193 }
194
195 /* Fetch the argument value. */
196#if __HAVE_DISTINCT_FLOAT128
197 if (info->is_binary128)
198 PRINTF_FPHEX_FETCH (_Float128, fpnum.flt128)
199 else
200#endif
201#ifndef __NO_LONG_DOUBLE_MATH
202 if (info->is_long_double && sizeof (long double) > sizeof (double))
203 PRINTF_FPHEX_FETCH (long double, fpnum.ldbl)
204 else
205#endif
206 PRINTF_FPHEX_FETCH (double, fpnum.dbl.d)
207
208#undef PRINTF_FPHEX_FETCH
209
210 if (special)
211 {
212 int width = info->width;
213
214 if (negative || info->showsign || info->space)
215 --width;
216 width -= 3;
217
218 if (!info->left && width > 0)
219 PADN (' ', width);
220
221 if (negative)
222 outchar ('-');
223 else if (info->showsign)
224 outchar ('+');
225 else if (info->space)
226 outchar (' ');
227
228 PRINT (special, wspecial, 3);
229
230 if (info->left && width > 0)
231 PADN (' ', width);
232
233 return done;
234 }
235
236#if __HAVE_DISTINCT_FLOAT128
237 if (info->is_binary128)
238 PRINT_FPHEX_FLOAT128;
239 else
240#endif
241 if (info->is_long_double == 0 || sizeof (double) == sizeof (long double))
242 {
243 /* We have 52 bits of mantissa plus one implicit digit. Since
244 52 bits are representable without rest using hexadecimal
245 digits we use only the implicit digits for the number before
246 the decimal point. */
247 unsigned long long int num;
248
249 num = (((unsigned long long int) fpnum.dbl.ieee.mantissa0) << 32
250 | fpnum.dbl.ieee.mantissa1);
251
252 zero_mantissa = num == 0;
253
254 if (sizeof (unsigned long int) > 6)
255 {
256 wnumstr = _itowa_word (num, wnumbuf + (sizeof wnumbuf) / sizeof (wchar_t), 16,
257 info->spec == 'A');
258 numstr = _itoa_word (num, numbuf + sizeof numbuf, 16,
259 info->spec == 'A');
260 }
261 else
262 {
263 wnumstr = _itowa (num, wnumbuf + sizeof wnumbuf / sizeof (wchar_t), 16,
264 info->spec == 'A');
265 numstr = _itoa (num, numbuf + sizeof numbuf, 16,
266 info->spec == 'A');
267 }
268
269 /* Fill with zeroes. */
270 while (wnumstr > wnumbuf + (sizeof wnumbuf - 52) / sizeof (wchar_t))
271 {
272 *--wnumstr = L'0';
273 *--numstr = '0';
274 }
275
276 leading = fpnum.dbl.ieee.exponent == 0 ? '0' : '1';
277
278 exponent = fpnum.dbl.ieee.exponent;
279
280 if (exponent == 0)
281 {
282 if (zero_mantissa)
283 expnegative = 0;
284 else
285 {
286 /* This is a denormalized number. */
287 expnegative = 1;
288 exponent = IEEE754_DOUBLE_BIAS - 1;
289 }
290 }
291 else if (exponent >= IEEE754_DOUBLE_BIAS)
292 {
293 expnegative = 0;
294 exponent -= IEEE754_DOUBLE_BIAS;
295 }
296 else
297 {
298 expnegative = 1;
299 exponent = -(exponent - IEEE754_DOUBLE_BIAS);
300 }
301 }
302#ifdef PRINT_FPHEX_LONG_DOUBLE
303 else
304 PRINT_FPHEX_LONG_DOUBLE;
305#endif
306
307 /* Look for trailing zeroes. */
308 if (! zero_mantissa)
309 {
310 wnumend = array_end (wnumbuf);
311 numend = array_end (numbuf);
312 while (wnumend[-1] == L'0')
313 {
314 --wnumend;
315 --numend;
316 }
317
318 bool do_round_away = false;
319
320 if (precision != -1 && precision < numend - numstr)
321 {
322 char last_digit = precision > 0 ? numstr[precision - 1] : leading;
323 char next_digit = numstr[precision];
324 int last_digit_value = (last_digit >= 'A' && last_digit <= 'F'
325 ? last_digit - 'A' + 10
326 : (last_digit >= 'a' && last_digit <= 'f'
327 ? last_digit - 'a' + 10
328 : last_digit - '0'));
329 int next_digit_value = (next_digit >= 'A' && next_digit <= 'F'
330 ? next_digit - 'A' + 10
331 : (next_digit >= 'a' && next_digit <= 'f'
332 ? next_digit - 'a' + 10
333 : next_digit - '0'));
334 bool more_bits = ((next_digit_value & 7) != 0
335 || precision + 1 < numend - numstr);
336 int rounding_mode = get_rounding_mode ();
337 do_round_away = round_away (negative, last_digit_value & 1,
338 next_digit_value >= 8, more_bits,
339 rounding_mode);
340 }
341
342 if (precision == -1)
343 precision = numend - numstr;
344 else if (do_round_away)
345 {
346 /* Round up. */
347 int cnt = precision;
348 while (--cnt >= 0)
349 {
350 char ch = numstr[cnt];
351 /* We assume that the digits and the letters are ordered
352 like in ASCII. This is true for the rest of GNU, too. */
353 if (ch == '9')
354 {
355 wnumstr[cnt] = (wchar_t) info->spec;
356 numstr[cnt] = info->spec; /* This is tricky,
357 think about it! */
358 break;
359 }
360 else if (tolower (ch) < 'f')
361 {
362 ++numstr[cnt];
363 ++wnumstr[cnt];
364 break;
365 }
366 else
367 {
368 numstr[cnt] = '0';
369 wnumstr[cnt] = L'0';
370 }
371 }
372 if (cnt < 0)
373 {
374 /* The mantissa so far was fff...f Now increment the
375 leading digit. Here it is again possible that we
376 get an overflow. */
377 if (leading == '9')
378 leading = info->spec;
379 else if (tolower (leading) < 'f')
380 ++leading;
381 else
382 {
383 leading = '1';
384 if (expnegative)
385 {
386 exponent -= 4;
387 if (exponent <= 0)
388 {
389 exponent = -exponent;
390 expnegative = 0;
391 }
392 }
393 else
394 exponent += 4;
395 }
396 }
397 }
398 }
399 else
400 {
401 if (precision == -1)
402 precision = 0;
403 numend = numstr;
404 wnumend = wnumstr;
405 }
406
407 /* Now we can compute the exponent string. */
408 expstr = _itoa_word (exponent, expbuf + sizeof expbuf, 10, 0);
409 wexpstr = _itowa_word (exponent,
410 wexpbuf + sizeof wexpbuf / sizeof (wchar_t), 10, 0);
411
412 /* Now we have all information to compute the size. */
413 width -= ((negative || info->showsign || info->space)
414 /* Sign. */
415 + 2 + 1 + 0 + precision + 1 + 1
416 /* 0x h . hhh P ExpoSign. */
417 + ((expbuf + sizeof expbuf) - expstr));
418 /* Exponent. */
419
420 /* Count the decimal point.
421 A special case when the mantissa or the precision is zero and the `#'
422 is not given. In this case we must not print the decimal point. */
423 if (precision > 0 || info->alt)
424 width -= wide ? 1 : strlen (decimal);
425
426 if (!info->left && info->pad != '0' && width > 0)
427 PADN (' ', width);
428
429 if (negative)
430 outchar ('-');
431 else if (info->showsign)
432 outchar ('+');
433 else if (info->space)
434 outchar (' ');
435
436 outchar ('0');
437 if ('X' - 'A' == 'x' - 'a')
438 outchar (info->spec + ('x' - 'a'));
439 else
440 outchar (info->spec == 'A' ? 'X' : 'x');
441
442 if (!info->left && info->pad == '0' && width > 0)
443 PADN ('0', width);
444
445 outchar (leading);
446
447 if (precision > 0 || info->alt)
448 {
449 const wchar_t *wtmp = &decimalwc;
450 PRINT (decimal, wtmp, wide ? 1 : strlen (decimal));
451 }
452
453 if (precision > 0)
454 {
455 ssize_t tofill = precision - (numend - numstr);
456 PRINT (numstr, wnumstr, MIN (numend - numstr, precision));
457 if (tofill > 0)
458 PADN ('0', tofill);
459 }
460
461 if ('P' - 'A' == 'p' - 'a')
462 outchar (info->spec + ('p' - 'a'));
463 else
464 outchar (info->spec == 'A' ? 'P' : 'p');
465
466 outchar (expnegative ? '-' : '+');
467
468 PRINT (expstr, wexpstr, (expbuf + sizeof expbuf) - expstr);
469
470 if (info->left && info->pad != '0' && width > 0)
471 PADN (info->pad, width);
472
473 return done;
474}
475