1 /* *printf* family compatibility routines for IEEE double as long double
2 Copyright (C) 2006-2023 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 /* This file may define some of the deprecated scanf variants. */
20 #include <features.h>
21 #undef __GLIBC_USE_DEPRECATED_SCANF
22 #define __GLIBC_USE_DEPRECATED_SCANF 1
23
24 #include <argp.h>
25 #include <err.h>
26 #include <error.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <libio/strfile.h>
30 #include <math.h>
31 #include <wchar.h>
32 #include <printf.h>
33 #include <monetary.h>
34 #include <locale/localeinfo.h>
35 #include <sys/syslog.h>
36 #include <libc-lock.h>
37
38 #include "nldbl-compat.h"
39
40 libc_hidden_proto (__nldbl_vsscanf)
41 libc_hidden_proto (__nldbl_vfscanf)
42 libc_hidden_proto (__nldbl_vfwscanf)
43 libc_hidden_proto (__nldbl_vswscanf)
44 libc_hidden_proto (__nldbl___isoc99_vsscanf)
45 libc_hidden_proto (__nldbl___isoc99_vfscanf)
46 libc_hidden_proto (__nldbl___isoc99_vswscanf)
47 libc_hidden_proto (__nldbl___isoc99_vfwscanf)
48 libc_hidden_proto (__nldbl___isoc23_vsscanf)
49 libc_hidden_proto (__nldbl___isoc23_vfscanf)
50 libc_hidden_proto (__nldbl___isoc23_vswscanf)
51 libc_hidden_proto (__nldbl___isoc23_vfwscanf)
52
53 /* Compatibility with IEEE double as long double.
54 IEEE quad long double is used by default for most programs, so
55 we don't need to split this into one file per function for the
56 sake of statically linked programs. */
57
58 int
59 attribute_compat_text_section
60 __nldbl___asprintf (char **string_ptr, const char *fmt, ...)
61 {
62 va_list ap;
63 int ret;
64
65 va_start (ap, fmt);
66 ret = __vasprintf_internal (string_ptr, fmt, ap, PRINTF_LDBL_IS_DBL);
67 va_end (ap);
68
69 return ret;
70 }
71 weak_alias (__nldbl___asprintf, __nldbl_asprintf)
72
73 int
74 attribute_compat_text_section
75 __nldbl_dprintf (int d, const char *fmt, ...)
76 {
77 va_list ap;
78 int ret;
79
80 va_start (ap, fmt);
81 ret = __vdprintf_internal (d, fmt, ap, PRINTF_LDBL_IS_DBL);
82 va_end (ap);
83
84 return ret;
85 }
86
87 int
88 attribute_compat_text_section
89 __nldbl_fprintf (FILE *stream, const char *fmt, ...)
90 {
91 va_list ap;
92 int ret;
93
94 va_start (ap, fmt);
95 ret = __vfprintf_internal (stream, fmt, ap, PRINTF_LDBL_IS_DBL);
96 va_end (ap);
97
98 return ret;
99 }
100 weak_alias (__nldbl_fprintf, __nldbl__IO_fprintf)
101
102 int
103 attribute_compat_text_section weak_function
104 __nldbl_fwprintf (FILE *stream, const wchar_t *fmt, ...)
105 {
106 va_list ap;
107 int ret;
108
109 va_start (ap, fmt);
110 ret = __vfwprintf_internal (stream, fmt, ap, PRINTF_LDBL_IS_DBL);
111 va_end (ap);
112
113 return ret;
114 }
115
116 int
117 attribute_compat_text_section
118 __nldbl_printf (const char *fmt, ...)
119 {
120 va_list ap;
121 int ret;
122
123 va_start (ap, fmt);
124 ret = __vfprintf_internal (stdout, fmt, ap, PRINTF_LDBL_IS_DBL);
125 va_end (ap);
126
127 return ret;
128 }
129 strong_alias (__nldbl_printf, __nldbl__IO_printf)
130
131 int
132 attribute_compat_text_section
133 __nldbl_sprintf (char *s, const char *fmt, ...)
134 {
135 va_list ap;
136 int ret;
137
138 va_start (ap, fmt);
139 ret = __vsprintf_internal (s, -1, fmt, ap, PRINTF_LDBL_IS_DBL);
140 va_end (ap);
141
142 return ret;
143 }
144 strong_alias (__nldbl_sprintf, __nldbl__IO_sprintf)
145
146 int
147 attribute_compat_text_section
148 __nldbl_vfprintf (FILE *s, const char *fmt, va_list ap)
149 {
150 return __vfprintf_internal (s, fmt, ap, PRINTF_LDBL_IS_DBL);
151 }
152 strong_alias (__nldbl_vfprintf, __nldbl__IO_vfprintf)
153
154 int
155 attribute_compat_text_section
156 __nldbl___vsprintf (char *string, const char *fmt, va_list ap)
157 {
158 return __vsprintf_internal (string, -1, fmt, ap, PRINTF_LDBL_IS_DBL);
159 }
160 strong_alias (__nldbl___vsprintf, __nldbl__IO_vsprintf)
161 weak_alias (__nldbl___vsprintf, __nldbl_vsprintf)
162
163 int
164 attribute_compat_text_section
165 __nldbl_obstack_vprintf (struct obstack *obstack, const char *fmt,
166 va_list ap)
167 {
168 return __obstack_vprintf_internal (obstack, fmt, ap, PRINTF_LDBL_IS_DBL);
169 }
170
171 int
172 attribute_compat_text_section
173 __nldbl_obstack_printf (struct obstack *obstack, const char *fmt, ...)
174 {
175 int ret;
176 va_list ap;
177 va_start (ap, fmt);
178 ret = __obstack_vprintf_internal (obstack, fmt, ap, PRINTF_LDBL_IS_DBL);
179 va_end (ap);
180 return ret;
181 }
182
183 int
184 attribute_compat_text_section weak_function
185 __nldbl_snprintf (char *s, size_t maxlen, const char *fmt, ...)
186 {
187 va_list ap;
188 int ret;
189
190 va_start (ap, fmt);
191 ret = __vsnprintf_internal (s, maxlen, fmt, ap, PRINTF_LDBL_IS_DBL);
192 va_end (ap);
193
194 return ret;
195 }
196
197 int
198 attribute_compat_text_section
199 __nldbl_swprintf (wchar_t *s, size_t n, const wchar_t *fmt, ...)
200 {
201 va_list ap;
202 int ret;
203
204 va_start (ap, fmt);
205 ret = __vswprintf_internal (s, n, fmt, ap, PRINTF_LDBL_IS_DBL);
206 va_end (ap);
207
208 return ret;
209 }
210
211 int
212 attribute_compat_text_section weak_function
213 __nldbl_vasprintf (char **result_ptr, const char *fmt, va_list ap)
214 {
215 return __vasprintf_internal (result_ptr, fmt, ap, PRINTF_LDBL_IS_DBL);
216 }
217
218 int
219 attribute_compat_text_section
220 __nldbl_vdprintf (int d, const char *fmt, va_list ap)
221 {
222 return __vdprintf_internal (d, fmt, ap, PRINTF_LDBL_IS_DBL);
223 }
224
225 int
226 attribute_compat_text_section weak_function
227 __nldbl_vfwprintf (FILE *s, const wchar_t *fmt, va_list ap)
228 {
229 return __vfwprintf_internal (s, fmt, ap, PRINTF_LDBL_IS_DBL);
230 }
231
232 int
233 attribute_compat_text_section
234 __nldbl_vprintf (const char *fmt, va_list ap)
235 {
236 return __vfprintf_internal (stdout, fmt, ap, PRINTF_LDBL_IS_DBL);
237 }
238
239 int
240 attribute_compat_text_section
241 __nldbl_vsnprintf (char *string, size_t maxlen, const char *fmt,
242 va_list ap)
243 {
244 return __vsnprintf_internal (string, maxlen, fmt, ap, PRINTF_LDBL_IS_DBL);
245 }
246 weak_alias (__nldbl_vsnprintf, __nldbl___vsnprintf)
247
248 int
249 attribute_compat_text_section weak_function
250 __nldbl_vswprintf (wchar_t *string, size_t maxlen, const wchar_t *fmt,
251 va_list ap)
252 {
253 return __vswprintf_internal (string, maxlen, fmt, ap, PRINTF_LDBL_IS_DBL);
254 }
255
256 int
257 attribute_compat_text_section
258 __nldbl_vwprintf (const wchar_t *fmt, va_list ap)
259 {
260 return __vfwprintf_internal (stdout, fmt, ap, PRINTF_LDBL_IS_DBL);
261 }
262
263 int
264 attribute_compat_text_section
265 __nldbl_wprintf (const wchar_t *fmt, ...)
266 {
267 va_list ap;
268 int ret;
269
270 va_start (ap, fmt);
271 ret = __vfwprintf_internal (stdout, fmt, ap, PRINTF_LDBL_IS_DBL);
272 va_end (ap);
273
274 return ret;
275 }
276
277 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_29)
278 int
279 attribute_compat_text_section
280 __nldbl__IO_vfscanf (FILE *s, const char *fmt, va_list ap, int *errp)
281 {
282 int ret = __vfscanf_internal (s, fmt, ap, SCANF_LDBL_IS_DBL);
283 if (__glibc_unlikely (errp != 0))
284 *errp = (ret == -1);
285 return ret;
286 }
287 #endif
288
289 int
290 attribute_compat_text_section
291 __nldbl___vfscanf (FILE *s, const char *fmt, va_list ap)
292 {
293 return __vfscanf_internal (s, fmt, ap, SCANF_LDBL_IS_DBL);
294 }
295 weak_alias (__nldbl___vfscanf, __nldbl_vfscanf)
296 libc_hidden_def (__nldbl_vfscanf)
297
298 int
299 attribute_compat_text_section
300 __nldbl_sscanf (const char *s, const char *fmt, ...)
301 {
302 _IO_strfile sf;
303 FILE *f = _IO_strfile_read (&sf, s);
304 va_list ap;
305 int ret;
306
307 va_start (ap, fmt);
308 ret = __vfscanf_internal (f, fmt, ap, SCANF_LDBL_IS_DBL);
309 va_end (ap);
310
311 return ret;
312 }
313 strong_alias (__nldbl_sscanf, __nldbl__IO_sscanf)
314
315 int
316 attribute_compat_text_section
317 __nldbl___vsscanf (const char *s, const char *fmt, va_list ap)
318 {
319 _IO_strfile sf;
320 FILE *f = _IO_strfile_read (&sf, s);
321 return __vfscanf_internal (f, fmt, ap, SCANF_LDBL_IS_DBL);
322 }
323 weak_alias (__nldbl___vsscanf, __nldbl_vsscanf)
324 libc_hidden_def (__nldbl_vsscanf)
325
326 int
327 attribute_compat_text_section weak_function
328 __nldbl_vscanf (const char *fmt, va_list ap)
329 {
330 return __vfscanf_internal (stdin, fmt, ap, SCANF_LDBL_IS_DBL);
331 }
332
333 int
334 attribute_compat_text_section
335 __nldbl_fscanf (FILE *stream, const char *fmt, ...)
336 {
337 va_list ap;
338 int ret;
339
340 va_start (ap, fmt);
341 ret = __vfscanf_internal (stream, fmt, ap, SCANF_LDBL_IS_DBL);
342 va_end (ap);
343
344 return ret;
345 }
346
347 int
348 attribute_compat_text_section
349 __nldbl_scanf (const char *fmt, ...)
350 {
351 va_list ap;
352 int ret;
353
354 va_start (ap, fmt);
355 ret = __vfscanf_internal (stdin, fmt, ap, SCANF_LDBL_IS_DBL);
356 va_end (ap);
357
358 return ret;
359 }
360
361 int
362 attribute_compat_text_section
363 __nldbl_vfwscanf (FILE *s, const wchar_t *fmt, va_list ap)
364 {
365 return __vfwscanf_internal (s, fmt, ap, SCANF_LDBL_IS_DBL);
366 }
367 libc_hidden_def (__nldbl_vfwscanf)
368
369 int
370 attribute_compat_text_section
371 __nldbl_swscanf (const wchar_t *s, const wchar_t *fmt, ...)
372 {
373 _IO_strfile sf;
374 struct _IO_wide_data wd;
375 FILE *f = _IO_strfile_readw (&sf, &wd, s);
376 va_list ap;
377 int ret;
378
379 va_start (ap, fmt);
380 ret = __vfwscanf_internal (f, fmt, ap, SCANF_LDBL_IS_DBL);
381 va_end (ap);
382
383 return ret;
384 }
385
386 int
387 attribute_compat_text_section
388 __nldbl_vswscanf (const wchar_t *s, const wchar_t *fmt, va_list ap)
389 {
390 _IO_strfile sf;
391 struct _IO_wide_data wd;
392 FILE *f = _IO_strfile_readw (&sf, &wd, s);
393
394 return __vfwscanf_internal (f, fmt, ap, SCANF_LDBL_IS_DBL);
395 }
396 libc_hidden_def (__nldbl_vswscanf)
397
398 int
399 attribute_compat_text_section weak_function
400 __nldbl_vwscanf (const wchar_t *fmt, va_list ap)
401 {
402 return __vfwscanf_internal (stdin, fmt, ap, SCANF_LDBL_IS_DBL);
403 }
404
405 int
406 attribute_compat_text_section
407 __nldbl_fwscanf (FILE *stream, const wchar_t *fmt, ...)
408 {
409 va_list ap;
410 int ret;
411
412 va_start (ap, fmt);
413 ret = __vfwscanf_internal (stream, fmt, ap, SCANF_LDBL_IS_DBL);
414 va_end (ap);
415
416 return ret;
417 }
418
419 int
420 attribute_compat_text_section
421 __nldbl_wscanf (const wchar_t *fmt, ...)
422 {
423 va_list ap;
424 int ret;
425
426 va_start (ap, fmt);
427 ret = __vfwscanf_internal (stdin, fmt, ap, SCANF_LDBL_IS_DBL);
428 va_end (ap);
429
430 return ret;
431 }
432
433 int
434 attribute_compat_text_section
435 __nldbl___fprintf_chk (FILE *stream, int flag, const char *fmt, ...)
436 {
437 va_list ap;
438 int ret;
439 unsigned int mode = PRINTF_LDBL_IS_DBL;
440 if (flag > 0)
441 mode |= PRINTF_FORTIFY;
442
443 va_start (ap, fmt);
444 ret = __vfprintf_internal (stream, fmt, ap, mode);
445 va_end (ap);
446
447 return ret;
448 }
449
450 int
451 attribute_compat_text_section
452 __nldbl___fwprintf_chk (FILE *stream, int flag, const wchar_t *fmt, ...)
453 {
454 va_list ap;
455 int ret;
456 unsigned int mode = PRINTF_LDBL_IS_DBL;
457 if (flag > 0)
458 mode |= PRINTF_FORTIFY;
459
460 va_start (ap, fmt);
461 ret = __vfwprintf_internal (stream, fmt, ap, mode);
462 va_end (ap);
463
464 return ret;
465 }
466
467 int
468 attribute_compat_text_section
469 __nldbl___printf_chk (int flag, const char *fmt, ...)
470 {
471 va_list ap;
472 int ret;
473 unsigned int mode = PRINTF_LDBL_IS_DBL;
474 if (flag > 0)
475 mode |= PRINTF_FORTIFY;
476
477 va_start (ap, fmt);
478 ret = __vfprintf_internal (stdout, fmt, ap, mode);
479 va_end (ap);
480
481 return ret;
482 }
483
484 int
485 attribute_compat_text_section
486 __nldbl___snprintf_chk (char *s, size_t maxlen, int flag, size_t slen,
487 const char *fmt, ...)
488 {
489 if (__glibc_unlikely (slen < maxlen))
490 __chk_fail ();
491
492 va_list ap;
493 int ret;
494 unsigned int mode = PRINTF_LDBL_IS_DBL;
495 if (flag > 0)
496 mode |= PRINTF_FORTIFY;
497
498 va_start (ap, fmt);
499 ret = __vsnprintf_internal (s, maxlen, fmt, ap, mode);
500 va_end (ap);
501
502 return ret;
503 }
504
505 int
506 attribute_compat_text_section
507 __nldbl___sprintf_chk (char *s, int flag, size_t slen, const char *fmt, ...)
508 {
509 if (slen == 0)
510 __chk_fail ();
511
512 va_list ap;
513 int ret;
514 unsigned int mode = PRINTF_LDBL_IS_DBL;
515 if (flag > 0)
516 mode |= PRINTF_FORTIFY;
517
518 va_start (ap, fmt);
519 ret = __vsprintf_internal (s, slen, fmt, ap, mode);
520 va_end (ap);
521
522 return ret;
523 }
524
525 int
526 attribute_compat_text_section
527 __nldbl___swprintf_chk (wchar_t *s, size_t maxlen, int flag, size_t slen,
528 const wchar_t *fmt, ...)
529 {
530 if (__glibc_unlikely (slen < maxlen))
531 __chk_fail ();
532
533 va_list ap;
534 int ret;
535 unsigned int mode = PRINTF_LDBL_IS_DBL;
536 if (flag > 0)
537 mode |= PRINTF_FORTIFY;
538
539 va_start (ap, fmt);
540 ret = __vswprintf_internal (s, maxlen, fmt, ap, mode);
541 va_end (ap);
542
543 return ret;
544 }
545
546 int
547 attribute_compat_text_section
548 __nldbl___vfprintf_chk (FILE *s, int flag, const char *fmt, va_list ap)
549 {
550 unsigned int mode = PRINTF_LDBL_IS_DBL;
551 if (flag > 0)
552 mode |= PRINTF_FORTIFY;
553
554 return __vfprintf_internal (s, fmt, ap, mode);
555 }
556
557 int
558 attribute_compat_text_section
559 __nldbl___vfwprintf_chk (FILE *s, int flag, const wchar_t *fmt, va_list ap)
560 {
561 unsigned int mode = PRINTF_LDBL_IS_DBL;
562 if (flag > 0)
563 mode |= PRINTF_FORTIFY;
564
565 return __vfwprintf_internal (s, fmt, ap, mode);
566 }
567
568 int
569 attribute_compat_text_section
570 __nldbl___vprintf_chk (int flag, const char *fmt, va_list ap)
571 {
572 unsigned int mode = PRINTF_LDBL_IS_DBL;
573 if (flag > 0)
574 mode |= PRINTF_FORTIFY;
575
576 return __vfprintf_internal (stdout, fmt, ap, mode);
577 }
578
579 int
580 attribute_compat_text_section
581 __nldbl___vsnprintf_chk (char *string, size_t maxlen, int flag, size_t slen,
582 const char *fmt, va_list ap)
583 {
584 if (__glibc_unlikely (slen < maxlen))
585 __chk_fail ();
586
587 unsigned int mode = PRINTF_LDBL_IS_DBL;
588 if (flag > 0)
589 mode |= PRINTF_FORTIFY;
590
591 return __vsnprintf_internal (string, maxlen, fmt, ap, mode);
592 }
593
594 int
595 attribute_compat_text_section
596 __nldbl___vsprintf_chk (char *string, int flag, size_t slen, const char *fmt,
597 va_list ap)
598 {
599 if (slen == 0)
600 __chk_fail ();
601
602 unsigned int mode = PRINTF_LDBL_IS_DBL;
603 if (flag > 0)
604 mode |= PRINTF_FORTIFY;
605
606 return __vsprintf_internal (string, slen, fmt, ap, mode);
607 }
608
609 int
610 attribute_compat_text_section
611 __nldbl___vswprintf_chk (wchar_t *string, size_t maxlen, int flag, size_t slen,
612 const wchar_t *fmt, va_list ap)
613 {
614 if (__glibc_unlikely (slen < maxlen))
615 __chk_fail ();
616
617 unsigned int mode = PRINTF_LDBL_IS_DBL;
618 if (flag > 0)
619 mode |= PRINTF_FORTIFY;
620
621 return __vswprintf_internal (string, maxlen, fmt, ap, mode);
622 }
623
624 int
625 attribute_compat_text_section
626 __nldbl___vwprintf_chk (int flag, const wchar_t *fmt, va_list ap)
627 {
628 unsigned int mode = PRINTF_LDBL_IS_DBL;
629 if (flag > 0)
630 mode |= PRINTF_FORTIFY;
631
632 return __vfwprintf_internal (stdout, fmt, ap, mode);
633 }
634
635 int
636 attribute_compat_text_section
637 __nldbl___wprintf_chk (int flag, const wchar_t *fmt, ...)
638 {
639 va_list ap;
640 int ret;
641 unsigned int mode = PRINTF_LDBL_IS_DBL;
642 if (flag > 0)
643 mode |= PRINTF_FORTIFY;
644
645 va_start (ap, fmt);
646 ret = __vfwprintf_internal (stdout, fmt, ap, mode);
647 va_end (ap);
648
649 return ret;
650 }
651
652 int
653 attribute_compat_text_section
654 __nldbl___vasprintf_chk (char **ptr, int flag, const char *fmt, va_list ap)
655 {
656 unsigned int mode = PRINTF_LDBL_IS_DBL;
657 if (flag > 0)
658 mode |= PRINTF_FORTIFY;
659
660 return __vasprintf_internal (ptr, fmt, ap, mode);
661 }
662
663 int
664 attribute_compat_text_section
665 __nldbl___asprintf_chk (char **ptr, int flag, const char *fmt, ...)
666 {
667 va_list ap;
668 int ret;
669 unsigned int mode = PRINTF_LDBL_IS_DBL;
670 if (flag > 0)
671 mode |= PRINTF_FORTIFY;
672
673 va_start (ap, fmt);
674 ret = __vasprintf_internal (ptr, fmt, ap, mode);
675 va_end (ap);
676
677 return ret;
678 }
679
680 int
681 attribute_compat_text_section
682 __nldbl___vdprintf_chk (int d, int flag, const char *fmt, va_list ap)
683 {
684 unsigned int mode = PRINTF_LDBL_IS_DBL;
685 if (flag > 0)
686 mode |= PRINTF_FORTIFY;
687
688 return __vdprintf_internal (d, fmt, ap, mode);
689 }
690
691 int
692 attribute_compat_text_section
693 __nldbl___dprintf_chk (int d, int flag, const char *fmt, ...)
694 {
695 va_list ap;
696 int ret;
697 unsigned int mode = PRINTF_LDBL_IS_DBL;
698 if (flag > 0)
699 mode |= PRINTF_FORTIFY;
700
701 va_start (ap, fmt);
702 ret = __vdprintf_internal (d, fmt, ap, mode);
703 va_end (ap);
704
705 return ret;
706 }
707
708 int
709 attribute_compat_text_section
710 __nldbl___obstack_vprintf_chk (struct obstack *obstack, int flag,
711 const char *fmt, va_list ap)
712 {
713 unsigned int mode = PRINTF_LDBL_IS_DBL;
714 if (flag > 0)
715 mode |= PRINTF_FORTIFY;
716
717 return __obstack_vprintf_internal (obstack, fmt, ap, mode);
718 }
719
720 int
721 attribute_compat_text_section
722 __nldbl___obstack_printf_chk (struct obstack *obstack, int flag,
723 const char *fmt, ...)
724 {
725 va_list ap;
726 int ret;
727 unsigned int mode = PRINTF_LDBL_IS_DBL;
728 if (flag > 0)
729 mode |= PRINTF_FORTIFY;
730
731 va_start (ap, fmt);
732 ret = __obstack_vprintf_internal (obstack, fmt, ap, mode);
733 va_end (ap);
734
735 return ret;
736 }
737
738 extern __typeof (printf_size) __printf_size;
739
740 int
741 attribute_compat_text_section
742 __nldbl_printf_size (FILE *fp, const struct printf_info *info,
743 const void *const *args)
744 {
745 struct printf_info info_no_ldbl = *info;
746
747 info_no_ldbl.is_long_double = 0;
748 return __printf_size (fp, &info_no_ldbl, args);
749 }
750
751 extern __typeof (__printf_fp) ___printf_fp;
752
753 int
754 attribute_compat_text_section
755 __nldbl___printf_fp (FILE *fp, const struct printf_info *info,
756 const void *const *args)
757 {
758 struct printf_info info_no_ldbl = *info;
759
760 info_no_ldbl.is_long_double = 0;
761 return ___printf_fp (fp, &info_no_ldbl, args);
762 }
763
764 ssize_t
765 attribute_compat_text_section
766 __nldbl_strfmon (char *s, size_t maxsize, const char *format, ...)
767 {
768 va_list ap;
769 ssize_t ret;
770
771 va_start (ap, format);
772 ret = __vstrfmon_l_internal (s, maxsize, _NL_CURRENT_LOCALE, format, ap,
773 STRFMON_LDBL_IS_DBL);
774 va_end (ap);
775 return ret;
776 }
777
778 ssize_t
779 attribute_compat_text_section
780 __nldbl___strfmon_l (char *s, size_t maxsize, locale_t loc,
781 const char *format, ...)
782 {
783 va_list ap;
784 ssize_t ret;
785
786 va_start (ap, format);
787 ret = __vstrfmon_l_internal (s, maxsize, loc, format, ap,
788 STRFMON_LDBL_IS_DBL);
789 va_end (ap);
790 return ret;
791 }
792 weak_alias (__nldbl___strfmon_l, __nldbl_strfmon_l)
793
794 ssize_t
795 attribute_compat_text_section
796 __nldbl___vstrfmon (char *s, size_t maxsize, const char *format, va_list ap)
797 {
798 return __vstrfmon_l_internal (s, maxsize, _NL_CURRENT_LOCALE, format, ap,
799 STRFMON_LDBL_IS_DBL);
800 }
801
802 ssize_t
803 attribute_compat_text_section
804 __nldbl___vstrfmon_l (char *s, size_t maxsize, locale_t loc,
805 const char *format, va_list ap)
806 {
807 return __vstrfmon_l_internal (s, maxsize, loc, format, ap,
808 STRFMON_LDBL_IS_DBL);
809 }
810
811 void
812 attribute_compat_text_section
813 __nldbl_syslog (int pri, const char *fmt, ...)
814 {
815 va_list ap;
816 va_start (ap, fmt);
817 __vsyslog_internal (pri, fmt, ap, PRINTF_LDBL_IS_DBL);
818 va_end (ap);
819 }
820
821 void
822 attribute_compat_text_section
823 __nldbl_vsyslog (int pri, const char *fmt, va_list ap)
824 {
825 __vsyslog_internal (pri, fmt, ap, PRINTF_LDBL_IS_DBL);
826 }
827
828 void
829 attribute_compat_text_section
830 __nldbl___syslog_chk (int pri, int flag, const char *fmt, ...)
831 {
832 va_list ap;
833 unsigned int mode = PRINTF_LDBL_IS_DBL;
834 if (flag > 0)
835 mode |= PRINTF_FORTIFY;
836
837 va_start (ap, fmt);
838 __vsyslog_internal (pri, fmt, ap, mode);
839 va_end(ap);
840 }
841
842 void
843 attribute_compat_text_section
844 __nldbl___vsyslog_chk (int pri, int flag, const char *fmt, va_list ap)
845 {
846 unsigned int mode = PRINTF_LDBL_IS_DBL;
847 if (flag > 0)
848 mode |= PRINTF_FORTIFY;
849
850 __vsyslog_internal (pri, fmt, ap, mode);
851 }
852
853 int
854 attribute_compat_text_section
855 __nldbl___isoc99_vfscanf (FILE *s, const char *fmt, va_list ap)
856 {
857 return __vfscanf_internal (s, fmt, ap, SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
858 }
859 libc_hidden_def (__nldbl___isoc99_vfscanf)
860
861 int
862 attribute_compat_text_section
863 __nldbl___isoc99_sscanf (const char *s, const char *fmt, ...)
864 {
865 _IO_strfile sf;
866 FILE *f = _IO_strfile_read (&sf, s);
867 va_list ap;
868 int ret;
869
870 va_start (ap, fmt);
871 ret = __vfscanf_internal (f, fmt, ap, SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
872 va_end (ap);
873
874 return ret;
875 }
876
877 int
878 attribute_compat_text_section
879 __nldbl___isoc99_vsscanf (const char *s, const char *fmt, va_list ap)
880 {
881 _IO_strfile sf;
882 FILE *f = _IO_strfile_read (&sf, s);
883
884 return __vfscanf_internal (f, fmt, ap, SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
885 }
886 libc_hidden_def (__nldbl___isoc99_vsscanf)
887
888 int
889 attribute_compat_text_section
890 __nldbl___isoc99_vscanf (const char *fmt, va_list ap)
891 {
892 return __vfscanf_internal (stdin, fmt, ap,
893 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
894 }
895
896 int
897 attribute_compat_text_section
898 __nldbl___isoc99_fscanf (FILE *s, const char *fmt, ...)
899 {
900 va_list ap;
901 int ret;
902
903 va_start (ap, fmt);
904 ret = __vfscanf_internal (s, fmt, ap, SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
905 va_end (ap);
906
907 return ret;
908 }
909
910 int
911 attribute_compat_text_section
912 __nldbl___isoc99_scanf (const char *fmt, ...)
913 {
914 va_list ap;
915 int ret;
916
917 va_start (ap, fmt);
918 ret = __vfscanf_internal (stdin, fmt, ap,
919 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
920 va_end (ap);
921
922 return ret;
923 }
924
925 int
926 attribute_compat_text_section
927 __nldbl___isoc99_vfwscanf (FILE *s, const wchar_t *fmt, va_list ap)
928 {
929 return __vfwscanf_internal (s, fmt, ap, SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
930 }
931 libc_hidden_def (__nldbl___isoc99_vfwscanf)
932
933 int
934 attribute_compat_text_section
935 __nldbl___isoc99_swscanf (const wchar_t *s, const wchar_t *fmt, ...)
936 {
937 _IO_strfile sf;
938 struct _IO_wide_data wd;
939 FILE *f = _IO_strfile_readw (&sf, &wd, s);
940 va_list ap;
941 int ret;
942
943 va_start (ap, fmt);
944 ret = __vfwscanf_internal (f, fmt, ap, SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
945 va_end (ap);
946
947 return ret;
948 }
949
950 int
951 attribute_compat_text_section
952 __nldbl___isoc99_vswscanf (const wchar_t *s, const wchar_t *fmt, va_list ap)
953 {
954 _IO_strfile sf;
955 struct _IO_wide_data wd;
956 FILE *f = _IO_strfile_readw (&sf, &wd, s);
957
958 return __vfwscanf_internal (f, fmt, ap, SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
959 }
960 libc_hidden_def (__nldbl___isoc99_vswscanf)
961
962 int
963 attribute_compat_text_section
964 __nldbl___isoc99_vwscanf (const wchar_t *fmt, va_list ap)
965 {
966 return __vfwscanf_internal (stdin, fmt, ap,
967 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
968 }
969
970 int
971 attribute_compat_text_section
972 __nldbl___isoc99_fwscanf (FILE *s, const wchar_t *fmt, ...)
973 {
974 va_list ap;
975 int ret;
976
977 va_start (ap, fmt);
978 ret = __vfwscanf_internal (s, fmt, ap, SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
979 va_end (ap);
980
981 return ret;
982 }
983
984 int
985 attribute_compat_text_section
986 __nldbl___isoc99_wscanf (const wchar_t *fmt, ...)
987 {
988 va_list ap;
989 int ret;
990
991 va_start (ap, fmt);
992 ret = __vfwscanf_internal (stdin, fmt, ap,
993 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A);
994 va_end (ap);
995
996 return ret;
997 }
998
999 int
1000 attribute_compat_text_section
1001 __nldbl___isoc23_vfscanf (FILE *s, const char *fmt, va_list ap)
1002 {
1003 return __vfscanf_internal (s, fmt, ap,
1004 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1005 | SCANF_ISOC23_BIN_CST);
1006 }
1007 libc_hidden_def (__nldbl___isoc23_vfscanf)
1008
1009 int
1010 attribute_compat_text_section
1011 __nldbl___isoc23_sscanf (const char *s, const char *fmt, ...)
1012 {
1013 _IO_strfile sf;
1014 FILE *f = _IO_strfile_read (&sf, s);
1015 va_list ap;
1016 int ret;
1017
1018 va_start (ap, fmt);
1019 ret = __vfscanf_internal (f, fmt, ap,
1020 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1021 | SCANF_ISOC23_BIN_CST);
1022 va_end (ap);
1023
1024 return ret;
1025 }
1026
1027 int
1028 attribute_compat_text_section
1029 __nldbl___isoc23_vsscanf (const char *s, const char *fmt, va_list ap)
1030 {
1031 _IO_strfile sf;
1032 FILE *f = _IO_strfile_read (&sf, s);
1033
1034 return __vfscanf_internal (f, fmt, ap,
1035 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1036 | SCANF_ISOC23_BIN_CST);
1037 }
1038 libc_hidden_def (__nldbl___isoc23_vsscanf)
1039
1040 int
1041 attribute_compat_text_section
1042 __nldbl___isoc23_vscanf (const char *fmt, va_list ap)
1043 {
1044 return __vfscanf_internal (stdin, fmt, ap,
1045 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1046 | SCANF_ISOC23_BIN_CST);
1047 }
1048
1049 int
1050 attribute_compat_text_section
1051 __nldbl___isoc23_fscanf (FILE *s, const char *fmt, ...)
1052 {
1053 va_list ap;
1054 int ret;
1055
1056 va_start (ap, fmt);
1057 ret = __vfscanf_internal (s, fmt, ap,
1058 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1059 | SCANF_ISOC23_BIN_CST);
1060 va_end (ap);
1061
1062 return ret;
1063 }
1064
1065 int
1066 attribute_compat_text_section
1067 __nldbl___isoc23_scanf (const char *fmt, ...)
1068 {
1069 va_list ap;
1070 int ret;
1071
1072 va_start (ap, fmt);
1073 ret = __vfscanf_internal (stdin, fmt, ap,
1074 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1075 | SCANF_ISOC23_BIN_CST);
1076 va_end (ap);
1077
1078 return ret;
1079 }
1080
1081 int
1082 attribute_compat_text_section
1083 __nldbl___isoc23_vfwscanf (FILE *s, const wchar_t *fmt, va_list ap)
1084 {
1085 return __vfwscanf_internal (s, fmt, ap,
1086 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1087 | SCANF_ISOC23_BIN_CST);
1088 }
1089 libc_hidden_def (__nldbl___isoc23_vfwscanf)
1090
1091 int
1092 attribute_compat_text_section
1093 __nldbl___isoc23_swscanf (const wchar_t *s, const wchar_t *fmt, ...)
1094 {
1095 _IO_strfile sf;
1096 struct _IO_wide_data wd;
1097 FILE *f = _IO_strfile_readw (&sf, &wd, s);
1098 va_list ap;
1099 int ret;
1100
1101 va_start (ap, fmt);
1102 ret = __vfwscanf_internal (f, fmt, ap,
1103 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1104 | SCANF_ISOC23_BIN_CST);
1105 va_end (ap);
1106
1107 return ret;
1108 }
1109
1110 int
1111 attribute_compat_text_section
1112 __nldbl___isoc23_vswscanf (const wchar_t *s, const wchar_t *fmt, va_list ap)
1113 {
1114 _IO_strfile sf;
1115 struct _IO_wide_data wd;
1116 FILE *f = _IO_strfile_readw (&sf, &wd, s);
1117
1118 return __vfwscanf_internal (f, fmt, ap,
1119 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1120 | SCANF_ISOC23_BIN_CST);
1121 }
1122 libc_hidden_def (__nldbl___isoc23_vswscanf)
1123
1124 int
1125 attribute_compat_text_section
1126 __nldbl___isoc23_vwscanf (const wchar_t *fmt, va_list ap)
1127 {
1128 return __vfwscanf_internal (stdin, fmt, ap,
1129 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1130 | SCANF_ISOC23_BIN_CST);
1131 }
1132
1133 int
1134 attribute_compat_text_section
1135 __nldbl___isoc23_fwscanf (FILE *s, const wchar_t *fmt, ...)
1136 {
1137 va_list ap;
1138 int ret;
1139
1140 va_start (ap, fmt);
1141 ret = __vfwscanf_internal (s, fmt, ap,
1142 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1143 | SCANF_ISOC23_BIN_CST);
1144 va_end (ap);
1145
1146 return ret;
1147 }
1148
1149 int
1150 attribute_compat_text_section
1151 __nldbl___isoc23_wscanf (const wchar_t *fmt, ...)
1152 {
1153 va_list ap;
1154 int ret;
1155
1156 va_start (ap, fmt);
1157 ret = __vfwscanf_internal (stdin, fmt, ap,
1158 SCANF_LDBL_IS_DBL | SCANF_ISOC99_A
1159 | SCANF_ISOC23_BIN_CST);
1160 va_end (ap);
1161
1162 return ret;
1163 }
1164
1165 void
1166 __nldbl_argp_error (const struct argp_state *state, const char *fmt, ...)
1167 {
1168 va_list ap;
1169 va_start (ap, fmt);
1170 __argp_error_internal (state, fmt, ap, PRINTF_LDBL_IS_DBL);
1171 va_end (ap);
1172 }
1173
1174 void
1175 __nldbl_argp_failure (const struct argp_state *state, int status,
1176 int errnum, const char *fmt, ...)
1177 {
1178 va_list ap;
1179 va_start (ap, fmt);
1180 __argp_failure_internal (state, status, errnum, fmt, ap,
1181 PRINTF_LDBL_IS_DBL);
1182 va_end (ap);
1183 }
1184
1185 #define VA_CALL(call) \
1186 { \
1187 va_list ap; \
1188 va_start (ap, format); \
1189 call (format, ap, PRINTF_LDBL_IS_DBL); \
1190 va_end (ap); \
1191 }
1192
1193 void
1194 __nldbl_err (int status, const char *format, ...)
1195 {
1196 VA_CALL (__vwarn_internal)
1197 exit (status);
1198 }
1199
1200 void
1201 __nldbl_errx (int status, const char *format, ...)
1202 {
1203 VA_CALL (__vwarnx_internal)
1204 exit (status);
1205 }
1206
1207 void
1208 __nldbl_verr (int status, const char *format, __gnuc_va_list ap)
1209 {
1210 __vwarn_internal (format, ap, PRINTF_LDBL_IS_DBL);
1211 exit (status);
1212 }
1213
1214 void
1215 __nldbl_verrx (int status, const char *format, __gnuc_va_list ap)
1216 {
1217 __vwarnx_internal (format, ap, PRINTF_LDBL_IS_DBL);
1218 exit (status);
1219 }
1220
1221 void
1222 __nldbl_warn (const char *format, ...)
1223 {
1224 VA_CALL (__vwarn_internal)
1225 }
1226
1227 void
1228 __nldbl_warnx (const char *format, ...)
1229 {
1230 VA_CALL (__vwarnx_internal)
1231 }
1232
1233 void
1234 __nldbl_vwarn (const char *format, __gnuc_va_list ap)
1235 {
1236 __vwarn_internal (format, ap, PRINTF_LDBL_IS_DBL);
1237 }
1238
1239 void
1240 __nldbl_vwarnx (const char *format, __gnuc_va_list ap)
1241 {
1242 __vwarnx_internal (format, ap, PRINTF_LDBL_IS_DBL);
1243 }
1244
1245 void
1246 __nldbl_error (int status, int errnum, const char *message, ...)
1247 {
1248 va_list ap;
1249 va_start (ap, message);
1250 __error_internal (status, errnum, message, ap, PRINTF_LDBL_IS_DBL);
1251 va_end (ap);
1252 }
1253
1254 void
1255 __nldbl_error_at_line (int status, int errnum, const char *file_name,
1256 unsigned int line_number, const char *message,
1257 ...)
1258 {
1259 va_list ap;
1260 va_start (ap, message);
1261 __error_at_line_internal (status, errnum, file_name, line_number,
1262 message, ap, PRINTF_LDBL_IS_DBL);
1263 va_end (ap);
1264 }
1265
1266 #if LONG_DOUBLE_COMPAT(libc, GLIBC_2_0)
1267 compat_symbol (libc, __nldbl__IO_printf, _IO_printf, GLIBC_2_0);
1268 compat_symbol (libc, __nldbl__IO_sprintf, _IO_sprintf, GLIBC_2_0);
1269 compat_symbol (libc, __nldbl__IO_vfprintf, _IO_vfprintf, GLIBC_2_0);
1270 compat_symbol (libc, __nldbl__IO_vsprintf, _IO_vsprintf, GLIBC_2_0);
1271 compat_symbol (libc, __nldbl_dprintf, dprintf, GLIBC_2_0);
1272 compat_symbol (libc, __nldbl_fprintf, fprintf, GLIBC_2_0);
1273 compat_symbol (libc, __nldbl_printf, printf, GLIBC_2_0);
1274 compat_symbol (libc, __nldbl_sprintf, sprintf, GLIBC_2_0);
1275 compat_symbol (libc, __nldbl_vfprintf, vfprintf, GLIBC_2_0);
1276 compat_symbol (libc, __nldbl_vprintf, vprintf, GLIBC_2_0);
1277 compat_symbol (libc, __nldbl__IO_fprintf, _IO_fprintf, GLIBC_2_0);
1278 compat_symbol (libc, __nldbl___vsnprintf, __vsnprintf, GLIBC_2_0);
1279 compat_symbol (libc, __nldbl_asprintf, asprintf, GLIBC_2_0);
1280 compat_symbol (libc, __nldbl_obstack_printf, obstack_printf, GLIBC_2_0);
1281 compat_symbol (libc, __nldbl_obstack_vprintf, obstack_vprintf, GLIBC_2_0);
1282 compat_symbol (libc, __nldbl_snprintf, snprintf, GLIBC_2_0);
1283 compat_symbol (libc, __nldbl_vasprintf, vasprintf, GLIBC_2_0);
1284 compat_symbol (libc, __nldbl_vdprintf, vdprintf, GLIBC_2_0);
1285 compat_symbol (libc, __nldbl_vsnprintf, vsnprintf, GLIBC_2_0);
1286 compat_symbol (libc, __nldbl_vsprintf, vsprintf, GLIBC_2_0);
1287 compat_symbol (libc, __nldbl__IO_sscanf, _IO_sscanf, GLIBC_2_0);
1288 compat_symbol (libc, __nldbl___vfscanf, __vfscanf, GLIBC_2_0);
1289 compat_symbol (libc, __nldbl___vsscanf, __vsscanf, GLIBC_2_0);
1290 compat_symbol (libc, __nldbl_fscanf, fscanf, GLIBC_2_0);
1291 compat_symbol (libc, __nldbl_scanf, scanf, GLIBC_2_0);
1292 compat_symbol (libc, __nldbl_sscanf, sscanf, GLIBC_2_0);
1293 compat_symbol (libc, __nldbl_vfscanf, vfscanf, GLIBC_2_0);
1294 compat_symbol (libc, __nldbl_vscanf, vscanf, GLIBC_2_0);
1295 compat_symbol (libc, __nldbl_vsscanf, vsscanf, GLIBC_2_0);
1296 compat_symbol (libc, __nldbl___printf_fp, __printf_fp, GLIBC_2_0);
1297 compat_symbol (libc, __nldbl_strfmon, strfmon, GLIBC_2_0);
1298 compat_symbol (libc, __nldbl_syslog, syslog, GLIBC_2_0);
1299 compat_symbol (libc, __nldbl_vsyslog, vsyslog, GLIBC_2_0);
1300 /* This function is not in public headers, but was exported until
1301 version 2.29. For platforms that are newer than that, there's no
1302 need to expose the symbol. */
1303 # if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_29)
1304 compat_symbol (libc, __nldbl__IO_vfscanf, _IO_vfscanf, GLIBC_2_0);
1305 # endif
1306 #endif
1307 #if LONG_DOUBLE_COMPAT(libc, GLIBC_2_1)
1308 compat_symbol (libc, __nldbl___asprintf, __asprintf, GLIBC_2_1);
1309 compat_symbol (libc, __nldbl_printf_size, printf_size, GLIBC_2_1);
1310 compat_symbol (libc, __nldbl___strfmon_l, __strfmon_l, GLIBC_2_1);
1311 #endif
1312 #if LONG_DOUBLE_COMPAT(libc, GLIBC_2_2)
1313 compat_symbol (libc, __nldbl_swprintf, swprintf, GLIBC_2_2);
1314 compat_symbol (libc, __nldbl_vwprintf, vwprintf, GLIBC_2_2);
1315 compat_symbol (libc, __nldbl_wprintf, wprintf, GLIBC_2_2);
1316 compat_symbol (libc, __nldbl_fwprintf, fwprintf, GLIBC_2_2);
1317 compat_symbol (libc, __nldbl_vfwprintf, vfwprintf, GLIBC_2_2);
1318 compat_symbol (libc, __nldbl_vswprintf, vswprintf, GLIBC_2_2);
1319 compat_symbol (libc, __nldbl_fwscanf, fwscanf, GLIBC_2_2);
1320 compat_symbol (libc, __nldbl_swscanf, swscanf, GLIBC_2_2);
1321 compat_symbol (libc, __nldbl_vfwscanf, vfwscanf, GLIBC_2_2);
1322 compat_symbol (libc, __nldbl_vswscanf, vswscanf, GLIBC_2_2);
1323 compat_symbol (libc, __nldbl_vwscanf, vwscanf, GLIBC_2_2);
1324 compat_symbol (libc, __nldbl_wscanf, wscanf, GLIBC_2_2);
1325 #endif
1326 #if LONG_DOUBLE_COMPAT(libc, GLIBC_2_3)
1327 compat_symbol (libc, __nldbl_strfmon_l, strfmon_l, GLIBC_2_3);
1328 #endif
1329 #if LONG_DOUBLE_COMPAT(libc, GLIBC_2_3_4)
1330 compat_symbol (libc, __nldbl___sprintf_chk, __sprintf_chk, GLIBC_2_3_4);
1331 compat_symbol (libc, __nldbl___vsprintf_chk, __vsprintf_chk, GLIBC_2_3_4);
1332 compat_symbol (libc, __nldbl___snprintf_chk, __snprintf_chk, GLIBC_2_3_4);
1333 compat_symbol (libc, __nldbl___vsnprintf_chk, __vsnprintf_chk, GLIBC_2_3_4);
1334 compat_symbol (libc, __nldbl___printf_chk, __printf_chk, GLIBC_2_3_4);
1335 compat_symbol (libc, __nldbl___fprintf_chk, __fprintf_chk, GLIBC_2_3_4);
1336 compat_symbol (libc, __nldbl___vprintf_chk, __vprintf_chk, GLIBC_2_3_4);
1337 compat_symbol (libc, __nldbl___vfprintf_chk, __vfprintf_chk, GLIBC_2_3_4);
1338 #endif