X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fformat.c;h=f323424d0868fbf128629bbf845e7bb94726a813;hb=0eded6940b00e6523d7a0a7f76e40c70324f85d2;hp=21162a05ae4f4ab21aff8012def2fdcd83d30123;hpb=6c99748d153d74b325a50f79bc8e59f1f9521f98;p=pspp

diff --git a/src/data/format.c b/src/data/format.c
index 21162a05ae..f323424d08 100644
--- a/src/data/format.c
+++ b/src/data/format.c
@@ -20,6 +20,7 @@
 
 #include <ctype.h>
 #include <stdlib.h>
+#include <time.h>
 #include <uniwidth.h>
 
 #include "data/identifier.h"
@@ -36,15 +37,11 @@
 #include "gl/c-strcase.h"
 #include "gl/minmax.h"
 #include "gl/xalloc.h"
+#include "gl/xmemdup0.h"
 
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
 
-struct fmt_settings
-  {
-    struct fmt_number_style styles[FMT_NUMBER_OF_FORMATS];
-  };
-
 bool is_fmt_type (enum fmt_type);
 
 static bool valid_width (enum fmt_type, int width, enum fmt_use);
@@ -53,126 +50,141 @@ static int max_digits_for_bytes (int bytes);
 static void fmt_clamp_width (struct fmt_spec *, enum fmt_use);
 static void fmt_clamp_decimals (struct fmt_spec *, enum fmt_use);
 
-static void fmt_affix_set (struct fmt_affix *, const char *);
-static void fmt_affix_free (struct fmt_affix *);
-
-static void fmt_number_style_init (struct fmt_number_style *);
-static void fmt_number_style_clone (struct fmt_number_style *,
-                                    const struct fmt_number_style *);
-static void fmt_number_style_destroy (struct fmt_number_style *);
-
-/* Creates and returns a new struct fmt_settings with default format styles. */
-struct fmt_settings *
-fmt_settings_create (void)
+void
+fmt_settings_init (struct fmt_settings *settings)
 {
-  struct fmt_settings *settings;
-  int t;
-
-  settings = xzalloc (sizeof *settings);
-  for (t = 0 ; t < FMT_NUMBER_OF_FORMATS ; ++t )
-    fmt_number_style_init (&settings->styles[t]);
-  fmt_settings_set_decimal (settings, '.');
-
-  return settings;
+  *settings = (struct fmt_settings) FMT_SETTINGS_INIT;
 }
 
-/* Destroys SETTINGS. */
 void
-fmt_settings_destroy (struct fmt_settings *settings)
+fmt_settings_uninit (struct fmt_settings *settings)
 {
-  if (settings != NULL)
-    {
-      int t;
-
-      for (t = 0 ; t < FMT_NUMBER_OF_FORMATS ; ++t )
-        fmt_number_style_destroy (&settings->styles[t]);
-
-      free (settings->styles);
-    }
+  for (int i = 0; i < FMT_N_CCS; i++)
+    fmt_number_style_destroy (settings->ccs[i]);
 }
 
-/* Returns a copy of SETTINGS. */
-struct fmt_settings *
-fmt_settings_clone (const struct fmt_settings *old)
+struct fmt_settings
+fmt_settings_copy (const struct fmt_settings *old)
 {
-  struct fmt_settings *new;
-  int t;
-
-  new = xmalloc (sizeof *new);
-  for (t = 0 ; t < FMT_NUMBER_OF_FORMATS ; ++t )
-    fmt_number_style_clone (&new->styles[t], &old->styles[t]);
-
+  struct fmt_settings new = *old;
+  for (int i = 0; i < FMT_N_CCS; i++)
+    new.ccs[i] = fmt_number_style_clone (old->ccs[i]);
   return new;
 }
 
