src/data/data-out.c

   1 /* PSPP - computes sample statistics.
   2    Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
   3    Written by Ben Pfaff <blp@gnu.org>.
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18    02110-1301, USA. */
  19
  20 #include <config.h>
  21
  22 #include "data-out.h"
  23
  24 #include <ctype.h>
  25 #include <float.h>
  26 #include <math.h>
  27 #include <stdint.h>
  28 #include <stdlib.h>
  29 #include <time.h>
  30
  31 #include "calendar.h"
  32 #include "format.h"
  33 #include "settings.h"
  34 #include "variable.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 (!isfinite (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   double magnitude = fabs (number);
 318   int year, month, day, yday;
 319
 320   const char *template = fmt_date_template (format->type);
 321   size_t template_width = strlen (template);
 322   int excess_width = format->w - template_width;
 323
 324   char tmp[64];
 325   char *p = tmp;
 326
 327   assert (format->w >= template_width);
 328   if (number == SYSMIS)
 329     goto missing;
 330
 331   if (fmt_get_category (format->type) == FMT_CAT_DATE)
 332     {
 333       if (number <= 0)
 334         goto missing;
 335       calendar_offset_to_gregorian (number / 60. / 60. / 24.,
 336                                     &year, &month, &day, &yday);
 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           p += sprintf (p, "%.0f", floor (magnitude / 60. / 60. / 24.));
 398           break;
 399         case 'h':
 400           if (number < 0)
 401             *p++ = '-';
 402           p += sprintf (p, "%.0f", floor (magnitude / 60. / 60.));
 403           break;
 404         case 'H':
 405           p += sprintf (p, "%02d",
 406                         (int) fmod (floor (magnitude / 60. / 60.), 24.));
 407           break;
 408         case 'M':
 409           p += sprintf (p, "%02d",
 410                         (int) fmod (floor (magnitude / 60.), 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) fmod (magnitude, 60.));
 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, fmod (magnitude, 60.));
 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         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
 662       && (fraction_width == 1
 663           || format->w - width + (style->grouping == 0 && number < 0) <= 2))
 664     fraction_width = 0;
 665   width += fraction_width;
 666
 667   /* Format (except suffix). */
 668   p = buf;
 669   if (width < format->w)
 670     p = mempset (p, ' ', format->w - width);
 671   if (number < 0)
 672     p = mempcpy (p, ss_data (style->neg_prefix),
 673                  ss_length (style->neg_prefix));
 674   if (add_affixes)
 675     p = mempcpy (p, ss_data (style->prefix), ss_length (style->prefix));
 676   if (fraction_width > 0)
 677     sprintf (p, "%#.*E", fraction_width - 1, fabs (number));
 678   else
 679     sprintf (p, "%.0E", fabs (number));
 680
 681   /* The C locale always uses a period `.' as a decimal point.
 682      Translate to comma if necessary. */
 683   if (style->decimal != '.')
 684     {
 685       char *cp = strchr (p, '.');
 686       if (cp != NULL)
 687         *cp = style->decimal;
 688     }
 689
 690   /* Make exponent have exactly three digits, plus sign. */
 691   {
 692     char *cp = strchr (p, 'E') + 1;
 693     long int exponent = strtol (cp, NULL, 10);
 694     if (abs (exponent) > 999)
 695       return false;
 696     sprintf (cp, "%+04ld", exponent);
 697   }
 698
 699   /* Add suffixes. */
 700   p = strchr (p, '\0');
 701   if (add_affixes)
 702     p = mempcpy (p, ss_data (style->suffix), ss_length (style->suffix));
 703   if (number < 0)
 704     p = mempcpy (p, ss_data (style->neg_suffix),
 705                  ss_length (style->neg_suffix));
 706   else
 707     p = mempset (p, ' ', ss_length (style->neg_suffix));
 708
 709   assert (p == buf + format->w);
 710
 711   buf_copy_str_lpad (output, format->w, buf);
 712   return true;
 713 }
 714 \f
 715 #ifndef HAVE_ROUND
 716 /* Return X rounded to the nearest integer,
 717    rounding ties away from zero. */
 718 static double
 719 round (double x)
 720 {
 721   return x >= 0.0 ? floor (x + .5) : ceil (x - .5);
 722 }
 723 #endif /* !HAVE_ROUND */
 724
 725 /* Returns true if the magnitude represented by R should be
 726    rounded up when chopped off at DECIMALS decimal places, false
 727    if it should be rounded down. */
 728 static bool
 729 should_round_up (const struct rounder *r, int decimals)
 730 {
 731   int digit = r->string[r->integer_digits + decimals + 1];
 732   assert (digit >= '0' && digit <= '9');
 733   return digit >= '5';
 734 }
 735
 736 /* Initializes R for formatting the magnitude of NUMBER to no
 737    more than MAX_DECIMAL decimal places. */
 738 static void
 739 rounder_init (struct rounder *r, double number, int max_decimals)
 740 {
 741   assert (fabs (number) < 1e41);
 742   assert (max_decimals >= 0 && max_decimals <= 16);
 743   if (max_decimals == 0)
 744     {
 745       /* Fast path.  No rounding needed.
 746
 747          We append ".00" to the integer representation because
 748          round_up assumes that fractional digits are present.  */
 749       sprintf (r->string, "%.0f.00", fabs (round (number)));
 750     }
 751   else
 752     {
 753       /* Slow path.
 754
 755          This is more difficult than it really should be because
 756          we have to make sure that numbers that are exactly
 757          halfway between two representations are always rounded
 758          away from zero.  This is not what sprintf normally does
 759          (usually it rounds to even), so we have to fake it as
 760          best we can, by formatting with extra precision and then
 761          doing the rounding ourselves.
 762
 763          We take up to two rounds to format numbers.  In the
 764          first round, we obtain 2 digits of precision beyond
 765          those requested by the user.  If those digits are
 766          exactly "50", then in a second round we format with as
 767          many digits as are significant in a "double".
 768
 769          It might be better to directly implement our own
 770          floating-point formatting routine instead of relying on
 771          the system's sprintf implementation.  But the classic
 772          Steele and White paper on printing floating-point
 773          numbers does not hint how to do what we want, and it's
 774          not obvious how to change their algorithms to do so.  It
 775          would also be a lot of work. */
 776       sprintf (r->string, "%.*f", max_decimals + 2, fabs (number));
 777       if (!strcmp (r->string + strlen (r->string) - 2, "50"))
 778         {
 779           int binary_exponent, decimal_exponent, format_decimals;
 780           frexp (number, &binary_exponent);
 781           decimal_exponent = binary_exponent * 3 / 10;
 782           format_decimals = (DBL_DIG + 1) - decimal_exponent;
 783           if (format_decimals > max_decimals + 2)
 784             sprintf (r->string, "%.*f", format_decimals, fabs (number));
 785         }
 786     }
 787
 788   if (r->string[0] == '0')
 789     memmove (r->string, &r->string[1], strlen (r->string));
 790
 791   r->leading_zeros = strspn (r->string, "0.");
 792   r->leading_nines = strspn (r->string, "9.");
 793   r->integer_digits = strchr (r->string, '.') - r->string;
 794   r->negative = number < 0;
 795 }
 796
 797 /* Returns the number of characters required to format the
 798    magnitude represented by R to DECIMALS decimal places.
 799    The return value includes integer digits and a decimal point
 800    and fractional digits, if any, but it does not include any
 801    negative prefix or suffix or other affixes.
 802
 803    *INTEGER_DIGITS is set to the number of digits before the
 804    decimal point in the output, between 0 and 40.
 805
 806    If R represents a negative number and its rounded
 807    representation would include at least one nonzero digit,
 808    *NEGATIVE is set to true; otherwise, it is set to false. */
 809 static int
 810 rounder_width (const struct rounder *r, int decimals,
 811                int *integer_digits, bool *negative)
 812 {
 813   /* Calculate base measures. */
 814   int width = r->integer_digits;
 815   if (decimals > 0)
 816     width += decimals + 1;
 817   *integer_digits = r->integer_digits;
 818   *negative = r->negative;
 819
 820   /* Rounding can cause adjustments. */
 821   if (should_round_up (r, decimals))
 822     {
 823       /* Rounding up leading 9s adds a new digit (a 1). */
 824       if (r->leading_nines >= width)
 825         {
 826           width++;
 827           ++*integer_digits;
 828         }
 829     }
 830   else
 831     {
 832       /* Rounding down. */
 833       if (r->leading_zeros >= width)
 834         {
 835           /* All digits that remain after rounding are zeros.
 836              Therefore we drop the negative sign. */
 837           *negative = false;
 838           if (r->integer_digits == 0 && decimals == 0)
 839             {
 840               /* No digits at all are left.  We need to display
 841                  at least a single digit (a zero). */
 842               assert (width == 0);
 843               width++;
 844               *integer_digits = 1;
 845             }
 846         }
 847     }
 848   return width;
 849 }
 850
 851 /* Formats the magnitude represented by R into OUTPUT, rounding
 852    to DECIMALS decimal places.  Exactly as many characters as
 853    indicated by rounder_width are written.  No terminating null
 854    is appended. */
 855 static void
 856 rounder_format (const struct rounder *r, int decimals, char *output)
 857 {
 858   int base_width = r->integer_digits + (decimals > 0 ? decimals + 1 : 0);
 859   if (should_round_up (r, decimals))
 860     {
 861       if (r->leading_nines < base_width)
 862         {
 863           /* Rounding up.  This is the common case where rounding
 864              up doesn't add an extra digit. */
 865           char *p;
 866           memcpy (output, r->string, base_width);
 867           for (p = output + base_width - 1; ; p--)
 868             {
 869               assert (p >= output);
 870               if (*p == '9')
 871                 *p = '0';
 872               else if (*p >= '0' && *p <= '8')
 873                 {
 874                   (*p)++;
 875                   break;
 876                 }
 877               else
 878                 assert (*p == '.');
 879             }
 880         }
 881       else
 882         {
 883           /* Rounding up leading 9s causes the result to be a 1
 884              followed by a number of 0s, plus a decimal point. */
 885           char *p = output;
 886           *p++ = '1';
 887           p = mempset (p, '0', r->integer_digits);
 888           if (decimals > 0)
 889             {
 890               *p++ = '.';
 891               p = mempset (p, '0', decimals);
 892             }
 893           assert (p == output + base_width + 1);
 894         }
 895     }
 896   else
 897     {
 898       /* Rounding down. */
 899       if (r->integer_digits != 0 || decimals != 0)
 900         {
 901           /* Common case: just copy the digits. */
 902           memcpy (output, r->string, base_width);
 903         }
 904       else
 905         {
 906           /* No digits remain.  The output is just a zero. */
 907           output[0] = '0';
 908         }
 909     }
 910 }
 911 \f
 912 /* Helper functions. */
 913
 914 /* Returns 10**X. */
 915 static double PURE_FUNCTION
 916 power10 (int x)
 917 {
 918   static const double p[] =
 919     {
 920       1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
 921       1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
 922       1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
 923       1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39,
 924       1e40,
 925     };
 926   return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (10.0, x);
 927 }
 928
 929 /* Returns 256**X. */
 930 static double PURE_FUNCTION
 931 power256 (int x)
 932 {
 933   static const double p[] =
 934     {
 935       1.0,
 936       256.0,
 937       65536.0,
 938       16777216.0,
 939       4294967296.0,
 940       1099511627776.0,
 941       281474976710656.0,
 942       72057594037927936.0,
 943       18446744073709551616.0
 944     };
 945   return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (256.0, x);
 946 }
 947
 948 /* Formats non-finite NUMBER into OUTPUT according to the width
 949    given in FORMAT. */
 950 static void
 951 output_infinite (double number, const struct fmt_spec *format, char *output)
 952 {
 953   assert (!isfinite (number));
 954
 955   if (format->w >= 3)
 956     {
 957       const char *s;
 958
 959       if (isnan (number))
 960         s = "NaN";
 961       else if (isinf (number))
 962         s = number > 0 ? "+Infinity" : "-Infinity";
 963       else
 964         s = "Unknown";
 965
 966       buf_copy_str_lpad (output, format->w, s);
 967     }
 968   else
 969     output_overflow (format, output);
 970 }
 971
 972 /* Formats OUTPUT as a missing value for the given FORMAT. */
 973 static void
 974 output_missing (const struct fmt_spec *format, char *output)
 975 {
 976   memset (output, ' ', format->w);
 977
 978   if (format->type != FMT_N)
 979     {
 980       int dot_ofs = (format->type == FMT_PCT ? 2
 981                      : format->type == FMT_E ? 5
 982                      : 1);
 983       output[MAX (0, format->w - format->d - dot_ofs)] = '.';
 984     }
 985   else
 986     output[format->w - 1] = '.';
 987 }
 988
 989 /* Formats OUTPUT for overflow given FORMAT. */
 990 static void
 991 output_overflow (const struct fmt_spec *format, char *output)
 992 {
 993   memset (output, '*', format->w);
 994 }
 995
 996 /* Converts the integer part of NUMBER to a packed BCD number
 997    with the given number of DIGITS in OUTPUT.  If DIGITS is odd,
 998    the least significant nibble of the final byte in OUTPUT is
 999    set to 0.  Returns true if successful, false if NUMBER is not
1000    representable.  On failure, OUTPUT is cleared to all zero
1001    bytes. */
1002 static bool
1003 output_bcd_integer (double number, int digits, char *output)
1004 {
1005   char decimal[64];
1006
1007   assert (digits < sizeof decimal);
1008   if (number != SYSMIS
1009       && number >= 0.
1010       && number < power10 (digits)
1011       && sprintf (decimal, "%0*.0f", digits, round (number)) == digits)
1012     {
1013       const char *src = decimal;
1014       int i;
1015
1016       for (i = 0; i < digits / 2; i++)
1017         {
1018           int d0 = *src++ - '0';
1019           int d1 = *src++ - '0';
1020           *output++ = (d0 << 4) + d1;
1021         }
1022       if (digits % 2)
1023         *output = (*src - '0') << 4;
1024
1025       return true;
1026     }
1027   else
1028     {
1029       memset (output, 0, digits);
1030       return false;
1031     }
1032 }
1033
1034 /* Writes VALUE to OUTPUT as a BYTES-byte binary integer of the
1035    given INTEGER_FORMAT. */
1036 static void
1037 output_binary_integer (uint64_t value, int bytes,
1038                        enum integer_format integer_format, char *output)
1039 {
1040   integer_put (value, integer_format, output, bytes);
1041 }
1042
1043 /* Converts the BYTES bytes in DATA to twice as many hexadecimal
1044    digits in OUTPUT. */
1045 static void
1046 output_hex (const void *data_, size_t bytes, char *output)
1047 {
1048   const uint8_t *data = data_;
1049   size_t i;
1050
1051   for (i = 0; i < bytes; i++)
1052     {
1053       static const char hex_digits[] = "0123456789ABCDEF";
1054       *output++ = hex_digits[data[i] >> 4];
1055       *output++ = hex_digits[data[i] & 15];
1056     }
1057 }