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

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