src/data/data-out.c

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