Add binary format specifications '%b' and '%B'

These produce the binary representation of a number.
'%#b' and '%#B' prefix with '0b' and '0B', respectively.
(bug#79990)
* etc/NEWS: Announce change.
* doc/lispref/strings.texi (Formatting Strings): Describe new format
specs and add to comment on reconstructing the value with 'read'.
* src/editfns.c (format): Update doc string.
(styled_format): Add support for '%b' and '%B'.  To remain
portable, avoid use of 'sprintf' by converting by hand.
* test/src/editfns-tests.el (format-binary-zero, format-binary-floats)
(format-binary-nonzero-integers): Add tests.
(read-large-integer): Add binary test cases.
Co-authored-by: Paul Eggert <eggert@cs.ucla.edu>

1 files changed, 42 insertions, 12 deletions

diff --git a/src/editfns.c b/src/editfns.c
index b5ba3bde7f9..117722e0e09 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -3349,6 +3349,8 @@ the next available argument, or the argument explicitly specified:
 
 %s means produce a string argument.  Actually, produces any object with `princ'.
 %d or %i means produce a signed number in decimal.
+%b means produce a number in binary.
+%B is like %b, but %#B uses upper case.
 %o means produce a number in octal.
 %x means produce a number in hex.
 %X is like %x, but uses upper case.
@@ -3382,8 +3384,9 @@ space inserts a space before any nonnegative number; these flags
 affect only numeric %-sequences, and the + flag takes precedence.
 The - and 0 flags affect the width specifier, as described below.
 
-The # flag means to use an alternate display form for %o, %x, %X, %e,
-%f, and %g sequences: for %o, it ensures that the result begins with
+The # flag means to use an alternate display form for %b, %B, %o, %x,
+%X, %e, %f, and %g sequences: for %b and %B, it prefixes nonzero results
+with \"0b\" or \"0B\"; for %o, it ensures that the result begins with
 \"0\"; for %x and %X, it prefixes nonzero results with \"0x\" or \"0X\";
 for %e and %f, it causes a decimal point to be included even if the
 precision is zero; for %g, it causes a decimal point to be
@@ -3395,7 +3398,7 @@ produced representation.  The padding, if any, normally goes on the
 left, but it goes on the right if the - flag is present.  The padding
 character is normally a space, but it is 0 if the 0 flag is present.
 The 0 flag is ignored if the - flag is present, or the format sequence
-is something other than %d, %o, %x, %e, %f, and %g.
+is something other than %d, %b, %o, %x, %e, %f, and %g.
 
 For %e and %f sequences, the number after the "." in the precision
 specifier says how many decimal places to show; if zero, the decimal
@@ -3813,8 +3816,9 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
             }
           else if (! (conversion == 'c' || conversion == 'd'
                       || float_conversion || conversion == 'i'
-                      || conversion == 'o' || conversion == 'x'
-                      || conversion == 'X'))
+                      || conversion == 'o'
+                      || conversion == 'x' || conversion == 'X'
+                      || conversion == 'b' || conversion == 'B'))
             {
               unsigned char *p = (unsigned char *) format - 1;
               if (multibyte_format)
@@ -3865,7 +3869,9 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
 
               /* Characters to be inserted after spaces and before
                  leading zeros.  This can occur with bignums, since
-                 bignum_to_string does only leading '-'.  */
+                 bignum_to_string does only leading '-'.
+                 It can also occur with the conversion specs %b and %B,
+                 which sprintf might not support.  */
               char prefix[sizeof "-0x" - 1];
               int prefixlen = 0;
 
@@ -3882,6 +3888,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                  conversions; for example, the min and max macros are
                  not suitable here.  */
               ptrdiff_t sprintf_bytes;
+              bool nonzero_arg;
               if (float_conversion)
                 {
                   /* Format as a long double if the arg is an integer
@@ -3949,20 +3956,28 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
               bignum_arg:
                 {
                   int base = ((conversion == 'd' || conversion == 'i') ? 10
-                              : conversion == 'o' ? 8 : 16);
+                              : conversion == 'o' ? 8
+                              : conversion == 'x' || conversion == 'X' ? 16
+                              : 2);
                   sprintf_bytes = bignum_bufsize (arg, base);
                   if (sprintf_bytes <= buf + bufsize - p)
                     {
                       int signedbase = conversion == 'X' ? -base : base;
                       sprintf_bytes = bignum_to_c_string (p, sprintf_bytes,
                                                           arg, signedbase);
+                      nonzero_arg = true;
+                    preformatted_fixnum_arg:
                       bool negative = p[0] == '-';
                       prec = min (precision, sprintf_bytes - prefixlen);
                       prefix[prefixlen] = plus_flag ? '+' : ' ';
                       prefixlen += (plus_flag | space_flag) & !negative;
                       prefix[prefixlen] = '0';
                       prefix[prefixlen + 1] = conversion;
-                      prefixlen += sharp_flag && base == 16 ? 2 : 0;
+                      prefixlen += ((sharp_flag & nonzero_arg
+                                     && ! (conversion == 'd'
+                                           || conversion == 'i'
+                                           || conversion == 'o'))
+                                    ? 2 : 0);
                     }
                 }
               else if (conversion == 'd' || conversion == 'i')
@@ -4013,6 +4028,20 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                         }
                     }
                   p[0] = negative ? '-' : plus_flag ? '+' : ' ';
+
+                  if (conversion == 'b' || conversion == 'B')
+                    {
+                      int bit_width = stdc_bit_width (x);
+                      char *bits = p + negative;
+                      int nbits = bit_width ? bit_width : prec < 0;
+                      for (int i = 0; i < nbits; i++)
+                        bits[i] = ((x >> (nbits - (i + 1))) & 1) + '0';
+                      bits[nbits] = '\0';
+                      sprintf_bytes = negative + nbits;
+                      nonzero_arg = x != 0;
+                      goto preformatted_fixnum_arg;
+                    }
+
                   bool signedp = negative | plus_flag | space_flag;
                   sprintf_bytes = sprintf (p + signedp, convspec, prec, x);
                   sprintf_bytes += signedp;
@@ -4053,12 +4082,13 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
 
               if (convbytes <= buf + bufsize - p)
                 {
+                  /* Skip any sign and 0[bBxX] prefixes.  */
                   bool signedp = p[0] == '-' || p[0] == '+' || p[0] == ' ';
                   int beglen = (signedp
-                                   + ((p[signedp] == '0'
-                                       && (p[signedp + 1] == 'x'
-                                           || p[signedp + 1] == 'X'))
-                                      ? 2 : 0));
+                                + ((!float_conversion
+                                    && p[signedp] == '0'
+                                    && p[signedp + 1] == conversion)
+                                   ? 2 : 0));
                   eassert (prefixlen == 0 || beglen == 0
                            || (beglen == 1 && p[0] == '-'
                                && ! (prefix[0] == '-' || prefix[0] == '+'