src/data/data-out.c

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