+static size_t
+fmt_type_to_cc_index (enum fmt_type type)
+{
+  switch (type)
+    {
+    case FMT_CCA: return 0;
+    case FMT_CCB: return 1;
+    case FMT_CCC: return 2;
+    case FMT_CCD: return 3;
+    case FMT_CCE: return 4;
+    default: NOT_REACHED ();
+    }
+}
+
 /* Returns the number formatting style associated with the given
    format TYPE. */
 const struct fmt_number_style *
 fmt_settings_get_style (const struct fmt_settings *settings,
                         enum fmt_type type)
 {
-  assert (is_fmt_type (type));
-  return &settings->styles[type];
-}
-
-/* Sets the number style for TYPE to have the given DECIMAL and GROUPING
-   characters, negative prefix NEG_PREFIX, prefix PREFIX, suffix SUFFIX, and
-   negative suffix NEG_SUFFIX.  All of the strings are UTF-8 encoded. */
-void
-fmt_settings_set_style (struct fmt_settings *settings, enum fmt_type type,
-                        char decimal, char grouping,
-                        const char *neg_prefix, const char *prefix,
-                        const char *suffix, const char *neg_suffix)
-{
-  struct fmt_number_style *style = &settings->styles[type];
-  int total_bytes, total_width;
+  verify (FMT_F < 6);
+  verify (FMT_COMMA < 6);
+  verify (FMT_DOT < 6);
+  verify (FMT_DOLLAR < 6);
+  verify (FMT_PCT < 6);
+  verify (FMT_E < 6);
+
+#define OPPOSITE(C) ((C) == ',' ? '.' : ',')
+#define AFFIX(S) { .s = (char *) (S), .width = sizeof (S) - 1 }
+#define NS(PREFIX, SUFFIX, DECIMAL, GROUPING) { \
+    .neg_prefix = AFFIX ("-"),                  \
+    .prefix = AFFIX (PREFIX),                   \
+    .suffix = AFFIX (SUFFIX),                   \
+    .neg_suffix = AFFIX (""),                   \
+    .decimal = DECIMAL,                         \
+    .grouping = GROUPING,                       \
+  }
+#define ANS(DECIMAL, GROUPING) {                        \
+    [FMT_F]      = NS( "",  "", DECIMAL, 0),            \
+    [FMT_E]      = NS( "",  "", DECIMAL, 0),            \
+    [FMT_COMMA]  = NS( "",  "", DECIMAL, GROUPING),     \
+    [FMT_DOT]    = NS( "",  "", GROUPING, DECIMAL),     \
+    [FMT_DOLLAR] = NS("$",  "", DECIMAL, GROUPING),     \
+    [FMT_PCT]    = NS( "", "%", DECIMAL, 0),            \
+  }
+
+  static const struct fmt_number_style period_styles[6] = ANS ('.', ',');
+  static const struct fmt_number_style comma_styles[6] = ANS (',', '.');
+  static const struct fmt_number_style default_style = NS ("", "", '.', 0);
 
-  assert (grouping == '.' || grouping == ',' || grouping == 0);
-  assert (decimal == '.' || decimal == ',');
-  assert (decimal != grouping);
+  switch (type)
+    {
+    case FMT_F:
+    case FMT_COMMA:
+    case FMT_DOT:
+    case FMT_DOLLAR:
+    case FMT_PCT:
+    case FMT_E:
+      return (settings->decimal == '.'
+              ? &period_styles[type]
+              : &comma_styles[type]);
 
-  fmt_number_style_destroy (style);
+    case FMT_CCA:
+    case FMT_CCB:
+    case FMT_CCC:
+    case FMT_CCD:
+    case FMT_CCE:
+      {
+        size_t idx = fmt_type_to_cc_index (type);
+        return settings->ccs[idx] ? settings->ccs[idx] : &default_style;
+      }
 
-  fmt_affix_set (&style->neg_prefix, neg_prefix);
-  fmt_affix_set (&style->prefix, prefix);
-  fmt_affix_set (&style->suffix, suffix);
-  fmt_affix_set (&style->neg_suffix, neg_suffix);
-  style->decimal = decimal;
-  style->grouping = grouping;
+    default:
+      return &default_style;
+    }
+}
 
-  total_bytes = (strlen (neg_prefix) + strlen (prefix)
-                 + strlen (suffix) + strlen (neg_suffix));
-  total_width = (style->neg_prefix.width + style->prefix.width
-                 + style->suffix.width + style->neg_suffix.width);
-  style->extra_bytes = MAX (0, total_bytes - total_width);
+static int
+default_epoch (void)
+{
+  static int epoch = 0;
+  if (!epoch)
+    {
+      time_t t = time (0);
+      struct tm *tm = localtime (&t);
+      epoch = (tm != NULL ? tm->tm_year + 1900 : 2000) - 69;
+    }
+  return epoch;
 }
 
