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