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