-/* Sets the decimal point character for the settings in S to DECIMAL.
+int
+fmt_settings_get_epoch (const struct fmt_settings *settings)
+{
+  return !settings->epoch ? default_epoch () : settings->epoch;
+}
 
-   This has no effect on custom currency formats. */
 void
-fmt_settings_set_decimal (struct fmt_settings *s, char decimal)
+fmt_settings_set_cc (struct fmt_settings *settings, enum fmt_type type,
+                     struct fmt_number_style *style)
 {
-  int grouping = decimal == '.' ? ',' : '.';
-  assert (decimal == '.' || decimal == ',');
+  size_t idx = fmt_type_to_cc_index (type);
 
-  fmt_settings_set_style (s, FMT_F,      decimal,        0, "-",  "",  "", "");
-  fmt_settings_set_style (s, FMT_E,      decimal,        0, "-",  "",  "", "");
-  fmt_settings_set_style (s, FMT_COMMA,  decimal, grouping, "-",  "",  "", "");
-  fmt_settings_set_style (s, FMT_DOT,   grouping,  decimal, "-",  "",  "", "");
-  fmt_settings_set_style (s, FMT_DOLLAR, decimal, grouping, "-", "$",  "", "");
-  fmt_settings_set_style (s, FMT_PCT,    decimal,        0, "-",  "", "%", "");
+  fmt_number_style_destroy (settings->ccs[idx]);
+  settings->ccs[idx] = style;
 }
 
+
 /* Returns an input format specification with type TYPE, width W,
    and D decimals. */
 struct fmt_spec
 fmt_for_input (enum fmt_type type, int w, int d)
 {
-  struct fmt_spec f;
-  f.type = type;
-  f.w = w;
-  f.d = d;
+  struct fmt_spec f = { .type = type, .w = w, .d = d };
   assert (fmt_check_input (&f));
   return f;
 }
@@ -182,10 +194,7 @@ fmt_for_input (enum fmt_type type, int w, int d)
 struct fmt_spec
 fmt_for_output (enum fmt_type type, int w, int d)
 {
-  struct fmt_spec f;
-  f.type = type;
-  f.w = w;
-  f.d = d;
+  struct fmt_spec f = { .type = type, .w = w, .d = d };
   assert (fmt_check_output (&f));
   return f;
 }
@@ -193,7 +202,8 @@ fmt_for_output (enum fmt_type type, int w, int d)
 /* Returns the output format specifier corresponding to input
    format specifier INPUT. */
 struct fmt_spec
