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