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

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