-fmt_for_output_from_input (const struct fmt_spec *input)
+fmt_for_output_from_input (const struct fmt_spec *input,
+                           const struct fmt_settings *settings)
 {
   struct fmt_spec output;
 
@@ -222,7 +232,7 @@ fmt_for_output_from_input (const struct fmt_spec *input)
     case FMT_PCT:
       {
         const struct fmt_number_style *style =
-	  settings_get_style (input->type);
+	  fmt_settings_get_style (settings, input->type);
 
         output.w += fmt_affix_width (style);
         if (style->grouping != 0 && input->w - input->d >= 3)
@@ -293,6 +303,16 @@ fmt_for_output_from_input (const struct fmt_spec *input)
     case FMT_MONTH:
       break;
 
+    case FMT_MTIME:
+      if (input->d)
+        output.w = MAX (input->w, input->d + 6);
+      break;
+
+    case FMT_YMDHMS:
+      if (input->w)
+        output.w = MAX (input->w, input->d + 20);
+      break;
+
     default:
       NOT_REACHED ();
     }
@@ -319,14 +339,12 @@ fmt_default_for_width (int width)
 bool
 fmt_check (const struct fmt_spec *spec, enum fmt_use use)
 {
-  const char *io_fmt;
   char str[FMT_STRING_LEN_MAX + 1];
   int min_w, max_w, max_d;
 
   assert (is_fmt_type (spec->type));
   fmt_to_string (spec, str);
 
-  io_fmt = use == FMT_FOR_INPUT ? _("Input format") : _("Output format");
   if (use == FMT_FOR_INPUT && !fmt_usable_for_input (spec->type))
     {
       msg (SE, _("Format %s may not be used for input."), str);
@@ -336,8 +354,14 @@ fmt_check (const struct fmt_spec *spec, enum fmt_use use)
   if (spec->w % fmt_step_width (spec->type))
     {
       assert (fmt_step_width (spec->type) == 2);
-      msg (SE, _("%s specifies width %d, but %s requires an even width."),
-           str, spec->w, fmt_name (spec->type));
+      if (use == FMT_FOR_INPUT)
+        msg (SE, _("Input format %s specifies width %d, "
+                   "but %s requires an even width."),
+             str, spec->w, fmt_name (spec->type));
+      else
+        msg (SE, _("Output format %s specifies width %d, "
+                   "but %s requires an even width."),
+             str, spec->w, fmt_name (spec->type));
       return false;
     }
 
@@ -345,39 +369,80 @@ fmt_check (const struct fmt_spec *spec, enum fmt_use use)
   max_w = fmt_max_width (spec->type, use);
   if (spec->w < min_w || spec->w > max_w)
     {
-      msg (SE, _("%s %s specifies width %d, but "
-                 "%s requires a width between %d and %d."),
-           io_fmt, str, spec->w, fmt_name (spec->type), min_w, max_w);
+      if (use == FMT_FOR_INPUT)
+        msg (SE, _("Input format %s specifies width %d, but "
+                   "%s requires a width between %d and %d."),
+             str, spec->w, fmt_name (spec->type), min_w, max_w);
+      else
+        msg (SE, _("Output format %s specifies width %d, but "
+                   "%s requires a width between %d and %d."),
+             str, spec->w, fmt_name (spec->type), min_w, max_w);
       return false;
     }
 
   max_d = fmt_max_decimals (spec->type, spec->w, use);
   if (!fmt_takes_decimals (spec->type) && spec->d != 0)
     {
-      msg (SE, ngettext ("%s %s specifies %d decimal place, but "
-                         "%s does not allow any decimals.",
-                         "%s %s specifies %d decimal places, but "
-                         "%s does not allow any decimals.",
-                         spec->d),
-           io_fmt, str, spec->d, fmt_name (spec->type));
+      if (use == FMT_FOR_INPUT)
+        msg (SE, ngettext ("Input format %s specifies %d decimal place, but "
+                           "%s does not allow any decimals.",
+                           "Input format %s specifies %d decimal places, but "
+                           "%s does not allow any decimals.",
+                           spec->d),
+             str, spec->d, fmt_name (spec->type));
+      else
+        msg (SE, ngettext ("Output format %s specifies %d decimal place, but "
+                           "%s does not allow any decimals.",
+                           "Output format %s specifies %d decimal places, but "
+                           "%s does not allow any decimals.",
+                           spec->d),
+             str, spec->d, fmt_name (spec->type));
       return false;
     }
   else if (spec->d > max_d)
     {
       if (max_d > 0)
-        msg (SE, ngettext ("%s %s specifies %d decimal place, but "
-                           "the given width allows at most %d decimals.",
-                           "%s %s specifies %d decimal places, but "
-                           "the given width allows at most %d decimals.",
-                           spec->d),
-             io_fmt, str, spec->d, max_d);
+        {
+          if (use == FMT_FOR_INPUT)
+            msg (SE, ngettext ("Input format %s specifies %d decimal place, "
+                               "but the given width allows at most "
+                               "%d decimals.",
+                               "Input format %s specifies %d decimal places, "
+                               "but the given width allows at most "
+                               "%d decimals.",
+                               spec->d),
+                 str, spec->d, max_d);
+          else
+            msg (SE, ngettext ("Output format %s specifies %d decimal place, "
+                               "but the given width allows at most "
+                               "%d decimals.",
+                               "Output format %s specifies %d decimal places, "
+                               "but the given width allows at most "
+                               "%d decimals.",
+                               spec->d),
+                 str, spec->d, max_d);
+        }
       else
-        msg (SE, ngettext ("%s %s specifies %d decimal place, but "
-                           "the given width does not allow for any decimals.",
-                           "%s %s specifies %d decimal places, but "
-                           "the given width does not allow for any decimals.",
-                           spec->d),
-             io_fmt, str, spec->d);
+        {
+          if (use == FMT_FOR_INPUT)
+            msg (SE, ngettext ("Input format %s specifies %d decimal place, "
+                               "but the given width does not allow "
+                               "for any decimals.",
+                               "Input format %s specifies %d decimal places, "
+                               "but the given width does not allow "
+                               "for any decimals.",
+                               spec->d),
+                 str, spec->d);
+          else
+            msg (SE, ngettext ("Output format %s specifies %d decimal place, "
+                               "but the given width does not allow "
+                               "for any decimals.",
+                               "Output format %s specifies %d decimal places, "
+                               "but the given width does not allow "
+                               "for any decimals.",
+                               spec->d),
+                 str, spec->d);
+        }
       return false;
     }
 
@@ -475,8 +540,10 @@ fmt_equal (const struct fmt_spec *a, const struct fmt_spec *b)
   return a->type == b->type && a->w == b->w && a->d == b->d;
 }
 
-/* Adjusts FMT to be valid for a value of the given WIDTH. */
-void
+/* Adjusts FMT to be valid for a value of the given WIDTH if necessary.
+   If nothing needed to be changed the return value is false
+ */
+bool
 fmt_resize (struct fmt_spec *fmt, int width)
 {
   if ((width > 0) != fmt_is_string (fmt->type))
@@ -494,7 +561,9 @@ fmt_resize (struct fmt_spec *fmt, int width)
   else
     {
       /* Still numeric. */
+      return false;
     }
+  return true;
 }
 
 /* Adjusts FMT's width and decimal places to be valid for USE.  */
@@ -715,6 +784,14 @@ fmt_max_decimals (enum fmt_type type, int width, enum fmt_use use)
       max_d = width - 21;
       break;
 
+    case FMT_YMDHMS:
+      max_d = width - 20;
+      break;
+
+    case FMT_MTIME:
+      max_d = width - 6;
+      break;
+
     case FMT_TIME:
       max_d = width - 9;
       break;
@@ -873,6 +950,40 @@ fmt_from_io (int io, enum fmt_type *fmt_type)
     }
 }
 
