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

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2006, 2009, 2011, 2012, 2013, 2014 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 "data/data-out.h"
  20
  21 #include <ctype.h>
  22 #include <float.h>
  23 #include <math.h>
  24 #include <stdint.h>
  25 #include <stdlib.h>
  26 #include <time.h>
  27 #include <unistr.h>
  28
  29 #include "data/calendar.h"
  30 #include "data/format.h"
  31 #include "data/settings.h"
  32 #include "data/value.h"
  33 #include "libpspp/assertion.h"
  34 #include "libpspp/cast.h"
  35 #include "libpspp/float-format.h"
  36 #include "libpspp/i18n.h"
  37 #include "libpspp/integer-format.h"
  38 #include "libpspp/message.h"
  39 #include "libpspp/misc.h"
  40 #include "libpspp/pool.h"
  41 #include "libpspp/str.h"
  42
  43 #include "gl/minmax.h"
  44 #include "gl/c-snprintf.h"
  45
  46 #include "gettext.h"
  47 #define _(msgid) gettext (msgid)
  48 \f
  49 /* A representation of a number that can be quickly rounded to
  50    any desired number of decimal places (up to a specified
  51    maximum). */
  52 struct rounder
  53   {
  54     char string[64];    /* Magnitude of number with excess precision. */
  55     int integer_digits; /* Number of digits before decimal point. */
  56     int leading_nines;  /* Number of `9's or `.'s at start of string. */
  57     int leading_zeros;  /* Number of `0's or `.'s at start of string. */
  58     bool negative;      /* Is the number negative? */
  59   };
  60
  61 static void rounder_init (struct rounder *, double number, int max_decimals);
  62 static int rounder_width (const struct rounder *, int decimals,
  63                           int *integer_digits, bool *negative);
  64 static void rounder_format (const struct rounder *, int decimals,
  65                             char *output);
  66 \f
  67 typedef void data_out_converter_func (const union value *,
  68                                       const struct fmt_spec *,
  69                                       char *);
  70 #define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) \
  71         static data_out_converter_func output_##METHOD;
  72 #include "format.def"
  73
  74 static bool output_decimal (const struct rounder *, const struct fmt_spec *,
  75                             bool require_affixes, char *);
  76 static bool output_scientific (double, const struct fmt_spec *,
  77                                bool require_affixes, char *);
  78
  79 static double power10 (int) PURE_FUNCTION;
  80 static double power256 (int) PURE_FUNCTION;
  81
  82 static void output_infinite (double, const struct fmt_spec *, char *);
  83 static void output_missing (const struct fmt_spec *, char *);
  84 static void output_overflow (const struct fmt_spec *, char *);
  85 static bool output_bcd_integer (double, int digits, char *);
  86 static void output_binary_integer (uint64_t, int bytes, enum integer_format,
  87                                    char *);
  88 static void output_hex (const void *, size_t bytes, char *);
  89 \f
  90
  91 static data_out_converter_func *const converters[FMT_NUMBER_OF_FORMATS] =
  92     {
  93 #define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) output_##METHOD,
  94 #include "format.def"
  95     };
  96
  97 /* Converts the INPUT value, encoded in INPUT_ENCODING, according to format
  98    specification FORMAT, appending the output to OUTPUT in OUTPUT_ENCODING.
  99    However, binary formats (FMT_P, FMT_PK, FMT_IB, FMT_PIB, FMT_RB) yield the
 100    binary results, which may not be properly encoded for OUTPUT_ENCODING.
 101
 102    VALUE must be the correct width for FORMAT, that is, its width must be
 103    fmt_var_width(FORMAT).
 104
 105    INPUT_ENCODING can normally be obtained by calling dict_get_encoding() on
 106    the dictionary with which INPUT is associated.  ENCODING is only important
 107    when FORMAT's type is FMT_A. */
 108 void
 109 data_out_recode (const union value *input, const char *input_encoding,
 110                  const struct fmt_spec *format,
 111                  struct string *output, const char *output_encoding)
 112 {
 113   assert (fmt_check_output (format));
 114   if (format->type == FMT_A)
 115     {
 116       char *in = CHAR_CAST (char *, value_str (input, format->w));
 117       char *out = recode_string (output_encoding, input_encoding,
 118                                  in, format->w);
 119       ds_put_cstr (output, out);
 120       free (out);
 121     }
 122   else if (fmt_get_category (format->type) == FMT_CAT_BINARY)
 123     converters[format->type] (input, format,
 124                               ds_put_uninit (output, format->w));
 125   else
 126     {
 127       char *utf8_encoded = data_out (input, input_encoding, format);
 128       char *output_encoded = recode_string (output_encoding, UTF8,
 129                                             utf8_encoded, -1);
 130       ds_put_cstr (output, output_encoded);
 131       free (output_encoded);
 132       free (utf8_encoded);
 133     }
 134 }
 135
 136 static char *
 137 binary_to_utf8 (const char *in, struct pool *pool)
 138 {
 139   uint8_t *out = pool_alloc_unaligned (pool, strlen (in) * 2 + 1);
 140   uint8_t *p = out;
 141
 142   while (*in != '\0')
 143     {
 144       uint8_t byte = *in++;
 145       int mblen = u8_uctomb (p, byte, 2);
 146       assert (mblen > 0);
 147       p += mblen;
 148     }
 149   *p = '\0';
 150
 151   return CHAR_CAST (char *, out);
 152 }
 153
 154 /* Converts the INPUT value into a UTF-8 encoded string, according to format
 155    specification FORMAT.
 156
 157    VALUE must be the correct width for FORMAT, that is, its width must be
 158    fmt_var_width(FORMAT).
 159
 160    ENCODING must be the encoding of INPUT.  Normally this can be obtained by
 161    calling dict_get_encoding() on the dictionary with which INPUT is
 162    associated.  ENCODING is only important when FORMAT's type is FMT_A.
 163
 164    The return value is dynamically allocated, and must be freed by the caller.
 165    If POOL is non-null, then the return value is allocated on that pool.  */
 166 char *
 167 data_out_pool (const union value *input, const char *encoding,
 168                const struct fmt_spec *format, struct pool *pool)
 169 {
 170   assert (fmt_check_output (format));
 171   if (format->type == FMT_A)
 172     {
 173       char *in = CHAR_CAST (char *, value_str (input, format->w));
 174       return recode_string_pool (UTF8, encoding, in, format->w, pool);
 175     }
 176   else if (fmt_get_category (format->type) == FMT_CAT_BINARY)
 177     {
 178       char tmp[16];
 179
 180       assert (format->w + 1 <= sizeof tmp);
 181       converters[format->type] (input, format, tmp);
 182       return binary_to_utf8 (tmp, pool);
 183     }
 184   else
 185     {
 186       const struct fmt_number_style *style = settings_get_style (format->type);
 187       size_t size = format->w + style->extra_bytes + 1;
 188       char *output;
 189
 190       output = pool_alloc_unaligned (pool, size);
 191       converters[format->type] (input, format, output);
 192       return output;
 193     }
 194 }
 195
 196 /* Like data_out_pool(), except that for basic numeric formats (F, COMMA, DOT,
 197    COLLAR, PCT, E) and custom currency formats are formatted as wide as
 198    necessary to fully display the selected number of decimal places. */
 199 char *
 200 data_out_stretchy (const union value *input, const char *encoding,
 201                    const struct fmt_spec *format, struct pool *pool)
 202 {
 203
 204   if (fmt_get_category (format->type) & (FMT_CAT_BASIC | FMT_CAT_CUSTOM))
 205     {
 206       const struct fmt_number_style *style = settings_get_style (format->type);
 207       struct fmt_spec wide_format;
 208       char tmp[128];
 209       size_t size;
 210
 211       wide_format.type = format->type;
 212       wide_format.w = 40;
 213       wide_format.d = format->d;
 214
 215       size = format->w + style->extra_bytes + 1;
 216       if (size <= sizeof tmp)
 217         {
 218           output_number (input, &wide_format, tmp);
 219           return pool_strdup (pool, tmp + strspn (tmp, " "));
 220         }
 221     }
 222
 223   return data_out_pool (input, encoding, format, pool);
 224 }
 225
 226 char *
 227 data_out (const union value *input, const char *encoding, const struct fmt_spec *format)
 228 {
 229   return data_out_pool (input, encoding, format, NULL);
 230 }
 231
 232 \f
 233 /* Main conversion functions. */
 234
 235 /* Outputs F, COMMA, DOT, DOLLAR, PCT, E, CCA, CCB, CCC, CCD, and
 236    CCE formats. */
 237 static void
 238 output_number (const union value *input, const struct fmt_spec *format,
 239                char *output)
 240 {
 241   double number = input->f;
 242
 243   if (number == SYSMIS)
 244     output_missing (format, output);
 245   else if (!isfinite (number))
 246     output_infinite (number, format, output);
 247   else
 248     {
 249       if (format->type != FMT_E && fabs (number) < 1.5 * power10 (format->w))
 250         {
 251           struct rounder r;
 252           rounder_init (&r, number, format->d);
 253
 254           if (output_decimal (&r, format, true, output)
 255               || output_scientific (number, format, true, output)
 256               || output_decimal (&r, format, false, output))
 257             return;
 258         }
 259
 260       if (!output_scientific (number, format, false, output))
 261         output_overflow (format, output);
 262     }
 263 }
 264
 265 /* Outputs N format. */
 266 static void
 267 output_N (const union value *input, const struct fmt_spec *format,
 268           char *output)
 269 {
 270   double number = input->f * power10 (format->d);
 271   if (input->f == SYSMIS || number < 0)
 272     output_missing (format, output);
 273   else
 274     {
 275       char buf[128];
 276       number = fabs (round (number));
 277       if (number < power10 (format->w)
 278           && c_snprintf (buf, 128, "%0*.0f", format->w, number) == format->w)
 279         memcpy (output, buf, format->w);
 280       else
 281         output_overflow (format, output);
 282     }
 283
 284   output[format->w] = '\0';
 285 }
 286
 287 /* Outputs Z format. */
 288 static void
 289 output_Z (const union value *input, const struct fmt_spec *format,
 290           char *output)
 291 {
 292   double number = input->f * power10 (format->d);
 293   char buf[128];
 294   if (input->f == SYSMIS)
 295     output_missing (format, output);
 296   else if (fabs (number) < power10 (format->w)
 297            && c_snprintf (buf, 128, "%0*.0f", format->w,
 298                        fabs (round (number))) == format->w)
 299     {
 300       if (number < 0 && strspn (buf, "0") < format->w)
 301         {
 302           char *p = &buf[format->w - 1];
 303           *p = "}JKLMNOPQR"[*p - '0'];
 304         }
 305       memcpy (output, buf, format->w);
 306       output[format->w] = '\0';
 307     }
 308   else
 309     output_overflow (format, output);
 310 }
 311
 312 /* Outputs P format. */
 313 static void
 314 output_P (const union value *input, const struct fmt_spec *format,
 315           char *output)
 316 {
 317   if (output_bcd_integer (fabs (input->f * power10 (format->d)),
 318                           format->w * 2 - 1, output)
 319       && input->f < 0.0)
 320     output[format->w - 1] |= 0xd;
 321   else
 322     output[format->w - 1] |= 0xf;
 323 }
 324
 325 /* Outputs PK format. */
 326 static void
 327 output_PK (const union value *input, const struct fmt_spec *format,
 328            char *output)
 329 {
 330   output_bcd_integer (input->f * power10 (format->d), format->w * 2, output);
 331 }
 332
 333 /* Outputs IB format. */
 334 static void
 335 output_IB (const union value *input, const struct fmt_spec *format,
 336            char *output)
 337 {
 338   double number = round (input->f * power10 (format->d));
 339   if (input->f == SYSMIS
 340       || number >= power256 (format->w) / 2 - 1
 341       || number < -power256 (format->w) / 2)
 342     memset (output, 0, format->w);
 343   else
 344     {
 345       uint64_t integer = fabs (number);
 346       if (number < 0)
 347         integer = -integer;
 348       output_binary_integer (integer, format->w,
 349                              settings_get_output_integer_format (),
 350                              output);
 351     }
 352
 353   output[format->w] = '\0';
 354 }
 355
 356 /* Outputs PIB format. */
 357 static void
 358 output_PIB (const union value *input, const struct fmt_spec *format,
 359             char *output)
 360 {
 361   double number = round (input->f * power10 (format->d));
 362   if (input->f == SYSMIS
 363       || number < 0 || number >= power256 (format->w))
 364     memset (output, 0, format->w);
 365   else
 366     output_binary_integer (number, format->w,
 367                            settings_get_output_integer_format (), output);
 368
 369   output[format->w] = '\0';
 370 }
 371
 372 /* Outputs PIBHEX format. */
 373 static void
 374 output_PIBHEX (const union value *input, const struct fmt_spec *format,
 375                char *output)
 376 {
 377   double number = round (input->f);
 378   if (input->f == SYSMIS)
 379     output_missing (format, output);
 380   else if (input->f < 0 || number >= power256 (format->w / 2))
 381     output_overflow (format, output);
 382   else
 383     {
 384       char tmp[8];
 385       output_binary_integer (number, format->w / 2, INTEGER_MSB_FIRST, tmp);
 386       output_hex (tmp, format->w / 2, output);
 387     }
 388
 389 }
 390
 391 /* Outputs RB format. */
 392 static void
 393 output_RB (const union value *input, const struct fmt_spec *format,
 394            char *output)
 395 {
 396   double d = input->f;
 397   memcpy (output, &d, format->w);
 398
 399   output[format->w] = '\0';
 400 }
 401
 402 /* Outputs RBHEX format. */
 403 static void
 404 output_RBHEX (const union value *input, const struct fmt_spec *format,
 405               char *output)
 406 {
 407   double d = input->f;
 408
 409   output_hex (&d, format->w / 2, output);
 410 }
 411
 412 /* Outputs DATE, ADATE, EDATE, JDATE, SDATE, QYR, MOYR, WKYR,
 413    DATETIME, TIME, and DTIME formats. */
 414 static void
 415 output_date (const union value *input, const struct fmt_spec *format,
 416              char *output)
 417 {
 418   double number = input->f;
 419   int year, month, day, yday;
 420
 421   const char *template = fmt_date_template (format->type, format->w);
 422
 423   char tmp[64];
 424   char *p = tmp;
 425
 426   if (number == SYSMIS)
 427     goto missing;
 428
 429   if (fmt_get_category (format->type) == FMT_CAT_DATE)
 430     {
 431       if (number <= 0)
 432         goto missing;
 433       calendar_offset_to_gregorian (number / 60. / 60. / 24.,
 434                                     &year, &month, &day, &yday);
 435       number = fmod (number, 60. * 60. * 24.);
 436     }
 437   else
 438     year = month = day = yday = 0;
 439
 440   while (*template != '\0')
 441     {
 442       int excess_width;
 443
 444       int ch = *template;
 445       int count = 1;
 446       while (template[count] == ch)
 447         count++;
 448       template += count;
 449
 450       switch (ch)
 451         {
 452         case 'd':
 453           if (count < 3)
 454             p += sprintf (p, "%02d", day);
 455           else
 456             p += sprintf (p, "%03d", yday);
 457           break;
 458         case 'm':
 459           if (count < 3)
 460             p += sprintf (p, "%02d", month);
 461           else
 462             {
 463               static const char *const months[12] =
 464                 {
 465                   "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
 466                   "JUL", "AUG", "SEP", "OCT", "NOV", "DEC",
 467                 };
 468               p = stpcpy (p, months[month - 1]);
 469             }
 470           break;
 471         case 'y':
 472           if (count >= 4)
 473             {
 474               if (year <= 9999)
 475                 p += sprintf (p, "%04d", year);
 476               else if (format->type == FMT_DATETIME)
 477                 p = stpcpy (p, "****");
 478               else
 479                 goto overflow;
 480             }
 481           else
 482             {
 483               int epoch =  settings_get_epoch ();
 484               int offset = year - epoch;
 485               if (offset < 0 || offset > 99)
 486                 goto overflow;
 487               p += sprintf (p, "%02d", abs (year) % 100);
 488             }
 489           break;
 490         case 'q':
 491           p += sprintf (p, "%d", (month - 1) / 3 + 1);
 492           break;
 493         case 'w':
 494           p += sprintf (p, "%2d", (yday - 1) / 7 + 1);
 495           break;
 496         case 'D':
 497           if (number < 0)
 498             *p++ = '-';
 499           number = fabs (number);
 500           p += c_snprintf (p, 64, "%*.0f", count, floor (number / 60. / 60. / 24.));
 501           number = fmod (number, 60. * 60. * 24.);
 502           break;
 503         case 'H':
 504           if (number < 0)
 505             *p++ = '-';
 506           number = fabs (number);
 507           p += c_snprintf (p, 64, "%0*.0f", count, floor (number / 60. / 60.));
 508           number = fmod (number, 60. * 60.);
 509           break;
 510         case 'M':
 511           p += sprintf (p, "%02d", (int) floor (number / 60.));
 512           number = fmod (number, 60.);
 513           excess_width = format->w - (p - tmp);
 514           if (excess_width < 0)
 515             goto overflow;
 516           if (excess_width == 3 || excess_width == 4
 517               || (excess_width >= 5 && format->d == 0))
 518             p += sprintf (p, ":%02d", (int) number);
 519           else if (excess_width >= 5)
 520             {
 521               int d = MIN (format->d, excess_width - 4);
 522               int w = d + 3;
 523               c_snprintf (p, 64, ":%0*.*f", w, d, number);
 524               if (settings_get_decimal_char (FMT_F) != '.')
 525                 {
 526                   char *cp = strchr (p, '.');
 527                   if (cp != NULL)
 528                     *cp = settings_get_decimal_char (FMT_F);
 529                 }
 530               p += strlen (p);
 531             }
 532           goto done;
 533         default:
 534           assert (count == 1);
 535           *p++ = ch;
 536           break;
 537         }
 538     }
 539
 540  done:
 541   buf_copy_lpad (output, format->w, tmp, p - tmp, ' ');
 542   output[format->w] = '\0';
 543   return;
 544
 545  overflow:
 546   output_overflow (format, output);
 547   return;
 548
 549  missing:
 550   output_missing (format, output);
 551   return;
 552 }
 553
 554 /* Outputs WKDAY format. */
 555 static void
 556 output_WKDAY (const union value *input, const struct fmt_spec *format,
 557               char *output)
 558 {
 559   static const char *const weekdays[7] =
 560     {
 561       "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY",
 562       "THURSDAY", "FRIDAY", "SATURDAY",
 563     };
 564
 565   if (input->f >= 1 && input->f < 8)
 566     {
 567       buf_copy_str_rpad (output, format->w,
 568                          weekdays[(int) input->f - 1], ' ');
 569       output[format->w] = '\0';
 570     }
 571   else
 572     {
 573       if (input->f != SYSMIS)
 574         msg (ME, _("Weekday number %f is not between 1 and 7."), input->f);
 575       output_missing (format, output);
 576     }
 577
 578 }
 579
 580 /* Outputs MONTH format. */
 581 static void
 582 output_MONTH (const union value *input, const struct fmt_spec *format,
 583               char *output)
 584 {
 585   static const char *const months[12] =
 586     {
 587       "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE",
 588       "JULY", "AUGUST", "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER",
 589     };
 590
 591   if (input->f >= 1 && input->f < 13)
 592     {
 593       buf_copy_str_rpad (output, format->w, months[(int) input->f - 1], ' ');
 594       output[format->w] = '\0';
 595     }
 596   else
 597     {
 598       if (input->f != SYSMIS)
 599         msg (ME, _("Month number %f is not between 1 and 12."), input->f);
 600       output_missing (format, output);
 601     }
 602
 603 }
 604
 605 /* Outputs A format. */
 606 static void
 607 output_A (const union value *input UNUSED,
 608           const struct fmt_spec *format UNUSED, char *output UNUSED)
 609 {
 610   NOT_REACHED ();
 611 }
 612
 613 /* Outputs AHEX format. */
 614 static void
 615 output_AHEX (const union value *input, const struct fmt_spec *format,
 616              char *output)
 617 {
 618   output_hex (value_str (input, format->w), format->w / 2, output);
 619 }
 620 \f
 621 /* Decimal and scientific formatting. */
 622
 623 /* If REQUEST plus the current *WIDTH fits within MAX_WIDTH,
 624    increments *WIDTH by REQUEST and return true.
 625    Otherwise returns false without changing *WIDTH. */
 626 static bool
 627 allocate_space (int request, int max_width, int *width)
 628 {
 629   assert (*width <= max_width);
 630   if (request + *width <= max_width)
 631     {
 632       *width += request;
 633       return true;
 634     }
 635   else
 636     return false;
 637 }
 638
 639 /* Tries to compose the number represented by R, in the style of
 640    FORMAT, into OUTPUT.  Returns true if successful, false on
 641    failure, which occurs if FORMAT's width is too narrow.  If
 642    REQUIRE_AFFIXES is true, then the prefix and suffix specified
 643    by FORMAT's style must be included; otherwise, they may be
 644    omitted to make the number fit. */
 645 static bool
 646 output_decimal (const struct rounder *r, const struct fmt_spec *format,
 647                 bool require_affixes, char *output)
 648 {
 649   const struct fmt_number_style *style =
 650     settings_get_style (format->type);
 651
 652   int decimals;
 653
 654   for (decimals = format->d; decimals >= 0; decimals--)
 655     {
 656       /* Formatted version of magnitude of NUMBER. */
 657       char magnitude[64];
 658
 659       /* Number of digits in MAGNITUDE's integer and fractional parts. */
 660       int integer_digits;
 661
 662       /* Amount of space within the field width already claimed.
 663          Initially this is the width of MAGNITUDE, then it is reduced
 664          in stages as space is allocated to prefixes and suffixes and
 665          grouping characters. */
 666       int width;
 667
 668       /* Include various decorations? */
 669       bool add_neg_prefix;
 670       bool add_affixes;
 671       bool add_grouping;
 672
 673       /* Position in output. */
 674       char *p;
 675
 676       /* Make sure there's room for the number's magnitude, plus
 677          the negative suffix, plus (if negative) the negative
 678          prefix. */
 679       width = rounder_width (r, decimals, &integer_digits, &add_neg_prefix);
 680       width += style->neg_suffix.width;
 681       if (add_neg_prefix)
 682         width += style->neg_prefix.width;
 683       if (width > format->w)
 684         continue;
 685
 686       /* If there's room for the prefix and suffix, allocate
 687          space.  If the affixes are required, but there's no
 688          space, give up. */
 689       add_affixes = allocate_space (fmt_affix_width (style),
 690                                     format->w, &width);
 691       if (!add_affixes && require_affixes)
 692         continue;
 693
 694       /* Check whether we should include grouping characters.
 695          We need room for a complete set or we don't insert any at all.
 696          We don't include grouping characters if decimal places were
 697          requested but they were all dropped. */
 698       add_grouping = (style->grouping != 0
 699                       && integer_digits > 3
 700                       && (format->d == 0 || decimals > 0)
 701                       && allocate_space ((integer_digits - 1) / 3,
 702                                          format->w, &width));
 703
 704       /* Format the number's magnitude. */
 705       rounder_format (r, decimals, magnitude);
 706
 707       /* Assemble number. */
 708       p = output;
 709       if (format->w > width)
 710         p = mempset (p, ' ', format->w - width);
 711       if (add_neg_prefix)
 712         p = stpcpy (p, style->neg_prefix.s);
 713       if (add_affixes)
 714         p = stpcpy (p, style->prefix.s);
 715       if (!add_grouping)
 716         p = mempcpy (p, magnitude, integer_digits);
 717       else
 718         {
 719           int i;
 720           for (i = 0; i < integer_digits; i++)
 721             {
 722               if (i > 0 && (integer_digits - i) % 3 == 0)
 723                 *p++ = style->grouping;
 724               *p++ = magnitude[i];
 725             }
 726         }
 727       if (decimals > 0)
 728         {
 729           *p++ = style->decimal;
 730           p = mempcpy (p, &magnitude[integer_digits + 1], decimals);
 731         }
 732       if (add_affixes)
 733         p = stpcpy (p, style->suffix.s);
 734       if (add_neg_prefix)
 735         p = stpcpy (p, style->neg_suffix.s);
 736       else
 737         p = mempset (p, ' ', style->neg_suffix.width);
 738
 739       assert (p >= output + format->w);
 740       assert (p <= output + format->w + style->extra_bytes);
 741       *p = '\0';
 742
 743       return true;
 744     }
 745   return false;
 746 }
 747
 748 /* Formats NUMBER into OUTPUT in scientific notation according to
 749    the style of the format specified in FORMAT. */
 750 static bool
 751 output_scientific (double number, const struct fmt_spec *format,
 752                    bool require_affixes, char *output)
 753 {
 754   const struct fmt_number_style *style =
 755     settings_get_style (format->type);
 756   int width;
 757   int fraction_width;
 758   bool add_affixes;
 759   char *p;
 760
 761   /* Allocate minimum required space. */
 762   width = 6 + style->neg_suffix.width;
 763   if (number < 0)
 764     width += style->neg_prefix.width;
 765   if (width > format->w)
 766     return false;
 767
 768   /* Check for room for prefix and suffix. */
 769   add_affixes = allocate_space (fmt_affix_width (style), format->w, &width);
 770   if (require_affixes && !add_affixes)
 771     return false;
 772
 773   /* Figure out number of characters we can use for the fraction,
 774      if any.  (If that turns out to be 1, then we'll output a
 775      decimal point without any digits following; that's what the
 776      # flag does in the call to c_snprintf, below.) */
 777   fraction_width = MIN (MIN (format->d + 1, format->w - width), 16);
 778   if (format->type != FMT_E && fraction_width == 1)
 779     fraction_width = 0;
 780   width += fraction_width;
 781
 782   /* Format (except suffix). */
 783   p = output;
 784   if (width < format->w)
 785     p = mempset (p, ' ', format->w - width);
 786   if (number < 0)
 787     p = stpcpy (p, style->neg_prefix.s);
 788   if (add_affixes)
 789     p = stpcpy (p, style->prefix.s);
 790   if (fraction_width > 0)
 791     c_snprintf (p, 64, "%#.*E", fraction_width - 1, fabs (number));
 792   else
 793     c_snprintf (p, 64, "%.0E", fabs (number));
 794
 795   /* The C locale always uses a period `.' as a decimal point.
 796      Translate to comma if necessary. */
 797   if (style->decimal != '.')
 798     {
 799       char *cp = strchr (p, '.');
 800       if (cp != NULL)
 801         *cp = style->decimal;
 802     }
 803
 804   /* Make exponent have exactly three digits, plus sign. */
 805   {
 806     char *cp = strchr (p, 'E') + 1;
 807     long int exponent = strtol (cp, NULL, 10);
 808     if (abs (exponent) > 999)
 809       return false;
 810     sprintf (cp, "%+04ld", exponent);
 811   }
 812
 813   /* Add suffixes. */
 814   p = strchr (p, '\0');
 815   if (add_affixes)
 816     p = stpcpy (p, style->suffix.s);
 817   if (number < 0)
 818     p = stpcpy (p, style->neg_suffix.s);
 819   else
 820     p = mempset (p, ' ', style->neg_suffix.width);
 821
 822   assert (p >= output + format->w);
 823   assert (p <= output + format->w + style->extra_bytes);
 824   *p = '\0';
 825
 826   return true;
 827 }
 828 \f
 829 /* Returns true if the magnitude represented by R should be
 830    rounded up when chopped off at DECIMALS decimal places, false
 831    if it should be rounded down. */
 832 static bool
 833 should_round_up (const struct rounder *r, int decimals)
 834 {
 835   int digit = r->string[r->integer_digits + decimals + 1];
 836   assert (digit >= '0' && digit <= '9');
 837   return digit >= '5';
 838 }
 839
 840 /* Initializes R for formatting the magnitude of NUMBER to no
 841    more than MAX_DECIMAL decimal places. */
 842 static void
 843 rounder_init (struct rounder *r, double number, int max_decimals)
 844 {
 845   assert (fabs (number) < 1e41);
 846   assert (max_decimals >= 0 && max_decimals <= 16);
 847   if (max_decimals == 0)
 848     {
 849       /* Fast path.  No rounding needed.
 850
 851          We append ".00" to the integer representation because
 852          round_up assumes that fractional digits are present.  */
 853       c_snprintf (r->string, 64, "%.0f.00", fabs (round (number)));
 854     }
 855   else
 856     {
 857       /* Slow path.
 858
 859          This is more difficult than it really should be because
 860          we have to make sure that numbers that are exactly
 861          halfway between two representations are always rounded
 862          away from zero.  This is not what sprintf normally does
 863          (usually it rounds to even), so we have to fake it as
 864          best we can, by formatting with extra precision and then
 865          doing the rounding ourselves.
 866
 867          We take up to two rounds to format numbers.  In the
 868          first round, we obtain 2 digits of precision beyond
 869          those requested by the user.  If those digits are
 870          exactly "50", then in a second round we format with as
 871          many digits as are significant in a "double".
 872
 873          It might be better to directly implement our own
 874          floating-point formatting routine instead of relying on
 875          the system's sprintf implementation.  But the classic
 876          Steele and White paper on printing floating-point
 877          numbers does not hint how to do what we want, and it's
 878          not obvious how to change their algorithms to do so.  It
 879          would also be a lot of work. */
 880       c_snprintf (r->string, 64, "%.*f", max_decimals + 2, fabs (number));
 881       if (!strcmp (r->string + strlen (r->string) - 2, "50"))
 882         {
 883           int binary_exponent, decimal_exponent, format_decimals;
 884           frexp (number, &binary_exponent);
 885           decimal_exponent = binary_exponent * 3 / 10;
 886           format_decimals = (DBL_DIG + 1) - decimal_exponent;
 887           if (format_decimals > max_decimals + 2)
 888             c_snprintf (r->string, 64, "%.*f", format_decimals, fabs (number));
 889         }
 890     }
 891
 892   if (r->string[0] == '0')
 893     memmove (r->string, &r->string[1], strlen (r->string));
 894
 895   r->leading_zeros = strspn (r->string, "0.");
 896   r->leading_nines = strspn (r->string, "9.");
 897   r->integer_digits = strchr (r->string, '.') - r->string;
 898   assert (r->integer_digits < 64);
 899   assert (r->integer_digits >= 0);
 900   r->negative = number < 0;
 901 }
 902
 903 /* Returns the number of characters required to format the
 904    magnitude represented by R to DECIMALS decimal places.
 905    The return value includes integer digits and a decimal point
 906    and fractional digits, if any, but it does not include any
 907    negative prefix or suffix or other affixes.
 908
 909    *INTEGER_DIGITS is set to the number of digits before the
 910    decimal point in the output, between 0 and 40.
 911
 912    If R represents a negative number and its rounded
 913    representation would include at least one nonzero digit,
 914    *NEGATIVE is set to true; otherwise, it is set to false. */
 915 static int
 916 rounder_width (const struct rounder *r, int decimals,
 917                int *integer_digits, bool *negative)
 918 {
 919   /* Calculate base measures. */
 920   int width = r->integer_digits;
 921   if (decimals > 0)
 922     width += decimals + 1;
 923   *integer_digits = r->integer_digits;
 924   *negative = r->negative;
 925
 926   /* Rounding can cause adjustments. */
 927   if (should_round_up (r, decimals))
 928     {
 929       /* Rounding up leading 9s adds a new digit (a 1). */
 930       if (r->leading_nines >= width)
 931         {
 932           width++;
 933           ++*integer_digits;
 934         }
 935     }
 936   else
 937     {
 938       /* Rounding down. */
 939       if (r->leading_zeros >= width)
 940         {
 941           /* All digits that remain after rounding are zeros.
 942              Therefore we drop the negative sign. */
 943           *negative = false;
 944           if (r->integer_digits == 0 && decimals == 0)
 945             {
 946               /* No digits at all are left.  We need to display
 947                  at least a single digit (a zero). */
 948               assert (width == 0);
 949               width++;
 950               *integer_digits = 1;
 951             }
 952         }
 953     }
 954   return width;
 955 }
 956
 957 /* Formats the magnitude represented by R into OUTPUT, rounding
 958    to DECIMALS decimal places.  Exactly as many characters as
 959    indicated by rounder_width are written.  No terminating null
 960    is appended. */
 961 static void
 962 rounder_format (const struct rounder *r, int decimals, char *output)
 963 {
 964   int base_width = r->integer_digits + (decimals > 0 ? decimals + 1 : 0);
 965   if (should_round_up (r, decimals))
 966     {
 967       if (r->leading_nines < base_width)
 968         {
 969           /* Rounding up.  This is the common case where rounding
 970              up doesn't add an extra digit. */
 971           char *p;
 972           memcpy (output, r->string, base_width);
 973           for (p = output + base_width - 1; ; p--)
 974             {
 975               assert (p >= output);
 976               if (*p == '9')
 977                 *p = '0';
 978               else if (*p >= '0' && *p <= '8')
 979                 {
 980                   (*p)++;
 981                   break;
 982                 }
 983               else
 984                 assert (*p == '.');
 985             }
 986         }
 987       else
 988         {
 989           /* Rounding up leading 9s causes the result to be a 1
 990              followed by a number of 0s, plus a decimal point. */
 991           char *p = output;
 992           *p++ = '1';
 993           p = mempset (p, '0', r->integer_digits);
 994           if (decimals > 0)
 995             {
 996               *p++ = '.';
 997               p = mempset (p, '0', decimals);
 998             }
 999           assert (p == output + base_width + 1);
1000         }
1001     }
1002   else
1003     {
1004       /* Rounding down. */
1005       if (r->integer_digits != 0 || decimals != 0)
1006         {
1007           /* Common case: just copy the digits. */
1008           memcpy (output, r->string, base_width);
1009         }
1010       else
1011         {
1012           /* No digits remain.  The output is just a zero. */
1013           output[0] = '0';
1014         }
1015     }
1016 }
1017 \f
1018 /* Helper functions. */
1019
1020 /* Returns 10**X. */
1021 static double PURE_FUNCTION
1022 power10 (int x)
1023 {
1024   static const double p[] =
1025     {
1026       1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1027       1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
1028       1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
1029       1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39,
1030       1e40,
1031     };
1032   return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (10.0, x);
1033 }
1034
1035 /* Returns 256**X. */
1036 static double PURE_FUNCTION
1037 power256 (int x)
1038 {
1039   static const double p[] =
1040     {
1041       1.0,
1042       256.0,
1043       65536.0,
1044       16777216.0,
1045       4294967296.0,
1046       1099511627776.0,
1047       281474976710656.0,
1048       72057594037927936.0,
1049       18446744073709551616.0
1050     };
1051   return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (256.0, x);
1052 }
1053
1054 /* Formats non-finite NUMBER into OUTPUT according to the width
1055    given in FORMAT. */
1056 static void
1057 output_infinite (double number, const struct fmt_spec *format, char *output)
1058 {
1059   assert (!isfinite (number));
1060
1061   if (format->w >= 3)
1062     {
1063       const char *s;
1064
1065       if (isnan (number))
1066         s = "NaN";
1067       else if (isinf (number))
1068         s = number > 0 ? "+Infinity" : "-Infinity";
1069       else
1070         s = "Unknown";
1071
1072       buf_copy_str_lpad (output, format->w, s, ' ');
1073     }
1074   else
1075     output_overflow (format, output);
1076
1077   output[format->w] = '\0';
1078 }
1079
1080 /* Formats OUTPUT as a missing value for the given FORMAT. */
1081 static void
1082 output_missing (const struct fmt_spec *format, char *output)
1083 {
1084   memset (output, ' ', format->w);
1085
1086   if (format->type != FMT_N)
1087     {
1088       int dot_ofs = (format->type == FMT_PCT ? 2
1089                      : format->type == FMT_E ? 5
1090                      : 1);
1091       output[MAX (0, format->w - format->d - dot_ofs)] = '.';
1092     }
1093   else
1094     output[format->w - 1] = '.';
1095
1096   output[format->w] = '\0';
1097 }
1098
1099 /* Formats OUTPUT for overflow given FORMAT. */
1100 static void
1101 output_overflow (const struct fmt_spec *format, char *output)
1102 {
1103   memset (output, '*', format->w);
1104   output[format->w] = '\0';
1105 }
1106
1107 /* Converts the integer part of NUMBER to a packed BCD number
1108    with the given number of DIGITS in OUTPUT.  If DIGITS is odd,
1109    the least significant nibble of the final byte in OUTPUT is
1110    set to 0.  Returns true if successful, false if NUMBER is not
1111    representable.  On failure, OUTPUT is cleared to all zero
1112    bytes. */
1113 static bool
1114 output_bcd_integer (double number, int digits, char *output)
1115 {
1116   char decimal[64];
1117
1118   assert (digits < sizeof decimal);
1119
1120   output[DIV_RND_UP (digits, 2)] = '\0';
1121   if (number != SYSMIS
1122       && number >= 0.
1123       && number < power10 (digits)
1124       && c_snprintf (decimal, 64, "%0*.0f", digits, round (number)) == digits)
1125     {
1126       const char *src = decimal;
1127       int i;
1128
1129       for (i = 0; i < digits / 2; i++)
1130         {
1131           int d0 = *src++ - '0';
1132           int d1 = *src++ - '0';
1133           *output++ = (d0 << 4) + d1;
1134         }
1135       if (digits % 2)
1136         *output = (*src - '0') << 4;
1137
1138       return true;
1139     }
1140   else
1141     {
1142       memset (output, 0, DIV_RND_UP (digits, 2));
1143       return false;
1144     }
1145 }
1146
1147 /* Writes VALUE to OUTPUT as a BYTES-byte binary integer of the
1148    given INTEGER_FORMAT. */
1149 static void
1150 output_binary_integer (uint64_t value, int bytes,
1151                        enum integer_format integer_format, char *output)
1152 {
1153   integer_put (value, integer_format, output, bytes);
1154 }
1155
1156 /* Converts the BYTES bytes in DATA to twice as many hexadecimal
1157    digits in OUTPUT. */
1158 static void
1159 output_hex (const void *data_, size_t bytes, char *output)
1160 {
1161   const uint8_t *data = data_;
1162   size_t i;
1163
1164   for (i = 0; i < bytes; i++)
1165     {
1166       static const char hex_digits[] = "0123456789ABCDEF";
1167       *output++ = hex_digits[data[i] >> 4];
1168       *output++ = hex_digits[data[i] & 15];
1169     }
1170   *output = '\0';
1171 }