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