+/* Translate U32, which is in the form found in SAV and SPV files, into a
+   format specification, and stores the new specification in *F.
+
+   If LOOSE is false, checks that the format specification is appropriate as an
+   output format for a variable with the given WIDTH and reports an error if
+   not.  If LOOSE is true, instead adjusts the format's width and decimals as
+   necessary to be suitable.
+
+   Return true if successful, false if there was an error.. */
+bool
+fmt_from_u32 (uint32_t u32, int width, bool loose, struct fmt_spec *f)
+{
+  uint8_t raw_type = u32 >> 16;
+  uint8_t w = u32 >> 8;
+  uint8_t d = u32;
+
+  msg_disable ();
+  f->w = w;
+  f->d = d;
+  bool ok = fmt_from_io (raw_type, &f->type);
+  if (ok)
+    {
+      if (loose)
+        fmt_fix_output (f);
+      else
+        ok = fmt_check_output (f);
+    }
+  if (ok)
+    ok = fmt_check_width_compat (f, width);
+  msg_enable ();
+
+  return ok;
+}
+
 /* Returns true if TYPE may be used as an input format,
    false otherwise. */
 bool
@@ -942,9 +1053,19 @@ fmt_date_template (enum fmt_type type, int width)
       s2 = "dd-mmm-yyyy HH:MM:SS";
       break;
 
+    case FMT_YMDHMS:
+      s1 = "yyyy-mm-dd HH:MM";
+      s2 = "yyyy-mm-dd HH:MM:SS";
+      break;
+
+    case FMT_MTIME:
+      s1 = "MM";
+      s2 = "MM:SS";
+      break;
+
     case FMT_TIME:
