pintos-os.org Git - pspp/blob - src/data/format.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2006, 2010, 2011 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include "format.h"
  20
  21 #include <ctype.h>
  22 #include <stdlib.h>
  23 #include <uniwidth.h>
  24
  25 #include "data/identifier.h"
  26 #include "data/settings.h"
  27 #include "data/value.h"
  28 #include "data/variable.h"
  29 #include "libpspp/assertion.h"
  30 #include "libpspp/cast.h"
  31 #include "libpspp/compiler.h"
  32 #include "libpspp/message.h"
  33 #include "libpspp/misc.h"
  34 #include "libpspp/str.h"
  35
  36 #include "gl/minmax.h"
  37 #include "gl/xalloc.h"
  38
  39 #include "gettext.h"
  40 #define _(msgid) gettext (msgid)
  41
  42 struct fmt_settings
  43   {
  44     struct fmt_number_style styles[FMT_NUMBER_OF_FORMATS];
  45   };
  46
  47 bool is_fmt_type (enum fmt_type);
  48
  49 static bool valid_width (enum fmt_type, int width, enum fmt_use);
  50
  51 static int max_digits_for_bytes (int bytes);
  52 static void fmt_clamp_width (struct fmt_spec *, enum fmt_use);
  53 static void fmt_clamp_decimals (struct fmt_spec *, enum fmt_use);
  54
  55 static void fmt_affix_set (struct fmt_affix *, const char *);
  56 static void fmt_affix_free (struct fmt_affix *);
  57
  58 static void fmt_number_style_init (struct fmt_number_style *);
  59 static void fmt_number_style_clone (struct fmt_number_style *,
  60                                     const struct fmt_number_style *);
  61 static void fmt_number_style_destroy (struct fmt_number_style *);
  62
  63 /* Creates and returns a new struct fmt_settings with default format styles. */
  64 struct fmt_settings *
  65 fmt_settings_create (void)
  66 {
  67   struct fmt_settings *settings;
  68   int t;
  69
  70   settings = xzalloc (sizeof *settings);
  71   for (t = 0 ; t < FMT_NUMBER_OF_FORMATS ; ++t )
  72     fmt_number_style_init (&settings->styles[t]);
  73   fmt_settings_set_decimal (settings, '.');
  74
  75   return settings;
  76 }
  77
  78 /* Destroys SETTINGS. */
  79 void
  80 fmt_settings_destroy (struct fmt_settings *settings)
  81 {
  82   if (settings != NULL)
  83     {
  84       int t;
  85
  86       for (t = 0 ; t < FMT_NUMBER_OF_FORMATS ; ++t )
  87         fmt_number_style_destroy (&settings->styles[t]);
  88
  89       free (settings->styles);
  90     }
  91 }
  92
  93 /* Returns a copy of SETTINGS. */
  94 struct fmt_settings *
  95 fmt_settings_clone (const struct fmt_settings *old)
  96 {
  97   struct fmt_settings *new;
  98   int t;
  99
 100   new = xmalloc (sizeof *new);
 101   for (t = 0 ; t < FMT_NUMBER_OF_FORMATS ; ++t )
 102     fmt_number_style_clone (&new->styles[t], &old->styles[t]);
 103
 104   return new;
 105 }
 106
 107 /* Returns the number formatting style associated with the given
 108    format TYPE. */
 109 const struct fmt_number_style *
 110 fmt_settings_get_style (const struct fmt_settings *settings,
 111                         enum fmt_type type)
 112 {
 113   assert (is_fmt_type (type));
 114   return &settings->styles[type];
 115 }
 116
 117 /* Sets the number style for TYPE to have the given DECIMAL and GROUPING
 118    characters, negative prefix NEG_PREFIX, prefix PREFIX, suffix SUFFIX, and
 119    negative suffix NEG_SUFFIX.  All of the strings are UTF-8 encoded. */
 120 void
 121 fmt_settings_set_style (struct fmt_settings *settings, enum fmt_type type,
 122                         char decimal, char grouping,
 123                         const char *neg_prefix, const char *prefix,
 124                         const char *suffix, const char *neg_suffix)
 125 {
 126   struct fmt_number_style *style = &settings->styles[type];
 127   int total_bytes, total_width;
 128
 129   assert (grouping == '.' || grouping == ',' || grouping == 0);
 130   assert (decimal == '.' || decimal == ',');
 131   assert (decimal != grouping);
 132
 133   fmt_number_style_destroy (style);
 134
 135   fmt_affix_set (&style->neg_prefix, neg_prefix);
 136   fmt_affix_set (&style->prefix, prefix);
 137   fmt_affix_set (&style->suffix, suffix);
 138   fmt_affix_set (&style->neg_suffix, neg_suffix);
 139   style->decimal = decimal;
 140   style->grouping = grouping;
 141
 142   total_bytes = (strlen (neg_prefix) + strlen (prefix)
 143                  + strlen (suffix) + strlen (neg_suffix));
 144   total_width = (style->neg_prefix.width + style->prefix.width
 145                  + style->suffix.width + style->neg_suffix.width);
 146   style->extra_bytes = MAX (0, total_bytes - total_width);
 147 }
 148
 149 /* Sets the decimal point character for the settings in S to DECIMAL.
 150
 151    This has no effect on custom currency formats. */
 152 void
 153 fmt_settings_set_decimal (struct fmt_settings *s, char decimal)
 154 {
 155   int grouping = decimal == '.' ? ',' : '.';
 156   assert (decimal == '.' || decimal == ',');
 157
 158   fmt_settings_set_style (s, FMT_F,      decimal,        0, "-",  "",  "", "");
 159   fmt_settings_set_style (s, FMT_E,      decimal,        0, "-",  "",  "", "");
 160   fmt_settings_set_style (s, FMT_COMMA,  decimal, grouping, "-",  "",  "", "");
 161   fmt_settings_set_style (s, FMT_DOT,   grouping,  decimal, "-",  "",  "", "");
 162   fmt_settings_set_style (s, FMT_DOLLAR, decimal, grouping, "-", "$",  "", "");
 163   fmt_settings_set_style (s, FMT_PCT,    decimal,        0, "-",  "", "%", "");
 164 }
 165
 166 /* Returns an input format specification with type TYPE, width W,
 167    and D decimals. */
 168 struct fmt_spec
 169 fmt_for_input (enum fmt_type type, int w, int d)
 170 {
 171   struct fmt_spec f;
 172   f.type = type;
 173   f.w = w;
 174   f.d = d;
 175   assert (fmt_check_input (&f));
 176   return f;
 177 }
 178
 179 /* Returns an output format specification with type TYPE, width
 180    W, and D decimals. */
 181 struct fmt_spec
 182 fmt_for_output (enum fmt_type type, int w, int d)
 183 {
 184   struct fmt_spec f;
 185   f.type = type;
 186   f.w = w;
 187   f.d = d;
 188   assert (fmt_check_output (&f));
 189   return f;
 190 }
 191
 192 /* Returns the output format specifier corresponding to input
 193    format specifier INPUT. */
 194 struct fmt_spec
 195 fmt_for_output_from_input (const struct fmt_spec *input)
 196 {
 197   struct fmt_spec output;
 198
 199   assert (fmt_check_input (input));
 200
 201   output.type = fmt_input_to_output (input->type);
 202   output.w = input->w;
 203   if (output.w > fmt_max_output_width (output.type))
 204     output.w = fmt_max_output_width (output.type);
 205   else if (output.w < fmt_min_output_width (output.type))
 206     output.w = fmt_min_output_width (output.type);
 207   output.d = input->d;
 208
 209   switch (input->type)
 210     {
 211     case FMT_Z:
 212       output.w++;
 213       if (output.d > 0)
 214         output.w++;
 215       break;
 216
 217     case FMT_F:
 218     case FMT_COMMA:
 219     case FMT_DOT:
 220     case FMT_DOLLAR:
 221     case FMT_PCT:
 222       {
 223         const struct fmt_number_style *style =
 224           settings_get_style (input->type);
 225
 226         output.w += fmt_affix_width (style);
 227         if (style->grouping != 0 && input->w - input->d >= 3)
 228           output.w += (input->w - input->d - 1) / 3;
 229         if (output.d > 0)
 230           output.w++;
 231       }
 232       break;
 233
 234     case FMT_N:
 235       if (output.d > 0)
 236         output.w++;
 237       break;
 238
 239     case FMT_E:
 240       output.d = MAX (input->d, 3);
 241       output.w = MAX (input->w, output.d + 7);
 242       break;
 243
 244     case FMT_PIBHEX:
 245       output.w = max_digits_for_bytes (input->w / 2) + 1;
 246       break;
 247
 248     case FMT_RB:
 249     case FMT_RBHEX:
 250       output.w = 8;
 251       output.d = 2;
 252       break;
 253
 254     case FMT_P:
 255     case FMT_PK:
 256       output.w = 2 * input->w + (input->d > 0);
 257       break;
 258
 259     case FMT_IB:
 260     case FMT_PIB:
 261       output.w = max_digits_for_bytes (input->w) + 1;
 262       if (output.d > 0)
 263         output.w++;
 264       break;
 265
 266     case FMT_CCA:
 267     case FMT_CCB:
 268     case FMT_CCC:
 269     case FMT_CCD:
 270     case FMT_CCE:
 271       NOT_REACHED ();
 272
 273     case FMT_A:
 274       break;
 275
 276     case FMT_AHEX:
 277       output.w = input->w / 2;
 278       break;
 279
 280     case FMT_DATE:
 281     case FMT_EDATE:
 282     case FMT_SDATE:
 283     case FMT_ADATE:
 284     case FMT_JDATE:
 285     case FMT_QYR:
 286     case FMT_MOYR:
 287     case FMT_WKYR:
 288     case FMT_TIME:
 289     case FMT_DTIME:
 290     case FMT_DATETIME:
 291     case FMT_WKDAY:
 292     case FMT_MONTH:
 293       break;
 294
 295     default:
 296       NOT_REACHED ();
 297     }
 298
 299   if (output.w > fmt_max_output_width (output.type))
 300     output.w = fmt_max_output_width (output.type);
 301
 302   assert (fmt_check_output (&output));
 303   return output;
 304 }
 305
 306 /* Returns the default format for the given WIDTH: F8.2 format
 307    for a numeric value, A format for a string value. */
 308 struct fmt_spec
 309 fmt_default_for_width (int width)
 310 {
 311   return (width == 0
 312           ? fmt_for_output (FMT_F, 8, 2)
 313           : fmt_for_output (FMT_A, width, 0));
 314 }
 315
 316 /* Checks whether SPEC is valid for USE and returns nonzero if so.
 317    Otherwise, emits an error message and returns zero. */
 318 bool
 319 fmt_check (const struct fmt_spec *spec, enum fmt_use use)
 320 {
 321   const char *io_fmt;
 322   char str[FMT_STRING_LEN_MAX + 1];
 323   int min_w, max_w, max_d;
 324
 325   assert (is_fmt_type (spec->type));
 326   fmt_to_string (spec, str);
 327
 328   io_fmt = use == FMT_FOR_INPUT ? _("Input format") : _("Output format");
 329   if (use == FMT_FOR_INPUT && !fmt_usable_for_input (spec->type))
 330     {
 331       msg (SE, _("Format %s may not be used for input."), str);
 332       return false;
 333     }
 334
 335   if (spec->w % fmt_step_width (spec->type))
 336     {
 337       assert (fmt_step_width (spec->type) == 2);
 338       msg (SE, _("%s specifies width %d, but %s requires an even width."),
 339            str, spec->w, fmt_name (spec->type));
 340       return false;
 341     }
 342
 343   min_w = fmt_min_width (spec->type, use);
 344   max_w = fmt_max_width (spec->type, use);
 345   if (spec->w < min_w || spec->w > max_w)
 346     {
 347       msg (SE, _("%s %s specifies width %d, but "
 348                  "%s requires a width between %d and %d."),
 349            io_fmt, str, spec->w, fmt_name (spec->type), min_w, max_w);
 350       return false;
 351     }
 352
 353   max_d = fmt_max_decimals (spec->type, spec->w, use);
 354   if (!fmt_takes_decimals (spec->type) && spec->d != 0)
 355     {
 356       msg (SE, ngettext ("%s %s specifies %d decimal place, but "
 357                          "%s does not allow any decimals.",
 358                          "%s %s specifies %d decimal places, but "
 359                          "%s does not allow any decimals.",
 360                          spec->d),
 361            io_fmt, str, spec->d, fmt_name (spec->type));
 362       return false;
 363     }
 364   else if (spec->d > max_d)
 365     {
 366       if (max_d > 0)
 367         msg (SE, ngettext ("%s %s specifies %d decimal place, but "
 368                            "the given width allows at most %d decimals.",
 369                            "%s %s specifies %d decimal places, but "
 370                            "the given width allows at most %d decimals.",
 371                            spec->d),
 372              io_fmt, str, spec->d, max_d);
 373       else
 374         msg (SE, ngettext ("%s %s specifies %d decimal place, but "
 375                            "the given width does not allow for any decimals.",
 376                            "%s %s specifies %d decimal places, but "
 377                            "the given width does not allow for any decimals.",
 378                            spec->d),
 379              io_fmt, str, spec->d);
 380       return false;
 381     }
 382
 383   return true;
 384 }
 385
 386 /* Checks whether SPEC is valid as an input format and returns
 387    nonzero if so.  Otherwise, emits an error message and returns
 388    zero. */
 389 bool
 390 fmt_check_input (const struct fmt_spec *spec)
 391 {
 392   return fmt_check (spec, FMT_FOR_INPUT);
 393 }
 394
 395 /* Checks whether SPEC is valid as an output format and returns
 396    true if so.  Otherwise, emits an error message and returns false. */
 397 bool
 398 fmt_check_output (const struct fmt_spec *spec)
 399 {
 400   return fmt_check (spec, FMT_FOR_OUTPUT);
 401 }
 402
 403 /* Checks that FORMAT is appropriate for a variable of the given
 404    VAR_TYPE and returns true if so.  Otherwise returns false and
 405    emits an error message. */
 406 bool
 407 fmt_check_type_compat (const struct fmt_spec *format, enum val_type var_type)
 408 {
 409   assert (val_type_is_valid (var_type));
 410   if ((var_type == VAL_STRING) != (fmt_is_string (format->type) != 0))
 411     {
 412       char str[FMT_STRING_LEN_MAX + 1];
 413       msg (SE, _("%s variables are not compatible with %s format %s."),
 414            var_type == VAL_STRING ? _("String") : _("Numeric"),
 415            var_type == VAL_STRING ? _("numeric") : _("string"),
 416            fmt_to_string (format, str));
 417       return false;
 418     }
 419   return true;
 420 }
 421
 422 /* Checks that FORMAT is appropriate for a variable of the given
 423    WIDTH and returns true if so.  Otherwise returns false and
 424    emits an error message. */
 425 bool
 426 fmt_check_width_compat (const struct fmt_spec *format, int width)
 427 {
 428   if (!fmt_check_type_compat (format, val_type_from_width (width)))
 429     return false;
 430   if (fmt_var_width (format) != width)
 431     {
 432       char str[FMT_STRING_LEN_MAX + 1];
 433       msg (SE, _("String variable with width %d is not compatible with "
 434                  "format %s."),
 435            width, fmt_to_string (format, str));
 436       return false;
 437     }
 438   return true;
 439 }
 440
 441 /* Returns the width corresponding to FORMAT.  The return value
 442    is the width of the `union value's required by FORMAT. */
 443 int
 444 fmt_var_width (const struct fmt_spec *format)
 445 {
 446   return (format->type == FMT_AHEX ? format->w / 2
 447           : format->type == FMT_A ? format->w
 448           : 0);
 449 }
 450
 451 /* Converts F to its string representation (for instance, "F8.2")
 452    in BUFFER.  Returns BUFFER.
 453
 454    If F has decimals, they are included in the output string,
 455    even if F's format type does not allow decimals, to allow
 456    accurately presenting incorrect formats to the user. */
 457 char *
 458 fmt_to_string (const struct fmt_spec *f, char buffer[FMT_STRING_LEN_MAX + 1])
 459 {
 460   if (fmt_takes_decimals (f->type) || f->d > 0)
 461     snprintf (buffer, FMT_STRING_LEN_MAX + 1,
 462               "%s%d.%d", fmt_name (f->type), f->w, f->d);
 463   else
 464     snprintf (buffer, FMT_STRING_LEN_MAX + 1,
 465               "%s%d", fmt_name (f->type), f->w);
 466   return buffer;
 467 }
 468
 469 /* Returns true if A and B are identical formats,
 470    false otherwise. */
 471 bool
 472 fmt_equal (const struct fmt_spec *a, const struct fmt_spec *b)
 473 {
 474   return a->type == b->type && a->w == b->w && a->d == b->d;
 475 }
 476
 477 /* Adjusts FMT to be valid for a value of the given WIDTH. */
 478 void
 479 fmt_resize (struct fmt_spec *fmt, int width)
 480 {
 481   if ((width > 0) != fmt_is_string (fmt->type))
 482     {
 483       /* Changed from numeric to string or vice versa.  Set to
 484          default format for new width. */
 485       *fmt = fmt_default_for_width (width);
 486     }
 487   else if (width > 0)
 488     {
 489       /* Changed width of string.  Preserve format type, adjust
 490          width. */
 491       fmt->w = fmt->type == FMT_AHEX ? width * 2 : width;
 492     }
 493   else
 494     {
 495       /* Still numeric. */
 496     }
 497 }
 498
 499 /* Adjusts FMT's width and decimal places to be valid for USE.  */
 500 void
 501 fmt_fix (struct fmt_spec *fmt, enum fmt_use use)
 502 {
 503   /* Clamp width to those allowed by format. */
 504   fmt_clamp_width (fmt, use);
 505
 506   /* If FMT has more decimal places than allowed, attempt to increase FMT's
 507      width until that number of decimal places can be achieved. */
 508   if (fmt->d > fmt_max_decimals (fmt->type, fmt->w, use)
 509       && fmt_takes_decimals (fmt->type))
 510     {
 511       int max_w = fmt_max_width (fmt->type, use);
 512       for (; fmt->w < max_w; fmt->w++)
 513         if (fmt->d <= fmt_max_decimals (fmt->type, fmt->w, use))
 514           break;
 515     }
 516
 517   /* Clamp decimals to those allowed by format and width. */
 518   fmt_clamp_decimals (fmt, use);
 519 }
 520
 521 /* Adjusts FMT's width and decimal places to be valid for an
 522    input format.  */
 523 void
 524 fmt_fix_input (struct fmt_spec *fmt)
 525 {
 526   fmt_fix (fmt, FMT_FOR_INPUT);
 527 }
 528
 529 /* Adjusts FMT's width and decimal places to be valid for an
 530    output format.  */
 531 void
 532 fmt_fix_output (struct fmt_spec *fmt)
 533 {
 534   fmt_fix (fmt, FMT_FOR_OUTPUT);
 535 }
 536
 537 /* Sets FMT's width to WIDTH (or the nearest width allowed by FMT's type) and
 538    reduces its decimal places as necessary (if necessary) for that width.  */
 539 void
 540 fmt_change_width (struct fmt_spec *fmt, int width, enum fmt_use use)
 541 {
 542   fmt->w = width;
 543   fmt_clamp_width (fmt, use);
 544   fmt_clamp_decimals (fmt, use);
 545 }
 546
 547 /* Sets FMT's decimal places to DECIMALS (or the nearest number of decimal
 548    places allowed by FMT's type) and increases its width as necessary (if
 549    necessary) for that number of decimal places.  */
 550 void
 551 fmt_change_decimals (struct fmt_spec *fmt, int decimals, enum fmt_use use)
 552 {
 553   fmt->d = decimals;
 554   fmt_fix (fmt, use);
 555 }
 556 \f
 557 /* Describes a display format. */
 558 struct fmt_desc
 559   {
 560     char name[9];
 561     int min_input_width, min_output_width;
 562     int io;
 563     enum fmt_category category;
 564   };
 565
 566 static const struct fmt_desc *get_fmt_desc (enum fmt_type type);
 567
 568 /* Returns the name of the given format TYPE. */
 569 const char *
 570 fmt_name (enum fmt_type type)
 571 {
 572   return get_fmt_desc (type)->name;
 573 }
 574
 575 /* Tries to parse NAME as a format type.
 576    If successful, stores the type in *TYPE and returns true.
 577    On failure, returns false. */
 578 bool
 579 fmt_from_name (const char *name, enum fmt_type *type)
 580 {
 581   int i;
 582
 583   for (i = 0; i < FMT_NUMBER_OF_FORMATS; i++)
 584     if (!strcasecmp (name, get_fmt_desc (i)->name))
 585       {
 586         *type = i;
 587         return true;
 588       }
 589   return false;
 590 }
 591
 592 /* Returns true if TYPE accepts decimal places,
 593    false otherwise. */
 594 bool
 595 fmt_takes_decimals (enum fmt_type type)
 596 {
 597   return fmt_max_output_decimals (type, fmt_max_output_width (type)) > 0;
 598 }
 599
 600 /* Returns the minimum width of the given format TYPE for the given USE. */
 601 int
 602 fmt_min_width (enum fmt_type type, enum fmt_use use)
 603 {
 604   return (use == FMT_FOR_INPUT
 605           ? fmt_min_input_width (type)
 606           : fmt_min_output_width (type));
 607 }
 608
 609 /* Returns the maximum width of the given format TYPE,
 610    for input if FOR_INPUT is true,
 611    for output otherwise. */
 612 int
 613 fmt_max_width (enum fmt_type type, enum fmt_use use UNUSED)
 614 {
 615   /* Maximum width is actually invariant of whether the format is
 616      for input or output, so FOR_INPUT is unused. */
 617   assert (is_fmt_type (type));
 618   switch (type)
 619     {
 620     case FMT_P:
 621     case FMT_PK:
 622     case FMT_PIBHEX:
 623     case FMT_RBHEX:
 624       return 16;
 625
 626     case FMT_IB:
 627     case FMT_PIB:
 628     case FMT_RB:
 629       return 8;
 630
 631     case FMT_A:
 632       return MAX_STRING;
 633
 634     case FMT_AHEX:
 635       return 2 * MAX_STRING;
 636
 637     default:
 638       return 40;
 639     }
 640 }
 641
 642 /* Returns the maximum number of decimal places allowed for the
 643    given format TYPE with a width of WIDTH places, for the given USE. */
 644 int
 645 fmt_max_decimals (enum fmt_type type, int width, enum fmt_use use)
 646 {
 647   int max_d;
 648
 649   switch (type)
 650     {
 651     case FMT_F:
 652     case FMT_COMMA:
 653     case FMT_DOT:
 654       max_d = use == FMT_FOR_INPUT ? width : width - 1;
 655       break;
 656
 657     case FMT_DOLLAR:
 658     case FMT_PCT:
 659       max_d = use == FMT_FOR_INPUT ? width : width - 2;
 660       break;
 661
 662     case FMT_E:
 663       max_d = use == FMT_FOR_INPUT ? width : width - 7;
 664       break;
 665
 666     case FMT_CCA:
 667     case FMT_CCB:
 668     case FMT_CCC:
 669     case FMT_CCD:
 670     case FMT_CCE:
 671       assert (use == FMT_FOR_OUTPUT);
 672       max_d = width - 1;
 673       break;
 674
 675     case FMT_N:
 676     case FMT_Z:
 677       max_d = width;
 678       break;
 679
 680     case FMT_P:
 681       max_d = width * 2 - 1;
 682       break;
 683
 684     case FMT_PK:
 685       max_d = width * 2;
 686       break;
 687
 688     case FMT_IB:
 689     case FMT_PIB:
 690       max_d = max_digits_for_bytes (width);
 691       break;
 692
 693     case FMT_PIBHEX:
 694       max_d = 0;
 695       break;
 696
 697     case FMT_RB:
 698     case FMT_RBHEX:
 699       max_d = 16;
 700       break;
 701
 702     case FMT_DATE:
 703     case FMT_ADATE:
 704     case FMT_EDATE:
 705     case FMT_JDATE:
 706     case FMT_SDATE:
 707     case FMT_QYR:
 708     case FMT_MOYR:
 709     case FMT_WKYR:
 710       max_d = 0;
 711       break;
 712
 713     case FMT_DATETIME:
 714       max_d = width - 21;
 715       break;
 716
 717     case FMT_TIME:
 718       max_d = width - 9;
 719       break;
 720
 721     case FMT_DTIME:
 722       max_d = width - 12;
 723       break;
 724
 725     case FMT_WKDAY:
 726     case FMT_MONTH:
 727     case FMT_A:
 728     case FMT_AHEX:
 729       max_d = 0;
 730       break;
 731
 732     default:
 733       NOT_REACHED ();
 734     }
 735
 736   if (max_d < 0)
 737     max_d = 0;
 738   else if (max_d > 16)
 739     max_d = 16;
 740   return max_d;
 741 }
 742
 743 /* Returns the minimum acceptable width for an input field
 744    formatted with the given TYPE. */
 745 int
 746 fmt_min_input_width (enum fmt_type type)
 747 {
 748   return get_fmt_desc (type)->min_input_width;
 749 }
 750
 751 /* Returns the maximum acceptable width for an input field
 752    formatted with the given TYPE. */
 753 int
 754 fmt_max_input_width (enum fmt_type type)
 755 {
 756   return fmt_max_width (type, FMT_FOR_INPUT);
 757 }
 758
 759 /* Returns the maximum number of decimal places allowed in an
 760    input field of the given TYPE and WIDTH. */
 761 int
 762 fmt_max_input_decimals (enum fmt_type type, int width)
 763 {
 764   assert (valid_width (type, width, true));
 765   return fmt_max_decimals (type, width, FMT_FOR_INPUT);
 766 }
 767
 768 /* Returns the minimum acceptable width for an output field
 769    formatted with the given TYPE. */
 770 int
 771 fmt_min_output_width (enum fmt_type type)
 772 {
 773   return get_fmt_desc (type)->min_output_width;
 774 }
 775
 776 /* Returns the maximum acceptable width for an output field
 777    formatted with the given TYPE. */
 778 int
 779 fmt_max_output_width (enum fmt_type type)
 780 {
 781   return fmt_max_width (type, FMT_FOR_OUTPUT);
 782 }
 783
 784 /* Returns the maximum number of decimal places allowed in an
 785    output field of the given TYPE and WIDTH. */
 786 int
 787 fmt_max_output_decimals (enum fmt_type type, int width)
 788 {
 789   assert (valid_width (type, width, false));
 790   return fmt_max_decimals (type, width, FMT_FOR_OUTPUT);
 791 }
 792
 793 /* Returns the width step for a field formatted with the given
 794    TYPE.  Field width must be a multiple of the width step. */
 795 int
 796 fmt_step_width (enum fmt_type type)
 797 {
 798   return (fmt_get_category (type) == FMT_CAT_HEXADECIMAL || type == FMT_AHEX
 799           ? 2 : 1);
 800 }
 801
 802 /* Returns true if TYPE is used for string fields,
 803    false if it is used for numeric fields. */
 804 bool
 805 fmt_is_string (enum fmt_type type)
 806 {
 807   return fmt_get_category (type) == FMT_CAT_STRING;
 808 }
 809
 810 /* Returns true if TYPE is used for numeric fields,
 811    false if it is used for string fields. */
 812 bool
 813 fmt_is_numeric (enum fmt_type type)
 814 {
 815   return !fmt_is_string (type);
 816 }
 817
 818 /* Returns the format TYPE's category.
 819    Each format type is in exactly one category,
 820    and each category's value is bitwise disjoint from every other
 821    category.  Thus, the return value may be tested for equality
 822    or compared bitwise against a mask of FMT_CAT_* values. */
 823 enum fmt_category
 824 fmt_get_category (enum fmt_type type)
 825 {
 826   return get_fmt_desc (type)->category;
 827 }
 828
 829 /* Returns the output format selected by default when TYPE is
 830    used as an input format. */
 831 enum fmt_type
 832 fmt_input_to_output (enum fmt_type type)
 833 {
 834   switch (fmt_get_category (type))
 835     {
 836     case FMT_CAT_STRING:
 837       return FMT_A;
 838
 839     case FMT_CAT_LEGACY:
 840     case FMT_CAT_BINARY:
 841     case FMT_CAT_HEXADECIMAL:
 842       return FMT_F;
 843
 844     default:
 845       return type;
 846     }
 847 }
 848
 849 /* Returns the SPSS format type corresponding to the given PSPP
 850    format type. */
 851 int
 852 fmt_to_io (enum fmt_type type)
 853 {
 854   return get_fmt_desc (type)->io;
 855 }
 856
 857 /* Determines the PSPP format corresponding to the given SPSS
 858    format type.  If successful, sets *FMT_TYPE to the PSPP format
 859    and returns true.  On failure, return false. */
 860 bool
 861 fmt_from_io (int io, enum fmt_type *fmt_type)
 862 {
 863   switch (io)
 864     {
 865 #define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY)     \
 866     case IO:                                          \
 867       *fmt_type = FMT_##NAME;                           \
 868       return true;
 869 #include "format.def"
 870     default:
 871       return false;
 872     }
 873 }
 874
 875 /* Returns true if TYPE may be used as an input format,
 876    false otherwise. */
 877 bool
 878 fmt_usable_for_input (enum fmt_type type)
 879 {
 880   assert (is_fmt_type (type));
 881   return fmt_get_category (type) != FMT_CAT_CUSTOM;
 882 }
 883
 884 /* For time and date formats, returns a template used for input
 885    and output. */
 886 const char *
 887 fmt_date_template (enum fmt_type type)
 888 {
 889   switch (type)
 890     {
 891     case FMT_DATE:
 892       return "dd-mmm-yy";
 893     case FMT_ADATE:
 894       return "mm/dd/yy";
 895     case FMT_EDATE:
 896       return "dd.mm.yy";
 897     case FMT_JDATE:
 898       return "yyddd";
 899     case FMT_SDATE:
 900       return "yy/mm/dd";
 901     case FMT_QYR:
 902       return "q Q yy";
 903     case FMT_MOYR:
 904       return "mmmXyy";
 905     case FMT_WKYR:
 906       return "ww WK yy";
 907     case FMT_DATETIME:
 908       return "dd-mmm-yyyy HH:MM";
 909     case FMT_TIME:
 910       return "H:MM";
 911     case FMT_DTIME:
 912       return "D HH:MM";
 913     default:
 914       NOT_REACHED ();
 915     }
 916 }
 917
 918 /* Returns a string representing the format TYPE for use in a GUI dialog. */
 919 const char *
 920 fmt_gui_name (enum fmt_type type)
 921 {
 922   switch (type)
 923     {
 924     case FMT_F:
 925       return _("Numeric");
 926
 927     case FMT_COMMA:
 928       return _("Comma");
 929
 930     case FMT_DOT:
 931       return _("Dot");
 932
 933     case FMT_E:
 934       return _("Scientific");
 935
 936     case FMT_DATE:
 937     case FMT_EDATE:
 938     case FMT_SDATE:
 939     case FMT_ADATE:
 940     case FMT_JDATE:
 941     case FMT_QYR:
 942     case FMT_MOYR:
 943     case FMT_WKYR:
 944     case FMT_DATETIME:
 945     case FMT_TIME:
 946     case FMT_DTIME:
 947     case FMT_WKDAY:
 948     case FMT_MONTH:
 949       return _("Date");
 950
 951     case FMT_DOLLAR:
 952       return _("Dollar");
 953
 954     case FMT_CCA:
 955     case FMT_CCB:
 956     case FMT_CCC:
 957     case FMT_CCD:
 958     case FMT_CCE:
 959       return _("Custom");
 960
 961     case FMT_A:
 962       return _("String");
 963
 964     default:
 965       return fmt_name (type);
 966     }
 967 }
 968 \f
 969 /* Returns true if TYPE is a valid format type,
 970    false otherwise. */
 971 bool
 972 is_fmt_type (enum fmt_type type)
 973 {
 974   return type < FMT_NUMBER_OF_FORMATS;
 975 }
 976
 977 /* Returns true if WIDTH is a valid width for the given format
 978    TYPE, for the given USE. */
 979 static bool
 980 valid_width (enum fmt_type type, int width, enum fmt_use use)
 981 {
 982   return (width >= fmt_min_width (type, use)
 983           && width <= fmt_max_width (type, use));
 984 }
 985
 986 /* Returns the maximum number of decimal digits in an unsigned
 987    binary number that is BYTES bytes long. */
 988 static int
 989 max_digits_for_bytes (int bytes)
 990 {
 991   int map[8] = {3, 5, 8, 10, 13, 15, 17, 20};
 992   assert (bytes > 0 && bytes <= sizeof map / sizeof *map);
 993   return map[bytes - 1];
 994 }
 995
 996 /* Clamp FMT's width to the range and values allowed by FMT's type. */
 997 static void
 998 fmt_clamp_width (struct fmt_spec *fmt, enum fmt_use use)
 999 {
1000   unsigned int step;
1001   int min_w, max_w;
1002
1003   min_w = fmt_min_width (fmt->type, use);
1004   max_w = fmt_max_width (fmt->type, use);
1005   if (fmt->w < min_w)
1006     fmt->w = min_w;
1007   else if (fmt->w > max_w)
1008     fmt->w = max_w;
1009
1010   /* Round width to step. */
1011   step = fmt_step_width (fmt->type);
1012   fmt->w = ROUND_DOWN (fmt->w, step);
1013 }
1014
1015 /* Clamp FMT's decimal places to the range allowed by FMT's type and width. */
1016 static void
1017 fmt_clamp_decimals (struct fmt_spec *fmt, enum fmt_use use)
1018 {
1019   int max_d;
1020
1021   max_d = fmt_max_decimals (fmt->type, fmt->w, use);
1022   if (fmt->d < 0)
1023     fmt->d = 0;
1024   else if (fmt->d > max_d)
1025     fmt->d = max_d;
1026 }
1027 \f
1028 /* Sets AFFIX's string value to S, a UTF-8 encoded string. */
1029 static void
1030 fmt_affix_set (struct fmt_affix *affix, const char *s)
1031 {
1032   affix->s = s[0] == '\0' ? CONST_CAST (char *, "") : xstrdup (s);
1033   affix->width = u8_strwidth (CHAR_CAST (const uint8_t *, s), "UTF-8");
1034 }
1035
1036 /* Frees data in AFFIX. */
1037 static void
1038 fmt_affix_free (struct fmt_affix *affix)
1039 {
1040   if (affix->s[0])
1041     free (affix->s);
1042 }
1043
1044 static void
1045 fmt_number_style_init (struct fmt_number_style *style)
1046 {
1047   fmt_affix_set (&style->neg_prefix, "");
1048   fmt_affix_set (&style->prefix, "");
1049   fmt_affix_set (&style->suffix, "");
1050   fmt_affix_set (&style->neg_suffix, "");
1051   style->decimal = '.';
1052   style->grouping = 0;
1053 }
1054
1055 static void
1056 fmt_number_style_clone (struct fmt_number_style *new,
1057                         const struct fmt_number_style *old)
1058 {
1059   fmt_affix_set (&new->neg_prefix, old->neg_prefix.s);
1060   fmt_affix_set (&new->prefix, old->prefix.s);
1061   fmt_affix_set (&new->suffix, old->suffix.s);
1062   fmt_affix_set (&new->neg_suffix, old->neg_suffix.s);
1063   new->decimal = old->decimal;
1064   new->grouping = old->grouping;
1065   new->extra_bytes = old->extra_bytes;
1066 }
1067
1068 /* Destroys a struct fmt_number_style. */
1069 static void
1070 fmt_number_style_destroy (struct fmt_number_style *style)
1071 {
1072   if (style != NULL)
1073     {
1074       fmt_affix_free (&style->neg_prefix);
1075       fmt_affix_free (&style->prefix);
1076       fmt_affix_free (&style->suffix);
1077       fmt_affix_free (&style->neg_suffix);
1078     }
1079 }
1080
1081 /* Returns the total width of the standard prefix and suffix for STYLE, in
1082    display columns (e.g. as returned by u8_strwidth()). */
1083 int
1084 fmt_affix_width (const struct fmt_number_style *style)
1085 {
1086   return style->prefix.width + style->suffix.width;
1087 }
1088
1089 /* Returns the total width of the negative prefix and suffix for STYLE, in
1090    display columns (e.g. as returned by u8_strwidth()). */
1091 int
1092 fmt_neg_affix_width (const struct fmt_number_style *style)
1093 {
1094   return style->neg_prefix.width + style->neg_suffix.width;
1095 }
1096
1097 /* Returns the struct fmt_desc for the given format TYPE. */
1098 static const struct fmt_desc *
1099 get_fmt_desc (enum fmt_type type)
1100 {
1101   static const struct fmt_desc formats[FMT_NUMBER_OF_FORMATS] =
1102     {
1103 #define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) \
1104         {#NAME, IMIN, OMIN, IO, CATEGORY},
1105 #include "format.def"
1106     };
1107
1108   assert (is_fmt_type (type));
1109   return &formats[type];
1110 }
1111
1112 const struct fmt_spec F_8_0 = {FMT_F, 8, 0};