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.

diff --git a/NEWS b/NEWS
index 7cec03cc76938f43aff70ed94b0bd56f9fde6b62..709ee40e505c8abed1743fb3a0d1abc3744bad55 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -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

diff --git a/manual/stdio.texi b/manual/stdio.texi
index a981e6512a1dc35f7ae9dd1095dbcf500b179b12..9cf622403f296e40bfb742613a72954981e225e2 100644 (file)
--- a/manual/stdio.texi
+++ b/manual/stdio.texi
@@ -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.

diff --git a/stdio-common/tst-scanf-binary-main.c b/stdio-common/tst-scanf-binary-main.c
index 6b75cb32e58b3dd74a0453296dd1a6d28c06c010..f9b45178dbb8a2c09617a43a28d651fca662c4a1 100644 (file)
--- a/stdio-common/tst-scanf-binary-main.c
+++ b/stdio-common/tst-scanf-binary-main.c
@@ -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;
 }
 

diff --git a/stdio-common/vfscanf-internal.c b/stdio-common/vfscanf-internal.c
index a3ebf63554daf507564b728c333410e7d2ba1d8f..bfb9baa21a4474cd8e179a71b2ef0c2ee7f5bad3 100644 (file)
--- a/stdio-common/vfscanf-internal.c
+++ b/stdio-common/vfscanf-internal.c
@@ -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)

diff --git a/stdlib/inttypes.h b/stdlib/inttypes.h
index 8f0fa8ab9fe4d437dbf5d1c1bc020f0c3f55caf6..42ecf681cc7904de8c7b2345049433351e38d11e 100644 (file)
--- a/stdlib/inttypes.h
+++ b/stdlib/inttypes.h
@@ -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