-      s1 = "H:MM";
-      s2 = "H:MM:SS";
+      s1 = "HH:MM";
+      s2 = "HH:MM:SS";
       break;
 
     case FMT_DTIME:
@@ -986,6 +1107,8 @@ fmt_gui_name (enum fmt_type type)
     case FMT_MOYR:
     case FMT_WKYR:
     case FMT_DATETIME:
+    case FMT_YMDHMS:
+    case FMT_MTIME:
     case FMT_TIME:
     case FMT_DTIME:
     case FMT_WKDAY:
@@ -1060,57 +1183,149 @@ fmt_clamp_width (struct fmt_spec *fmt, enum fmt_use use)
 static void
 fmt_clamp_decimals (struct fmt_spec *fmt, enum fmt_use use)
 {
-  int max_d;
-
-  max_d = fmt_max_decimals (fmt->type, fmt->w, use);
-  if (fmt->d < 0)
-    fmt->d = 0;
-  else if (fmt->d > max_d)
+  int max_d = fmt_max_decimals (fmt->type, fmt->w, use);
+  if (fmt->d > max_d)
     fmt->d = max_d;
 }
 
-/* Sets AFFIX's string value to S, a UTF-8 encoded string. */
-static void
-fmt_affix_set (struct fmt_affix *affix, const char *s)
+static struct fmt_affix
+fmt_affix_clone (const struct fmt_affix *old)
 {
-  affix->s = s[0] == '\0' ? CONST_CAST (char *, "") : xstrdup (s);
-  affix->width = u8_strwidth (CHAR_CAST (const uint8_t *, s), "UTF-8");
+  return (struct fmt_affix) {
+    .s = xstrdup_if_nonnull (old->s),
+    .width = old->width,
+  };
 }
 
 /* Frees data in AFFIX. */
 static void
 fmt_affix_free (struct fmt_affix *affix)
 {
-  if (affix->s[0])
+  if (affix->s)
     free (affix->s);
 }
 
-static void
-fmt_number_style_init (struct fmt_number_style *style)
+/* Find and returns the grouping character in CC_STRING (either '.' or ',') or
+   0 on error. */
+static int
+find_cc_separators (const char *cc_string)
+{
+  /* Count commas and periods.  There must be exactly three of
+     one or the other, except that an apostrophe escapes a
+     following comma or period. */
+  int n_commas = 0;
+  int n_dots = 0;
+  for (const char *p = cc_string; *p; p++)
+    if (*p == ',')
+      n_commas++;
+    else if (*p == '.')
+      n_dots++;
+    else if (*p == '\'' && (p[1] == '.' || p[1] == ',' || p[1] == '\''))
+      p++;
+
+  return (n_commas == 3 ? (n_dots != 3 ? ',' : 0)
+          : n_dots == 3 ? '.'
+          : 0);
+}
+
+/* Extracts a token from IN into a newly allocated string AFFIXP.  Tokens are
+   delimited by GROUPING.  Returns the first character following the token. */
+static struct fmt_affix
+extract_cc_token (const char **sp, int grouping, size_t *extra_bytes)
 {
-  fmt_affix_set (&style->neg_prefix, "");
-  fmt_affix_set (&style->prefix, "");
-  fmt_affix_set (&style->suffix, "");
-  fmt_affix_set (&style->neg_suffix, "");
-  style->decimal = '.';
-  style->grouping = 0;
+  const char *p = *sp;
+  for (; *p && *p != grouping; p++)
+    if (*p == '\'' && p[1] == grouping)
+      p++;
+
+  size_t length = p - *sp;
+  char *affix = xmemdup0 (*sp, length);
+  size_t width = u8_strwidth (CHAR_CAST (const uint8_t *, affix), "UTF-8");
+  if (length > width)
+    *extra_bytes += length - width;
+
+  *sp = p + (*p != 0);
+
+  return (struct fmt_affix) { .s = affix, .width = width };
+}
+
+struct fmt_number_style *
+fmt_number_style_from_string (const char *s)
+{
+  char grouping = find_cc_separators (s);
+  if (!grouping)
+    return NULL;
+
+  size_t extra_bytes = 0;
+  struct fmt_affix neg_prefix = extract_cc_token (&s, grouping, &extra_bytes);
+  struct fmt_affix prefix = extract_cc_token (&s, grouping, &extra_bytes);
+  struct fmt_affix suffix = extract_cc_token (&s, grouping, &extra_bytes);
+  struct fmt_affix neg_suffix = extract_cc_token (&s, grouping, &extra_bytes);
+
+  struct fmt_number_style *style = xmalloc (sizeof *style);
+  *style = (struct fmt_number_style) {
+    .neg_prefix = neg_prefix,
+    .prefix = prefix,
+    .suffix = suffix,
+    .neg_suffix = neg_suffix,
+    .decimal = grouping == '.' ? ',' : '.',
+    .grouping = grouping,
+    .extra_bytes = extra_bytes,
+  };
+  return style;
 }
 
 static void
