riscv
/
glibc
mirror of https://gitee.com/Nocallback/glibc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

C2x scanf %b support 

ISO C2x defines scanf %b for input of binary integers (with an
optional 0b or 0B prefix).  Implement such support, along with the
corresponding SCNb* macros in <inttypes.h>.  Unlike the support for
binary integers with 0b or 0B prefix with scanf %i, this is supported
in all versions of scanf (independent of the standards mode used for
compilation), because there are no backwards compatibility concerns
(%b wasn't previously a supported format) the way there were for %i.

Tested for x86_64 and x86.
azanella/bz30558-posix_timer
Joseph Myers 3 years ago
parent
5f83b2674e
commit
2d88df5411
5 changed files with 248 additions and 9 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      NEWS
  2. 12
      manual/stdio.texi
  3. 203
      stdio-common/tst-scanf-binary-main.c
  4. 13
      stdio-common/vfscanf-internal.c
  5. 22
      stdlib/inttypes.h

7
NEWS
View File

@ -17,9 +17,12 @@ Major new features:
wcstoull_l, wcstoimax, wcstoumax, wcstoq, wcstouq. Similarly, the
following functions support binary integers prefixed by 0b or 0B as
input to the %i format: fscanf, scanf, sscanf, vscanf, vsscanf,
vfscanf, fwscanf, wscanf, swscanf, vfwscanf, vwscanf, vswscanf.
vfscanf, fwscanf, wscanf, swscanf, vfwscanf, vwscanf, vswscanf; those
functions also support the %b format for binary integers, with or
without such a prefix and independent of standards mode.
* PRIb* and PRIB* macros from C2X have been added to <inttypes.h>.
* PRIb*, PRIB* and SCNb* macros from C2X have been added to
<inttypes.h>.
* printf-family functions now support the wN format length modifiers for
arguments of type intN_t, int_leastN_t, uintN_t or uint_leastN_t (for

12
manual/stdio.texi
View File

@ -3545,6 +3545,10 @@ Matches an optionally signed integer in any of the formats that the C
language defines for specifying an integer constant. @xref{Numeric
Input Conversions}.
@item @samp{%b}
Matches an unsigned integer written in binary radix. This is an ISO
C2X feature. @xref{Numeric Input Conversions}.
@item @samp{%o}
Matches an unsigned integer written in octal radix.
@xref{Numeric Input Conversions}.
@ -3652,11 +3656,13 @@ For example, any of the strings @samp{10}, @samp{0xa}, or @samp{012}
could be read in as integers under the @samp{%i} conversion. Each of
these specifies a number with decimal value @code{10}.
The @samp{%o}, @samp{%u}, and @samp{%x} conversions match unsigned
integers in octal, decimal, and hexadecimal radices, respectively. The
The @samp{%b}, @samp{%o}, @samp{%u}, and @samp{%x} conversions match unsigned
integers in binary, octal, decimal, and hexadecimal radices, respectively. The
syntax that is recognized is the same as that for the @code{strtoul}
function (@pxref{Parsing of Integers}) with the appropriate value
(@code{8}, @code{10}, or @code{16}) for the @var{base} argument.
(@code{2}, @code{8}, @code{10}, or @code{16}) for the @var{base}
argument. The @samp{%b} conversion accepts an optional leading
@samp{0b} or @samp{0B} in all standards modes.
The @samp{%X} conversion is identical to the @samp{%x} conversion. They
both permit either uppercase or lowercase letters to be used as digits.

203
stdio-common/tst-scanf-binary-main.c
View File

@ -16,10 +16,12 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#include <inttypes.h>
#include <stdarg.h>
#include <stdio.h>
#include <wchar.h>
#include <libc-diag.h>
#include <support/check.h>
#include <support/xstdio.h>
@ -176,6 +178,195 @@ one_check (const CHAR *s, int expected, char expected_c)
TEST_COMPARE (ret_c, expected_c);
}
/* GCC does not know the %b format before GCC 12. */
DIAG_PUSH_NEEDS_COMMENT;
#if !__GNUC_PREREQ (12, 0)
DIAG_IGNORE_NEEDS_COMMENT (11, "-Wformat");
DIAG_IGNORE_NEEDS_COMMENT (11, "-Wformat-extra-args");
#endif
static void
one_check_b (const CHAR *s, int expected, char expected_c)
{
int ret;
FILE *fp;
unsigned int ret_i;
unsigned long int ret_l;
unsigned long long int ret_ll;
char ret_c;
fp = xfopen (INFILE, "w");
ret = FNX (fput, s) (s, fp);
TEST_VERIFY_EXIT (0 <= ret);
xfclose (fp);
ret = FNX (s, scanf) (s, L_("%b %c"), &ret_i, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_i, (unsigned int) expected);
TEST_COMPARE (ret_c, expected_c);
fp = xfopen (INFILE, "r");
ret = FNX (f, scanf) (fp, L_("%b %c"), &ret_i, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_i, (unsigned int) expected);
TEST_COMPARE (ret_c, expected_c);
xfclose (fp);
fp = xfreopen (INFILE, "r", stdin);
ret = FNX (, scanf) (L_("%b %c"), &ret_i, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_i, (unsigned int) expected);
TEST_COMPARE (ret_c, expected_c);
ret = wrap_vsscanf (s, L_("%b %c"), &ret_i, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_i, (unsigned int) expected);
TEST_COMPARE (ret_c, expected_c);
fp = xfopen (INFILE, "r");
ret = wrap_vfscanf (fp, L_("%b %c"), &ret_i, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_i, (unsigned int) expected);
TEST_COMPARE (ret_c, expected_c);
xfclose (fp);
fp = xfreopen (INFILE, "r", stdin);
ret = wrap_vscanf (L_("%b %c"), &ret_i, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_i, (unsigned int) expected);
TEST_COMPARE (ret_c, expected_c);
ret = FNX (s, scanf) (s, L_("%lb %c"), &ret_l, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_l, (unsigned long int) expected);
TEST_COMPARE (ret_c, expected_c);
fp = xfopen (INFILE, "r");
ret = FNX (f, scanf) (fp, L_("%lb %c"), &ret_l, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_l, (unsigned long int) expected);
TEST_COMPARE (ret_c, expected_c);
xfclose (fp);
fp = xfreopen (INFILE, "r", stdin);
ret = FNX (, scanf) (L_("%lb %c"), &ret_l, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_l, (unsigned long int) expected);
TEST_COMPARE (ret_c, expected_c);
ret = wrap_vsscanf (s, L_("%lb %c"), &ret_l, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_l, (unsigned long int) expected);
TEST_COMPARE (ret_c, expected_c);
fp = xfopen (INFILE, "r");
ret = wrap_vfscanf (fp, L_("%lb %c"), &ret_l, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_l, (unsigned long int) expected);
TEST_COMPARE (ret_c, expected_c);
xfclose (fp);
fp = xfreopen (INFILE, "r", stdin);
ret = wrap_vscanf (L_("%lb %c"), &ret_l, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_l, (unsigned long int) expected);
TEST_COMPARE (ret_c, expected_c);
ret = FNX (s, scanf) (s, L_("%llb %c"), &ret_ll, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_ll, (unsigned long long int) expected);
TEST_COMPARE (ret_c, expected_c);
fp = xfopen (INFILE, "r");
ret = FNX (f, scanf) (fp, L_("%llb %c"), &ret_ll, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_ll, (unsigned long long int) expected);
TEST_COMPARE (ret_c, expected_c);
xfclose (fp);
fp = xfreopen (INFILE, "r", stdin);
ret = FNX (, scanf) (L_("%llb %c"), &ret_ll, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_ll, (unsigned long long int) expected);
TEST_COMPARE (ret_c, expected_c);
ret = wrap_vsscanf (s, L_("%llb %c"), &ret_ll, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_ll, (unsigned long long int) expected);
TEST_COMPARE (ret_c, expected_c);
fp = xfopen (INFILE, "r");
ret = wrap_vfscanf (fp, L_("%llb %c"), &ret_ll, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_ll, (unsigned long long int) expected);
TEST_COMPARE (ret_c, expected_c);
xfclose (fp);
fp = xfreopen (INFILE, "r", stdin);
ret = wrap_vscanf (L_("%llb %c"), &ret_ll, &ret_c);
TEST_COMPARE (ret, 2);
TEST_COMPARE (ret_ll, (unsigned long long int) expected);
TEST_COMPARE (ret_c, expected_c);
}
#define CHECK_SCNB(TYPE, MACRO, S, EXPECTED, EXPECTED_C) \
do \
{ \
int ret; \
FILE *fp; \
TYPE ret_t; \
char ret_c; \
fp = xfopen (INFILE, "w"); \
ret = FNX (fput, s) (S, fp); \
TEST_VERIFY_EXIT (0 <= ret); \
xfclose (fp); \
ret = FNX (s, scanf) (S, L_("%") MACRO " %c", &ret_t, &ret_c); \
TEST_COMPARE (ret, 2); \
TEST_COMPARE (ret_t, EXPECTED); \
TEST_COMPARE (ret_c, EXPECTED_C); \
fp = xfopen (INFILE, "r"); \
ret = FNX (f, scanf) (fp, L_("%") MACRO " %c", &ret_t, &ret_c); \
TEST_COMPARE (ret, 2); \
TEST_COMPARE (ret_t, EXPECTED); \
TEST_COMPARE (ret_c, EXPECTED_C); \
xfclose (fp); \
fp = xfreopen (INFILE, "r", stdin); \
ret = FNX (, scanf) (L_("%") MACRO " %c", &ret_t, &ret_c); \
TEST_COMPARE (ret, 2); \
TEST_COMPARE (ret_t, EXPECTED); \
TEST_COMPARE (ret_c, EXPECTED_C); \
ret = wrap_vsscanf (S, L_("%") MACRO " %c", &ret_t, &ret_c); \
TEST_COMPARE (ret, 2); \
TEST_COMPARE (ret_t, EXPECTED); \
TEST_COMPARE (ret_c, EXPECTED_C); \
fp = xfopen (INFILE, "r"); \
ret = wrap_vfscanf (fp, L_("%") MACRO " %c", &ret_t, &ret_c); \
TEST_COMPARE (ret, 2); \
TEST_COMPARE (ret_t, EXPECTED); \
TEST_COMPARE (ret_c, EXPECTED_C); \
xfclose (fp); \
fp = xfreopen (INFILE, "r", stdin); \
ret = wrap_vscanf (L_("%") MACRO " %c", &ret_t, &ret_c); \
TEST_COMPARE (ret, 2); \
TEST_COMPARE (ret_t, EXPECTED); \
TEST_COMPARE (ret_c, EXPECTED_C); \
} \
while (0)
static void
one_check_scnb (const CHAR *s, int expected, char expected_c)
{
#if TEST_C2X || defined _GNU_SOURCE
CHECK_SCNB (uint8_t, SCNb8, s, (uint8_t) expected, expected_c);
CHECK_SCNB (uint16_t, SCNb16, s, (uint16_t) expected, expected_c);
CHECK_SCNB (uint32_t, SCNb32, s, (uint32_t) expected, expected_c);
CHECK_SCNB (uint64_t, SCNb64, s, (uint64_t) expected, expected_c);
CHECK_SCNB (uint_least8_t, SCNbLEAST8, s, (uint_least8_t) expected,
expected_c);
CHECK_SCNB (uint_least16_t, SCNbLEAST16, s, (uint_least16_t) expected,
expected_c);
CHECK_SCNB (uint_least32_t, SCNbLEAST32, s, (uint_least32_t) expected,
expected_c);
CHECK_SCNB (uint_least64_t, SCNbLEAST64, s, (uint_least64_t) expected,
expected_c);
CHECK_SCNB (uint_fast8_t, SCNbFAST8, s, (uint_fast8_t) expected, expected_c);
CHECK_SCNB (uint_fast16_t, SCNbFAST16, s, (uint_fast16_t) expected,
expected_c);
CHECK_SCNB (uint_fast32_t, SCNbFAST32, s, (uint_fast32_t) expected,
expected_c);
CHECK_SCNB (uint_fast64_t, SCNbFAST64, s, (uint_fast64_t) expected,
expected_c);
CHECK_SCNB (uintmax_t, SCNbMAX, s, (uintmax_t) expected, expected_c);
CHECK_SCNB (uintptr_t, SCNbPTR, s, (uintptr_t) expected, expected_c);
#endif
}
DIAG_POP_NEEDS_COMMENT;
static int
do_test (void)
{
@ -183,6 +374,18 @@ do_test (void)
one_check (L_("0B101 x"), 5, 'x');
one_check (L_("-0b11111 y"), -31, 'y');
one_check (L_("-0B11111 y"), -31, 'y');
one_check_b (L_("0b101 x"), 5, 'x');
one_check_b (L_("0B101 x"), 5, 'x');
one_check_b (L_("-0b11111 y"), -31, 'y');
one_check_b (L_("-0B11111 y"), -31, 'y');
one_check_b (L_("101 x"), 5, 'x');
one_check_b (L_("-11111 y"), -31, 'y');
one_check_scnb (L_("0b101 x"), 5, 'x');
one_check_scnb (L_("0B101 x"), 5, 'x');
one_check_scnb (L_("-0b11111 y"), -31, 'y');
one_check_scnb (L_("-0B11111 y"), -31, 'y');
one_check_scnb (L_("101 x"), 5, 'x');
one_check_scnb (L_("-11111 y"), -31, 'y');
return 0;
}

13
stdio-common/vfscanf-internal.c
View File

@ -1381,6 +1381,10 @@ __vfscanf_internal (FILE *s, const char *format, va_list argptr,
base = 8;
goto number;
case L_('b'): /* Binary integer. */
base = 2;
goto number;
case L_('u'): /* Unsigned decimal integer. */
base = 10;
goto number;
@ -1428,10 +1432,11 @@ __vfscanf_internal (FILE *s, const char *format, va_list argptr,
c = inchar ();
}
}
else if ((mode_flags & SCANF_ISOC23_BIN_CST) != 0
&& base == 0
&& width != 0
&& TOLOWER (c) == L_('b'))
else if (width != 0
&& TOLOWER (c) == L_('b')
&& (base == 2
|| ((mode_flags & SCANF_ISOC23_BIN_CST) != 0
&& base == 0)))
{
base = 2;
if (width > 0)

22
stdlib/inttypes.h
View File

@ -302,6 +302,28 @@ typedef wchar_t __gwchar_t;
# define SCNxPTR __PRIPTR_PREFIX "x"
/* Binary notation. */
# if __GLIBC_USE (ISOC2X)
# define SCNb8 "hhb"
# define SCNb16 "hb"
# define SCNb32 "b"
# define SCNb64 __PRI64_PREFIX "b"
# define SCNbLEAST8 "hhb"
# define SCNbLEAST16 "hb"
# define SCNbLEAST32 "b"
# define SCNbLEAST64 __PRI64_PREFIX "b"
# define SCNbFAST8 "hhb"
# define SCNbFAST16 __PRIPTR_PREFIX "b"
# define SCNbFAST32 __PRIPTR_PREFIX "b"
# define SCNbFAST64 __PRI64_PREFIX "b"
# define SCNbMAX __PRI64_PREFIX "b"
# define SCNbPTR __PRIPTR_PREFIX "b"
# endif
__BEGIN_DECLS
#if __WORDSIZE == 64

Write Preview
Loading…
Cancel
Save