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                        || format->type == FMT_YMDHMS)
 478                 p = stpcpy (p, "****");
 479               else
 480                 goto overflow;
 481             }
 482           else
 483             {
 484               int epoch =  settings_get_epoch ();
 485               int offset = year - epoch;
 486               if (offset < 0 || offset > 99)
 487                 goto overflow;
 488               p += sprintf (p, "%02d", abs (year) % 100);
 489             }
 490           break;
 491         case 'q':
 492           p += sprintf (p, "%d", (month - 1) / 3 + 1);
 493           break;
 494         case 'w':
 495           p += sprintf (p, "%2d", (yday - 1) / 7 + 1);
 496           break;
 497         case 'D':
 498           if (number < 0)
 499             *p++ = '-';
 500           number = fabs (number);
 501           p += c_snprintf (p, 64, "%*.0f", count, floor (number / 60. / 60. / 24.));
 502           number = fmod (number, 60. * 60. * 24.);
 503           break;
 504         case 'H':
 505           if (number < 0)
 506             *p++ = '-';
 507           number = fabs (number);
 508           p += c_snprintf (p, 64, "%0*.0f", count, floor (number / 60. / 60.));
 509           number = fmod (number, 60. * 60.);
 510           break;
 511         case 'M':
 512           if (number < 0)
 513             *p++ = '-';
 514           number = fabs (number);
 515           p += sprintf (p, "%02d", (int) floor (number / 60.));
 516           number = fmod (number, 60.);
 517           excess_width = format->w - (p - tmp);
 518           if (excess_width < 0
 519               || (format->type == FMT_MTIME && excess_width < 3))
 520             goto overflow;
 521           if (excess_width == 3 || excess_width == 4
 522               || (excess_width >= 5 && format->d == 0))
 523             p += sprintf (p, ":%02d", (int) number);
 524           else if (excess_width >= 5)
 525             {
 526               int d = MIN (format->d, excess_width - 4);
 527               int w = d + 3;
 528               c_snprintf (p, 64, ":%0*.*f", w, d, number);
 529               if (settings_get_decimal_char (FMT_F) != '.')
 530                 {
 531                   char *cp = strchr (p, '.');
 532                   if (cp != NULL)
 533                     *cp = settings_get_decimal_char (FMT_F);
 534                 }
 535               p += strlen (p);
 536             }
 537           goto done;
 538         default:
 539           assert (count == 1);
 540           *p++ = ch;
 541           break;
 542         }
 543     }
 544
 545  done:
 546   buf_copy_lpad (output, format->w, tmp, p - tmp, ' ');
 547   output[format->w] = '\0';
 548   return;
 549
 550  overflow:
 551   output_overflow (format, output);
 552   return;
 553
 554  missing:
 555   output_missing (format, output);
 556   return;
 557 }
 558
 559 /* Outputs WKDAY format. */
 560 static void
 561 output_WKDAY (const union value *input, const struct fmt_spec *format,
 562               char *output)
 563 {
 564   static const char *const weekdays[7] =
 565     {
 566       "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY",
 567       "THURSDAY", "FRIDAY", "SATURDAY",
 568     };
 569
 570   if (input->f >= 1 && input->f < 8)
 571     {
 572       buf_copy_str_rpad (output, format->w,
 573                          weekdays[(int) input->f - 1], ' ');
 574       output[format->w] = '\0';
 575     }
 576   else
 577     {
 578       if (input->f != SYSMIS)
 579         msg (ME, _("Weekday number %f is not between 1 and 7."), input->f);
 580       output_missing (format, output);
 581     }
 582
 583 }
 584
 585 /* Outputs MONTH format. */
 586 static void
 587 output_MONTH (const union value *input, const struct fmt_spec *format,
 588               char *output)
 589 {
 590   static const char *const months[12] =
 591     {
 592       "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE",
 593       "JULY", "AUGUST", "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER",
 594     };
 595
 596   if (input->f >= 1 && input->f < 13)
 597     {
 598       buf_copy_str_rpad (output, format->w, months[(int) input->f - 1], ' ');
 599       output[format->w] = '\0';
 600     }
 601   else
 602     {
 603       if (input->f != SYSMIS)
 604         msg (ME, _("Month number %f is not between 1 and 12."), input->f);
 605       output_missing (format, output);
 606     }
 607
 608 }
 609
 610 /* Outputs A format. */
 611 static void
 612 output_A (const union value *input UNUSED,
 613           const struct fmt_spec *format UNUSED, char *output UNUSED)
 614 {
 615   NOT_REACHED ();
 616 }
 617
 618 /* Outputs AHEX format. */
 619 static void
 620 output_AHEX (const union value *input, const struct fmt_spec *format,
 621              char *output)
 622 {
 623   output_hex (value_str (input, format->w / 2), format->w / 2, output);
 624 }
 625 \f
 626 /* Decimal and scientific formatting. */
 627
 628 /* If REQUEST plus the current *WIDTH fits within MAX_WIDTH,
 629    increments *WIDTH by REQUEST and return true.
 630    Otherwise returns false without changing *WIDTH. */
 631 static bool
 632 allocate_space (int request, int max_width, int *width)
 633 {
 634   assert (*width <= max_width);
 635   if (request + *width <= max_width)
 636     {
 637       *width += request;
 638       return true;
 639     }
 640   else
 641     return false;
 642 }
 643
 644 /* Tries to compose the number represented by R, in the style of
 645    FORMAT, into OUTPUT.  Returns true if successful, false on
 646    failure, which occurs if FORMAT's width is too narrow.  If
 647    REQUIRE_AFFIXES is true, then the prefix and suffix specified
 648    by FORMAT's style must be included; otherwise, they may be
 649    omitted to make the number fit. */
 650 static bool
 651 output_decimal (const struct rounder *r, const struct fmt_spec *format,
 652                 bool require_affixes, char *output)
 653 {
 654   const struct fmt_number_style *style =
 655     settings_get_style (format->type);
 656
 657   int decimals;
 658
 659   for (decimals = format->d; decimals >= 0; decimals--)
 660     {
 661       /* Formatted version of magnitude of NUMBER. */
 662       char magnitude[64];
 663
 664       /* Number of digits in MAGNITUDE's integer and fractional parts. */
 665       int integer_digits;
 666
 667       /* Amount of space within the field width already claimed.
 668          Initially this is the width of MAGNITUDE, then it is reduced
 669          in stages as space is allocated to prefixes and suffixes and
 670          grouping characters. */
 671       int width;
 672
 673       /* Include various decorations? */
 674       bool add_neg_prefix;
 675       bool add_affixes;
 676       bool add_grouping;
 677
 678       /* Position in output. */
 679       char *p;
 680
 681       /* Make sure there's room for the number's magnitude, plus
 682          the negative suffix, plus (if negative) the negative
 683          prefix. */
 684       width = rounder_width (r, decimals, &integer_digits, &add_neg_prefix);
 685       width += style->neg_suffix.width;
 686       if (add_neg_prefix)
 687         width += style->neg_prefix.width;
 688       if (width > format->w)
 689         continue;
 690
 691       /* If there's room for the prefix and suffix, allocate
 692          space.  If the affixes are required, but there's no
 693          space, give up. */
 694       add_affixes = allocate_space (fmt_affix_width (style),
 695                                     format->w, &width);
 696       if (!add_affixes && require_affixes)
 697         continue;
 698
 699       /* Check whether we should include grouping characters.
 700          We need room for a complete set or we don't insert any at all.
 701          We don't include grouping characters if decimal places were
 702          requested but they were all dropped. */
 703       add_grouping = (style->grouping != 0
 704                       && integer_digits > 3
 705                       && (format->d == 0 || decimals > 0)
 706                       && allocate_space ((integer_digits - 1) / 3,
 707                                          format->w, &width));
 708
 709       /* Format the number's magnitude. */
 710       rounder_format (r, decimals, magnitude);
 711
 712       /* Assemble number. */
 713       p = output;
 714       if (format->w > width)
 715         p = mempset (p, ' ', format->w - width);
 716       if (add_neg_prefix)
 717         p = stpcpy (p, style->neg_prefix.s);
 718       if (add_affixes)
 719         p = stpcpy (p, style->prefix.s);
 720       if (!add_grouping)
 721         p = mempcpy (p, magnitude, integer_digits);
 722       else
 723         {
 724           int i;
 725           for (i = 0; i < integer_digits; i++)
 726             {
 727               if (i > 0 && (integer_digits - i) % 3 == 0)
 728                 *p++ = style->grouping;
 729               *p++ = magnitude[i];
 730             }
 731         }
 732       if (decimals > 0)
 733         {
 734           *p++ = style->decimal;
 735           p = mempcpy (p, &magnitude[integer_digits + 1], decimals);
 736         }
 737       if (add_affixes)
 738         p = stpcpy (p, style->suffix.s);
 739       if (add_neg_prefix)
 740         p = stpcpy (p, style->neg_suffix.s);
 741       else
 742         p = mempset (p, ' ', style->neg_suffix.width);
 743
 744       assert (p >= output + format->w);
 745       assert (p <= output + format->w + style->extra_bytes);
 746       *p = '\0';
 747
 748       return true;
 749     }
 750   return false;
 751 }
 752
 753 /* Formats NUMBER into OUTPUT in scientific notation according to
 754    the style of the format specified in FORMAT. */
 755 static bool
 756 output_scientific (double number, const struct fmt_spec *format,
 757                    bool require_affixes, char *output)
 758 {
 759   const struct fmt_number_style *style =
 760     settings_get_style (format->type);
 761   int width;
 762   int fraction_width;
 763   bool add_affixes;
 764   char *p;
 765
 766   /* Allocate minimum required space. */
 767   width = 6 + style->neg_suffix.width;
 768   if (number < 0)
 769     width += style->neg_prefix.width;
 770   if (width > format->w)
 771     return false;
 772
 773   /* Check for room for prefix and suffix. */
 774   add_affixes = allocate_space (fmt_affix_width (style), format->w, &width);
 775   if (require_affixes && !add_affixes)
 776     return false;
 777
 778   /* Figure out number of characters we can use for the fraction,
 779      if any.  (If that turns out to be 1, then we'll output a
 780      decimal point without any digits following; that's what the
 781      # flag does in the call to c_snprintf, below.) */
 782   fraction_width = MIN (MIN (format->d + 1, format->w - width), 16);
 783   if (format->type != FMT_E && fraction_width == 1)
 784     fraction_width = 0;
 785   width += fraction_width;
 786
 787   /* Format (except suffix). */
 788   p = output;
 789   if (width < format->w)
 790     p = mempset (p, ' ', format->w - width);
 791   if (number < 0)
 792     p = stpcpy (p, style->neg_prefix.s);
 793   if (add_affixes)
 794     p = stpcpy (p, style->prefix.s);
 795   if (fraction_width > 0)
 796     c_snprintf (p, 64, "%#.*E", fraction_width - 1, fabs (number));
 797   else
 798     c_snprintf (p, 64, "%.0E", fabs (number));
 799
 800   /* The C locale always uses a period `.' as a decimal point.
 801      Translate to comma if necessary. */
 802   if (style->decimal != '.')
 803     {
 804       char *cp = strchr (p, '.');
 805       if (cp != NULL)
 806         *cp = style->decimal;
 807     }
 808
 809   /* Make exponent have exactly three digits, plus sign. */
 810   {
 811     char *cp = strchr (p, 'E') + 1;
 812     long int exponent = strtol (cp, NULL, 10);
 813     if (labs (exponent) > 999)
 814       return false;
 815     sprintf (cp, "%+04ld", exponent);
 816   }
 817
 818   /* Add suffixes. */
 819   p = strchr (p, '\0');
 820   if (add_affixes)
 821     p = stpcpy (p, style->suffix.s);
 822   if (number < 0)
 823     p = stpcpy (p, style->neg_suffix.s);
 824   else
 825     p = mempset (p, ' ', style->neg_suffix.width);
 826
 827   assert (p >= output + format->w);
 828   assert (p <= output + format->w + style->extra_bytes);
 829   *p = '\0';
 830
 831   return true;
 832 }
 833 \f
 834 /* Returns true if the magnitude represented by R should be
 835    rounded up when chopped off at DECIMALS decimal places, false
 836    if it should be rounded down. */
 837 static bool
 838 should_round_up (const struct rounder *r, int decimals)
 839 {
 840   int digit = r->string[r->integer_digits + decimals + 1];
 841   assert (digit >= '0' && digit <= '9');
 842   return digit >= '5';
 843 }
 844
 845 /* Initializes R for formatting the magnitude of NUMBER to no
 846    more than MAX_DECIMAL decimal places. */
 847 static void
 848 rounder_init (struct rounder *r, double number, int max_decimals)
 849 {
 850   assert (fabs (number) < 1e41);
 851   assert (max_decimals >= 0 && max_decimals <= 16);
 852   if (max_decimals == 0)
 853     {
 854       /* Fast path.  No rounding needed.
 855
 856          We append ".00" to the integer representation because
 857          round_up assumes that fractional digits are present.  */
 858       c_snprintf (r->string, 64, "%.0f.00", fabs (round (number)));
 859     }
 860   else
 861     {
 862       /* Slow path.
 863
 864          This is more difficult than it really should be because
 865          we have to make sure that numbers that are exactly
 866          halfway between two representations are always rounded
 867          away from zero.  This is not what sprintf normally does
 868          (usually it rounds to even), so we have to fake it as
 869          best we can, by formatting with extra precision and then
 870          doing the rounding ourselves.
 871
 872          We take up to two rounds to format numbers.  In the
 873          first round, we obtain 2 digits of precision beyond
 874          those requested by the user.  If those digits are
 875          exactly "50", then in a second round we format with as
 876          many digits as are significant in a "double".
 877
 878          It might be better to directly implement our own
 879          floating-point formatting routine instead of relying on
 880          the system's sprintf implementation.  But the classic
 881          Steele and White paper on printing floating-point
 882          numbers does not hint how to do what we want, and it's
 883          not obvious how to change their algorithms to do so.  It
 884          would also be a lot of work. */
 885       c_snprintf (r->string, 64, "%.*f", max_decimals + 2, fabs (number));
 886       if (!strcmp (r->string + strlen (r->string) - 2, "50"))
 887         {
 888           int binary_exponent, decimal_exponent, format_decimals;
 889           frexp (number, &binary_exponent);
 890           decimal_exponent = binary_exponent * 3 / 10;
 891           format_decimals = (DBL_DIG + 1) - decimal_exponent;
 892           if (format_decimals > max_decimals + 2)
 893             c_snprintf (r->string, 64, "%.*f", format_decimals, fabs (number));
 894         }
 895     }
 896
 897   if (r->string[0] == '0')
 898     memmove (r->string, &r->string[1], strlen (r->string));
 899
 900   r->leading_zeros = strspn (r->string, "0.");
 901   r->leading_nines = strspn (r->string, "9.");
 902   r->integer_digits = strchr (r->string, '.') - r->string;
 903   assert (r->integer_digits < 64);
 904   assert (r->integer_digits >= 0);
 905   r->negative = number < 0;
 906 }
 907
 908 /* Returns the number of characters required to format the
 909    magnitude represented by R to DECIMALS decimal places.
 910    The return value includes integer digits and a decimal point
 911    and fractional digits, if any, but it does not include any
 912    negative prefix or suffix or other affixes.
 913
 914    *INTEGER_DIGITS is set to the number of digits before the
 915    decimal point in the output, between 0 and 40.
 916
 917    If R represents a negative number and its rounded
 918    representation would include at least one nonzero digit,
 919    *NEGATIVE is set to true; otherwise, it is set to false. */
 920 static int
 921 rounder_width (const struct rounder *r, int decimals,
 922                int *integer_digits, bool *negative)
 923 {
 924   /* Calculate base measures. */
 925   int width = r->integer_digits;
 926   if (decimals > 0)
 927     width += decimals + 1;
 928   *integer_digits = r->integer_digits;
 929   *negative = r->negative;
 930
 931   /* Rounding can cause adjustments. */
 932   if (should_round_up (r, decimals))
 933     {
 934       /* Rounding up leading 9s adds a new digit (a 1). */
 935       if (r->leading_nines >= width)
 936         {
 937           width++;
 938           ++*integer_digits;
 939         }
 940     }
 941   else
 942     {
 943       /* Rounding down. */
 944       if (r->leading_zeros >= width)
 945         {
 946           /* All digits that remain after rounding are zeros.
 947              Therefore we drop the negative sign. */
 948           *negative = false;
 949           if (r->integer_digits == 0 && decimals == 0)
 950             {
 951               /* No digits at all are left.  We need to display
 952                  at least a single digit (a zero). */
 953               assert (width == 0);
 954               width++;
 955               *integer_digits = 1;
 956             }
 957         }
 958     }
 959   return width;
 960 }
 961
 962 /* Formats the magnitude represented by R into OUTPUT, rounding
 963    to DECIMALS decimal places.  Exactly as many characters as
 964    indicated by rounder_width are written.  No terminating null
 965    is appended. */
 966 static void
 967 rounder_format (const struct rounder *r, int decimals, char *output)
 968 {
 969   int base_width = r->integer_digits + (decimals > 0 ? decimals + 1 : 0);
 970   if (should_round_up (r, decimals))
 971     {
 972       if (r->leading_nines < base_width)
 973         {
 974           /* Rounding up.  This is the common case where rounding
 975              up doesn't add an extra digit. */
 976           char *p;
 977           memcpy (output, r->string, base_width);
 978           for (p = output + base_width - 1; ; p--)
 979             {
 980               assert (p >= output);
 981               if (*p == '9')
 982                 *p = '0';
 983               else if (*p >= '0' && *p <= '8')
 984                 {
 985                   (*p)++;
 986                   break;
 987                 }
 988               else
 989                 assert (*p == '.');
 990             }
 991         }
 992       else
 993         {
 994           /* Rounding up leading 9s causes the result to be a 1
 995              followed by a number of 0s, plus a decimal point. */
 996           char *p = output;
 997           *p++ = '1';
 998           p = mempset (p, '0', r->integer_digits);
 999           if (decimals > 0)
1000             {
1001               *p++ = '.';
1002               p = mempset (p, '0', decimals);
1003             }
1004           assert (p == output + base_width + 1);
1005         }
1006     }
1007   else
1008     {
1009       /* Rounding down. */
1010       if (r->integer_digits != 0 || decimals != 0)
1011         {
1012           /* Common case: just copy the digits. */
1013           memcpy (output, r->string, base_width);
1014         }
1015       else
1016         {
1017           /* No digits remain.  The output is just a zero. */
1018           output[0] = '0';
1019         }
1020     }
1021 }
1022 \f
1023 /* Helper functions. */
1024
1025 /* Returns 10**X. */
1026 static double PURE_FUNCTION
1027 power10 (int x)
1028 {
1029   static const double p[] =
1030     {
1031       1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1032       1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
1033       1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
1034       1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39,
1035       1e40,
1036     };
1037   return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (10.0, x);
1038 }
1039
1040 /* Returns 256**X. */
1041 static double PURE_FUNCTION
1042 power256 (int x)
1043 {
1044   static const double p[] =
1045     {
1046       1.0,
1047       256.0,
1048       65536.0,
1049       16777216.0,
1050       4294967296.0,
1051       1099511627776.0,
1052       281474976710656.0,
1053       72057594037927936.0,
1054       18446744073709551616.0
1055     };
1056   return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (256.0, x);
1057 }
1058
1059 /* Formats non-finite NUMBER into OUTPUT according to the width
1060    given in FORMAT. */
1061 static void
1062 output_infinite (double number, const struct fmt_spec *format, char *output)
1063 {
1064   assert (!isfinite (number));
1065
1066   if (format->w >= 3)
1067     {
1068       const char *s;
1069
1070       if (isnan (number))
1071         s = "NaN";
1072       else if (isinf (number))
1073         s = number > 0 ? "+Infinity" : "-Infinity";
1074       else
1075         s = "Unknown";
1076
1077       buf_copy_str_lpad (output, format->w, s, ' ');
1078     }
1079   else
1080     output_overflow (format, output);
1081
1082   output[format->w] = '\0';
1083 }
1084
1085 /* Formats OUTPUT as a missing value for the given FORMAT. */
1086 static void
1087 output_missing (const struct fmt_spec *format, char *output)
1088 {
1089   memset (output, ' ', format->w);
1090
1091   if (format->type != FMT_N)
1092     {
1093       int dot_ofs = (format->type == FMT_PCT ? 2
1094                      : format->type == FMT_E ? 5
1095                      : 1);
1096       output[MAX (0, format->w - format->d - dot_ofs)] = '.';
1097     }
1098   else
1099     output[format->w - 1] = '.';
1100
1101   output[format->w] = '\0';
1102 }
1103
1104 /* Formats OUTPUT for overflow given FORMAT. */
1105 static void
1106 output_overflow (const struct fmt_spec *format, char *output)
1107 {
1108   memset (output, '*', format->w);
1109   output[format->w] = '\0';
1110 }
1111
1112 /* Converts the integer part of NUMBER to a packed BCD number
1113    with the given number of DIGITS in OUTPUT.  If DIGITS is odd,
1114    the least significant nibble of the final byte in OUTPUT is
1115    set to 0.  Returns true if successful, false if NUMBER is not
1116    representable.  On failure, OUTPUT is cleared to all zero
1117    bytes. */
1118 static bool
1119 output_bcd_integer (double number, int digits, char *output)
1120 {
1121   char decimal[64];
1122
1123   assert (digits < sizeof decimal);
1124
1125   output[DIV_RND_UP (digits, 2)] = '\0';
1126   if (number != SYSMIS
1127       && number >= 0.
1128       && number < power10 (digits)
1129       && c_snprintf (decimal, 64, "%0*.0f", digits, round (number)) == digits)
1130     {
1131       const char *src = decimal;
1132       int i;
1133
1134       for (i = 0; i < digits / 2; i++)
1135         {
1136           int d0 = *src++ - '0';
1137           int d1 = *src++ - '0';
1138           *output++ = (d0 << 4) + d1;
1139         }
1140       if (digits % 2)
1141         *output = (*src - '0') << 4;
1142
1143       return true;
1144     }
1145   else
1146     {
1147       memset (output, 0, DIV_RND_UP (digits, 2));
1148       return false;
1149     }
1150 }
1151
1152 /* Writes VALUE to OUTPUT as a BYTES-byte binary integer of the
1153    given INTEGER_FORMAT. */
1154 static void
1155 output_binary_integer (uint64_t value, int bytes,
1156                        enum integer_format integer_format, char *output)
1157 {
1158   integer_put (value, integer_format, output, bytes);
1159 }
1160
1161 /* Converts the BYTES bytes in DATA to twice as many hexadecimal
1162    digits in OUTPUT. */
1163 static void
1164 output_hex (const void *data_, size_t bytes, char *output)
1165 {
1166   const uint8_t *data = data_;
1167   size_t i;
1168
1169   for (i = 0; i < bytes; i++)
1170     {
1171       static const char hex_digits[] = "0123456789ABCDEF";
1172       *output++ = hex_digits[data[i] >> 4];
1173       *output++ = hex_digits[data[i] & 15];
1174     }
1175   *output = '\0';
1176 }