-fmt_number_style_clone (struct fmt_number_style *new,
-                        const struct fmt_number_style *old)
+format_cc (struct string *out, const char *in, char grouping)
 {
-  fmt_affix_set (&new->neg_prefix, old->neg_prefix.s);
-  fmt_affix_set (&new->prefix, old->prefix.s);
-  fmt_affix_set (&new->suffix, old->suffix.s);
-  fmt_affix_set (&new->neg_suffix, old->neg_suffix.s);
-  new->decimal = old->decimal;
-  new->grouping = old->grouping;
-  new->extra_bytes = old->extra_bytes;
+  while (*in != '\0')
+    {
+      char c = *in++;
+      if (c == grouping || c == '\'')
+        ds_put_byte (out, '\'');
+      else if (c == '"')
+        ds_put_byte (out, '"');
+      ds_put_byte (out, c);
+    }
+}
+
+char *
+fmt_number_style_to_string (const struct fmt_number_style *cc)
+{
+  struct string out = DS_EMPTY_INITIALIZER;
+  format_cc (&out, cc->neg_prefix.s, cc->grouping);
+  ds_put_byte (&out, cc->grouping);
+  format_cc (&out, cc->prefix.s, cc->grouping);
+  ds_put_byte (&out, cc->grouping);
+  format_cc (&out, cc->suffix.s, cc->grouping);
+  ds_put_byte (&out, cc->grouping);
+  format_cc (&out, cc->neg_suffix.s, cc->grouping);
+  return ds_steal_cstr (&out);
+}
+
+struct fmt_number_style *
+fmt_number_style_clone (const struct fmt_number_style *old)
+{
+  if (old)
+    {
+      struct fmt_number_style *new = xmalloc (sizeof *new);
+      *new = (struct fmt_number_style) {
+        .neg_prefix = fmt_affix_clone (&old->neg_prefix),
+        .prefix = fmt_affix_clone (&old->prefix),
+        .suffix = fmt_affix_clone (&old->suffix),
+        .neg_suffix = fmt_affix_clone (&old->neg_suffix),
+        .decimal = old->decimal,
+        .grouping = old->grouping,
+        .extra_bytes = old->extra_bytes,
+      };
+      return new;
+    }
+  else
+    return NULL;
 }
 
 /* Destroys a struct fmt_number_style. */
-static void
+void
 fmt_number_style_destroy (struct fmt_number_style *style)
 {
   if (style != NULL)
@@ -1119,6 +1334,7 @@ fmt_number_style_destroy (struct fmt_number_style *style)
       fmt_affix_free (&style->prefix);
       fmt_affix_free (&style->suffix);
       fmt_affix_free (&style->neg_suffix);
+      free (style);
     }
 }
 
@@ -1153,4 +1369,7 @@ get_fmt_desc (enum fmt_type type)
   return &formats[type];
 }
 
-const struct fmt_spec F_8_0 = {FMT_F, 8, 0};
+const struct fmt_spec F_8_0 = { .type = FMT_F, .w = 8, .d = 0 };
+const struct fmt_spec F_8_2 = { .type = FMT_F, .w = 8, .d = 2 };
+const struct fmt_spec F_4_3 = { .type = FMT_F, .w = 4, .d = 3 };
+const struct fmt_spec F_5_1 = { .type = FMT_F, .w = 5, .d = 1 };