| /* Convert a floating-point number to string. |
| Copyright (C) 2016-2018 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| /* Generic implementation for strfrom functions. The implementation is generic |
| for several floating-point types (e.g.: float, double), so that each |
| function, such as strfromf and strfroml, share the same code, thus avoiding |
| code duplication. */ |
| |
| #include <ctype.h> |
| #include "../libio/libioP.h" |
| #include "../libio/strfile.h" |
| #include <printf.h> |
| #include <string.h> |
| #include <locale/localeinfo.h> |
| |
| #define UCHAR_T char |
| #define L_(Str) Str |
| #define ISDIGIT(Ch) isdigit (Ch) |
| #include "stdio-common/printf-parse.h" |
| |
| int |
| STRFROM (char *dest, size_t size, const char *format, FLOAT f) |
| { |
| _IO_strnfile sfile; |
| #ifdef _IO_MTSAFE_IO |
| sfile.f._sbf._f._lock = NULL; |
| #endif |
| |
| int done; |
| |
| /* Single-precision values need to be stored in a double type, because |
| __printf_fp_l and __printf_fphex do not accept the float type. */ |
| union { |
| double flt; |
| FLOAT value; |
| } fpnum; |
| const void *fpptr; |
| fpptr = &fpnum; |
| |
| /* Variables to control the output format. */ |
| int precision = -1; /* printf_fp and printf_fphex treat this internally. */ |
| int specifier; |
| struct printf_info info; |
| |
| /* Single-precision values need to be converted into double-precision, |
| because __printf_fp and __printf_fphex only accept double and long double |
| as the floating-point argument. */ |
| if (__builtin_types_compatible_p (FLOAT, float)) |
| fpnum.flt = f; |
| else |
| fpnum.value = f; |
| |
| /* Check if the first character in the format string is indeed the '%' |
| character. Otherwise, abort. */ |
| if (*format == '%') |
| format++; |
| else |
| abort (); |
| |
| /* The optional precision specification always starts with a '.'. If such |
| character is present, read the precision. */ |
| if (*format == '.') |
| { |
| format++; |
| |
| /* Parse the precision. */ |
| if (ISDIGIT (*format)) |
| precision = read_int (&format); |
| /* If only the period is specified, the precision is taken as zero, as |
| described in ISO/IEC 9899:2011, section 7.21.6.1, 4th paragraph, 3rd |
| item. */ |
| else |
| precision = 0; |
| } |
| |
| /* Now there is only the conversion specifier to be read. */ |
| switch (*format) |
| { |
| case 'a': |
| case 'A': |
| case 'e': |
| case 'E': |
| case 'f': |
| case 'F': |
| case 'g': |
| case 'G': |
| specifier = *format; |
| break; |
| default: |
| abort (); |
| } |
| |
| /* The following code to prepare the virtual file has been adapted from the |
| function _IO_vsnprintf from libio. */ |
| |
| if (size == 0) |
| { |
| /* When size is zero, nothing is written and dest may be a null pointer. |
| This is specified for snprintf in ISO/IEC 9899:2011, Section 7.21.6.5, |
| in the second paragraph. Thus, if size is zero, prepare to use the |
| overflow buffer right from the start. */ |
| dest = sfile.overflow_buf; |
| size = sizeof (sfile.overflow_buf); |
| } |
| |
| /* Prepare the virtual string file. */ |
| _IO_no_init (&sfile.f._sbf._f, _IO_USER_LOCK, -1, NULL, NULL); |
| _IO_JUMPS (&sfile.f._sbf) = &_IO_strn_jumps; |
| _IO_str_init_static_internal (&sfile.f, dest, size - 1, dest); |
| |
| /* Prepare the format specification for printf_fp. */ |
| memset (&info, '\0', sizeof (info)); |
| |
| /* The functions strfromd and strfromf pass a floating-point number with |
| double precision to printf_fp, whereas strfroml passes a floating-point |
| number with long double precision. The following line informs printf_fp |
| which type of floating-point number is being passed. */ |
| info.is_long_double = __builtin_types_compatible_p (FLOAT, long double); |
| |
| /* Similarly, the function strfromf128 passes a floating-point number in |
| _Float128 format to printf_fp. */ |
| #if __HAVE_DISTINCT_FLOAT128 |
| info.is_binary128 = __builtin_types_compatible_p (FLOAT, _Float128); |
| #endif |
| |
| /* Set info according to the format string. */ |
| info.prec = precision; |
| info.spec = specifier; |
| |
| if (info.spec != 'a' && info.spec != 'A') |
| done = __printf_fp_l (&sfile.f._sbf._f, _NL_CURRENT_LOCALE, &info, &fpptr); |
| else |
| done = __printf_fphex (&sfile.f._sbf._f, &info, &fpptr); |
| |
| /* Terminate the string. */ |
| if (sfile.f._sbf._f._IO_buf_base != sfile.overflow_buf) |
| *sfile.f._sbf._f._IO_write_ptr = '\0'; |
| |
| return done; |
| } |