1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2006, 2009, 2011, 2012, 2013, 2014 Free Software Foundation, Inc.
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.
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.
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/>. */
19 #include "data/data-out.h"
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"
43 #include "gl/minmax.h"
44 #include "gl/c-snprintf.h"
47 #define _(msgid) gettext (msgid)
49 /* A representation of a number that can be quickly rounded to
50 any desired number of decimal places (up to a specified
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? */
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,
67 typedef void data_out_converter_func (const union value *,
68 const struct fmt_spec *,
70 #define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) \
71 static data_out_converter_func output_##METHOD;
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 *);
79 static double power10 (int) PURE_FUNCTION;
80 static double power256 (int) PURE_FUNCTION;
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,
88 static void output_hex (const void *, size_t bytes, char *);
91 static data_out_converter_func *const converters[FMT_NUMBER_OF_FORMATS] =
93 #define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) output_##METHOD,
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.
102 VALUE must be the correct width for FORMAT, that is, its width must be
103 fmt_var_width(FORMAT).
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. */
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)
113 assert (fmt_check_output (format));
114 if (format->type == FMT_A)
116 char *in = CHAR_CAST (char *, value_str (input, format->w));
117 char *out = recode_string (output_encoding, input_encoding,
119 ds_put_cstr (output, out);
122 else if (fmt_get_category (format->type) == FMT_CAT_BINARY)
123 converters[format->type] (input, format,
124 ds_put_uninit (output, format->w));
127 char *utf8_encoded = data_out (input, input_encoding, format);
128 char *output_encoded = recode_string (output_encoding, UTF8,
130 ds_put_cstr (output, output_encoded);
131 free (output_encoded);
137 binary_to_utf8 (const char *in, struct pool *pool)
139 uint8_t *out = pool_alloc_unaligned (pool, strlen (in) * 2 + 1);
144 uint8_t byte = *in++;
145 int mblen = u8_uctomb (p, byte, 2);
151 return CHAR_CAST (char *, out);
154 /* Converts the INPUT value into a UTF-8 encoded string, according to format
155 specification FORMAT.
157 VALUE must be the correct width for FORMAT, that is, its width must be
158 fmt_var_width(FORMAT).
160 INPUT_ENCODING must be the encoding of INPUT. Normally this can be obtained
161 by calling dict_get_encoding() on the dictionary with which INPUT is
162 associated. INPUT_ENCODING is only important when FORMAT's type is FMT_A.
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. */
167 data_out_pool (const union value *input, const char *input_encoding,
168 const struct fmt_spec *format, struct pool *pool)
170 assert (fmt_check_output (format));
171 if (format->type == FMT_A)
173 char *in = CHAR_CAST (char *, value_str (input, format->w));
174 return recode_string_pool (UTF8, input_encoding, in, format->w, pool);
176 else if (fmt_get_category (format->type) == FMT_CAT_BINARY)
180 assert (format->w + 1 <= sizeof tmp);
181 converters[format->type] (input, format, tmp);
182 return binary_to_utf8 (tmp, pool);
186 const struct fmt_number_style *style = settings_get_style (format->type);
187 size_t size = format->w + style->extra_bytes + 1;
190 output = pool_alloc_unaligned (pool, size);
191 converters[format->type] (input, format, output);
196 /* Like data_out_pool(), except that for basic numeric formats (F, COMMA, DOT,
197 COLLAR, PCT, E) and custom currency formats are formatted as wide as
198 necessary to fully display the selected number of decimal places. */
200 data_out_stretchy (const union value *input, const char *encoding,
201 const struct fmt_spec *format, struct pool *pool)
204 if (fmt_get_category (format->type) & (FMT_CAT_BASIC | FMT_CAT_CUSTOM))
206 const struct fmt_number_style *style = settings_get_style (format->type);
207 struct fmt_spec wide_format;
211 wide_format.type = format->type;
213 wide_format.d = format->d;
215 size = format->w + style->extra_bytes + 1;
216 if (size <= sizeof tmp)
218 output_number (input, &wide_format, tmp);
219 return pool_strdup (pool, tmp + strspn (tmp, " "));
223 return data_out_pool (input, encoding, format, pool);
227 data_out (const union value *input, const char *input_encoding,
228 const struct fmt_spec *format)
230 return data_out_pool (input, input_encoding, format, NULL);
234 /* Main conversion functions. */
236 /* Outputs F, COMMA, DOT, DOLLAR, PCT, E, CCA, CCB, CCC, CCD, and
239 output_number (const union value *input, const struct fmt_spec *format,
242 double number = input->f;
244 if (number == SYSMIS)
245 output_missing (format, output);
246 else if (!isfinite (number))
247 output_infinite (number, format, output);
250 if (format->type != FMT_E && fabs (number) < 1.5 * power10 (format->w))
253 rounder_init (&r, number, format->d);
255 if (output_decimal (&r, format, true, output)
256 || output_scientific (number, format, true, output)
257 || output_decimal (&r, format, false, output))
261 if (!output_scientific (number, format, false, output))
262 output_overflow (format, output);
266 /* Outputs N format. */
268 output_N (const union value *input, const struct fmt_spec *format,
271 double number = input->f * power10 (format->d);
272 if (input->f == SYSMIS || number < 0)
273 output_missing (format, output);
277 number = fabs (round (number));
278 if (number < power10 (format->w)
279 && c_snprintf (buf, 128, "%0*.0f", format->w, number) == format->w)
280 memcpy (output, buf, format->w);
282 output_overflow (format, output);
285 output[format->w] = '\0';
288 /* Outputs Z format. */
290 output_Z (const union value *input, const struct fmt_spec *format,
293 double number = input->f * power10 (format->d);
295 if (input->f == SYSMIS)
296 output_missing (format, output);
297 else if (fabs (number) < power10 (format->w)
298 && c_snprintf (buf, 128, "%0*.0f", format->w,
299 fabs (round (number))) == format->w)
301 if (number < 0 && strspn (buf, "0") < format->w)
303 char *p = &buf[format->w - 1];
304 *p = "}JKLMNOPQR"[*p - '0'];
306 memcpy (output, buf, format->w);
307 output[format->w] = '\0';
310 output_overflow (format, output);
313 /* Outputs P format. */
315 output_P (const union value *input, const struct fmt_spec *format,
318 if (output_bcd_integer (fabs (input->f * power10 (format->d)),
319 format->w * 2 - 1, output)
321 output[format->w - 1] |= 0xd;
323 output[format->w - 1] |= 0xf;
326 /* Outputs PK format. */
328 output_PK (const union value *input, const struct fmt_spec *format,
331 output_bcd_integer (input->f * power10 (format->d), format->w * 2, output);
334 /* Outputs IB format. */
336 output_IB (const union value *input, const struct fmt_spec *format,
339 double number = round (input->f * power10 (format->d));
340 if (input->f == SYSMIS
341 || number >= power256 (format->w) / 2 - 1
342 || number < -power256 (format->w) / 2)
343 memset (output, 0, format->w);
346 uint64_t integer = fabs (number);
349 output_binary_integer (integer, format->w,
350 settings_get_output_integer_format (),
354 output[format->w] = '\0';
357 /* Outputs PIB format. */
359 output_PIB (const union value *input, const struct fmt_spec *format,
362 double number = round (input->f * power10 (format->d));
363 if (input->f == SYSMIS
364 || number < 0 || number >= power256 (format->w))
365 memset (output, 0, format->w);
367 output_binary_integer (number, format->w,
368 settings_get_output_integer_format (), output);
370 output[format->w] = '\0';
373 /* Outputs PIBHEX format. */
375 output_PIBHEX (const union value *input, const struct fmt_spec *format,
378 double number = round (input->f);
379 if (input->f == SYSMIS)
380 output_missing (format, output);
381 else if (input->f < 0 || number >= power256 (format->w / 2))
382 output_overflow (format, output);
386 output_binary_integer (number, format->w / 2, INTEGER_MSB_FIRST, tmp);
387 output_hex (tmp, format->w / 2, output);
392 /* Outputs RB format. */
394 output_RB (const union value *input, const struct fmt_spec *format,
398 memcpy (output, &d, format->w);
400 output[format->w] = '\0';
403 /* Outputs RBHEX format. */
405 output_RBHEX (const union value *input, const struct fmt_spec *format,
410 output_hex (&d, format->w / 2, output);
413 /* Outputs DATE, ADATE, EDATE, JDATE, SDATE, QYR, MOYR, WKYR,
414 DATETIME, TIME, and DTIME formats. */
416 output_date (const union value *input, const struct fmt_spec *format,
419 double number = input->f;
420 int year, month, day, yday;
422 const char *template = fmt_date_template (format->type, format->w);
427 if (number == SYSMIS)
430 if (fmt_get_category (format->type) == FMT_CAT_DATE)
434 calendar_offset_to_gregorian (number / 60. / 60. / 24.,
435 &year, &month, &day, &yday);
436 number = fmod (number, 60. * 60. * 24.);
439 year = month = day = yday = 0;
441 while (*template != '\0')
447 while (template[count] == ch)
455 p += sprintf (p, "%02d", day);
457 p += sprintf (p, "%03d", yday);
461 p += sprintf (p, "%02d", month);
464 static const char *const months[12] =
466 "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
467 "JUL", "AUG", "SEP", "OCT", "NOV", "DEC",
469 p = stpcpy (p, months[month - 1]);
476 p += sprintf (p, "%04d", year);
477 else if (format->type == FMT_DATETIME
478 || format->type == FMT_YMDHMS)
479 p = stpcpy (p, "****");
485 int epoch = settings_get_epoch ();
486 int offset = year - epoch;
487 if (offset < 0 || offset > 99)
489 p += sprintf (p, "%02d", abs (year) % 100);
493 p += sprintf (p, "%d", (month - 1) / 3 + 1);
496 p += sprintf (p, "%2d", (yday - 1) / 7 + 1);
501 number = fabs (number);
502 p += c_snprintf (p, 64, "%*.0f", count, floor (number / 60. / 60. / 24.));
503 number = fmod (number, 60. * 60. * 24.);
508 number = fabs (number);
509 p += c_snprintf (p, 64, "%0*.0f", count, floor (number / 60. / 60.));
510 number = fmod (number, 60. * 60.);
515 number = fabs (number);
516 p += sprintf (p, "%02d", (int) floor (number / 60.));
517 number = fmod (number, 60.);
518 excess_width = format->w - (p - tmp);
520 || (format->type == FMT_MTIME && excess_width < 3))
522 if (excess_width == 3 || excess_width == 4
523 || (excess_width >= 5 && format->d == 0))
524 p += sprintf (p, ":%02d", (int) number);
525 else if (excess_width >= 5)
527 int d = MIN (format->d, excess_width - 4);
529 c_snprintf (p, 64, ":%0*.*f", w, d, number);
530 if (settings_get_decimal_char (FMT_F) != '.')
532 char *cp = strchr (p, '.');
534 *cp = settings_get_decimal_char (FMT_F);
547 buf_copy_lpad (output, format->w, tmp, p - tmp, ' ');
548 output[format->w] = '\0';
552 output_overflow (format, output);
556 output_missing (format, output);
560 /* Outputs WKDAY format. */
562 output_WKDAY (const union value *input, const struct fmt_spec *format,
565 static const char *const weekdays[7] =
567 "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY",
568 "THURSDAY", "FRIDAY", "SATURDAY",
571 if (input->f >= 1 && input->f < 8)
573 buf_copy_str_rpad (output, format->w,
574 weekdays[(int) input->f - 1], ' ');
575 output[format->w] = '\0';
579 if (input->f != SYSMIS)
580 msg (ME, _("Weekday number %f is not between 1 and 7."), input->f);
581 output_missing (format, output);
586 /* Outputs MONTH format. */
588 output_MONTH (const union value *input, const struct fmt_spec *format,
591 static const char *const months[12] =
593 "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE",
594 "JULY", "AUGUST", "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER",
597 if (input->f >= 1 && input->f < 13)
599 buf_copy_str_rpad (output, format->w, months[(int) input->f - 1], ' ');
600 output[format->w] = '\0';
604 if (input->f != SYSMIS)
605 msg (ME, _("Month number %f is not between 1 and 12."), input->f);
606 output_missing (format, output);
611 /* Outputs A format. */
613 output_A (const union value *input UNUSED,
614 const struct fmt_spec *format UNUSED, char *output UNUSED)
619 /* Outputs AHEX format. */
621 output_AHEX (const union value *input, const struct fmt_spec *format,
624 output_hex (value_str (input, format->w / 2), format->w / 2, output);
627 /* Decimal and scientific formatting. */
629 /* If REQUEST plus the current *WIDTH fits within MAX_WIDTH,
630 increments *WIDTH by REQUEST and return true.
631 Otherwise returns false without changing *WIDTH. */
633 allocate_space (int request, int max_width, int *width)
635 assert (*width <= max_width);
636 if (request + *width <= max_width)
645 /* Tries to compose the number represented by R, in the style of
646 FORMAT, into OUTPUT. Returns true if successful, false on
647 failure, which occurs if FORMAT's width is too narrow. If
648 REQUIRE_AFFIXES is true, then the prefix and suffix specified
649 by FORMAT's style must be included; otherwise, they may be
650 omitted to make the number fit. */
652 output_decimal (const struct rounder *r, const struct fmt_spec *format,
653 bool require_affixes, char *output)
655 const struct fmt_number_style *style =
656 settings_get_style (format->type);
660 for (decimals = format->d; decimals >= 0; decimals--)
662 /* Formatted version of magnitude of NUMBER. */
665 /* Number of digits in MAGNITUDE's integer and fractional parts. */
668 /* Amount of space within the field width already claimed.
669 Initially this is the width of MAGNITUDE, then it is reduced
670 in stages as space is allocated to prefixes and suffixes and
671 grouping characters. */
674 /* Include various decorations? */
679 /* Position in output. */
682 /* Make sure there's room for the number's magnitude, plus
683 the negative suffix, plus (if negative) the negative
685 width = rounder_width (r, decimals, &integer_digits, &add_neg_prefix);
686 width += style->neg_suffix.width;
688 width += style->neg_prefix.width;
689 if (width > format->w)
692 /* If there's room for the prefix and suffix, allocate
693 space. If the affixes are required, but there's no
695 add_affixes = allocate_space (fmt_affix_width (style),
697 if (!add_affixes && require_affixes)
700 /* Check whether we should include grouping characters.
701 We need room for a complete set or we don't insert any at all.
702 We don't include grouping characters if decimal places were
703 requested but they were all dropped. */
704 add_grouping = (style->grouping != 0
705 && integer_digits > 3
706 && (format->d == 0 || decimals > 0)
707 && allocate_space ((integer_digits - 1) / 3,
710 /* Format the number's magnitude. */
711 rounder_format (r, decimals, magnitude);
713 /* Assemble number. */
715 if (format->w > width)
716 p = mempset (p, ' ', format->w - width);
718 p = stpcpy (p, style->neg_prefix.s);
720 p = stpcpy (p, style->prefix.s);
722 p = mempcpy (p, magnitude, integer_digits);
726 for (i = 0; i < integer_digits; i++)
728 if (i > 0 && (integer_digits - i) % 3 == 0)
729 *p++ = style->grouping;
735 *p++ = style->decimal;
736 p = mempcpy (p, &magnitude[integer_digits + 1], decimals);
739 p = stpcpy (p, style->suffix.s);
741 p = stpcpy (p, style->neg_suffix.s);
743 p = mempset (p, ' ', style->neg_suffix.width);
745 assert (p >= output + format->w);
746 assert (p <= output + format->w + style->extra_bytes);
754 /* Formats NUMBER into OUTPUT in scientific notation according to
755 the style of the format specified in FORMAT. */
757 output_scientific (double number, const struct fmt_spec *format,
758 bool require_affixes, char *output)
760 const struct fmt_number_style *style =
761 settings_get_style (format->type);
767 /* Allocate minimum required space. */
768 width = 6 + style->neg_suffix.width;
770 width += style->neg_prefix.width;
771 if (width > format->w)
774 /* Check for room for prefix and suffix. */
775 add_affixes = allocate_space (fmt_affix_width (style), format->w, &width);
776 if (require_affixes && !add_affixes)
779 /* Figure out number of characters we can use for the fraction,
780 if any. (If that turns out to be 1, then we'll output a
781 decimal point without any digits following; that's what the
782 # flag does in the call to c_snprintf, below.) */
783 fraction_width = MIN (MIN (format->d + 1, format->w - width), 16);
784 if (format->type != FMT_E && fraction_width == 1)
786 width += fraction_width;
788 /* Format (except suffix). */
790 if (width < format->w)
791 p = mempset (p, ' ', format->w - width);
793 p = stpcpy (p, style->neg_prefix.s);
795 p = stpcpy (p, style->prefix.s);
796 if (fraction_width > 0)
797 c_snprintf (p, 64, "%#.*E", fraction_width - 1, fabs (number));
799 c_snprintf (p, 64, "%.0E", fabs (number));
801 /* The C locale always uses a period `.' as a decimal point.
802 Translate to comma if necessary. */
803 if (style->decimal != '.')
805 char *cp = strchr (p, '.');
807 *cp = style->decimal;
810 /* Make exponent have exactly three digits, plus sign. */
812 char *cp = strchr (p, 'E') + 1;
813 long int exponent = strtol (cp, NULL, 10);
814 if (labs (exponent) > 999)
816 sprintf (cp, "%+04ld", exponent);
820 p = strchr (p, '\0');
822 p = stpcpy (p, style->suffix.s);
824 p = stpcpy (p, style->neg_suffix.s);
826 p = mempset (p, ' ', style->neg_suffix.width);
828 assert (p >= output + format->w);
829 assert (p <= output + format->w + style->extra_bytes);
835 /* Returns true if the magnitude represented by R should be
836 rounded up when chopped off at DECIMALS decimal places, false
837 if it should be rounded down. */
839 should_round_up (const struct rounder *r, int decimals)
841 int digit = r->string[r->integer_digits + decimals + 1];
842 assert (digit >= '0' && digit <= '9');
846 /* Initializes R for formatting the magnitude of NUMBER to no
847 more than MAX_DECIMAL decimal places. */
849 rounder_init (struct rounder *r, double number, int max_decimals)
851 assert (fabs (number) < 1e41);
852 assert (max_decimals >= 0 && max_decimals <= 16);
853 if (max_decimals == 0)
855 /* Fast path. No rounding needed.
857 We append ".00" to the integer representation because
858 round_up assumes that fractional digits are present. */
859 c_snprintf (r->string, 64, "%.0f.00", fabs (round (number)));
865 This is more difficult than it really should be because
866 we have to make sure that numbers that are exactly
867 halfway between two representations are always rounded
868 away from zero. This is not what sprintf normally does
869 (usually it rounds to even), so we have to fake it as
870 best we can, by formatting with extra precision and then
871 doing the rounding ourselves.
873 We take up to two rounds to format numbers. In the
874 first round, we obtain 2 digits of precision beyond
875 those requested by the user. If those digits are
876 exactly "50", then in a second round we format with as
877 many digits as are significant in a "double".
879 It might be better to directly implement our own
880 floating-point formatting routine instead of relying on
881 the system's sprintf implementation. But the classic
882 Steele and White paper on printing floating-point
883 numbers does not hint how to do what we want, and it's
884 not obvious how to change their algorithms to do so. It
885 would also be a lot of work. */
886 c_snprintf (r->string, 64, "%.*f", max_decimals + 2, fabs (number));
887 if (!strcmp (r->string + strlen (r->string) - 2, "50"))
889 int binary_exponent, decimal_exponent, format_decimals;
890 frexp (number, &binary_exponent);
891 decimal_exponent = binary_exponent * 3 / 10;
892 format_decimals = (DBL_DIG + 1) - decimal_exponent;
893 if (format_decimals > max_decimals + 2)
894 c_snprintf (r->string, 64, "%.*f", format_decimals, fabs (number));
898 if (r->string[0] == '0')
899 memmove (r->string, &r->string[1], strlen (r->string));
901 r->leading_zeros = strspn (r->string, "0.");
902 r->leading_nines = strspn (r->string, "9.");
903 r->integer_digits = strchr (r->string, '.') - r->string;
904 assert (r->integer_digits < 64);
905 assert (r->integer_digits >= 0);
906 r->negative = number < 0;
909 /* Returns the number of characters required to format the
910 magnitude represented by R to DECIMALS decimal places.
911 The return value includes integer digits and a decimal point
912 and fractional digits, if any, but it does not include any
913 negative prefix or suffix or other affixes.
915 *INTEGER_DIGITS is set to the number of digits before the
916 decimal point in the output, between 0 and 40.
918 If R represents a negative number and its rounded
919 representation would include at least one nonzero digit,
920 *NEGATIVE is set to true; otherwise, it is set to false. */
922 rounder_width (const struct rounder *r, int decimals,
923 int *integer_digits, bool *negative)
925 /* Calculate base measures. */
926 int width = r->integer_digits;
928 width += decimals + 1;
929 *integer_digits = r->integer_digits;
930 *negative = r->negative;
932 /* Rounding can cause adjustments. */
933 if (should_round_up (r, decimals))
935 /* Rounding up leading 9s adds a new digit (a 1). */
936 if (r->leading_nines >= width)
945 if (r->leading_zeros >= width)
947 /* All digits that remain after rounding are zeros.
948 Therefore we drop the negative sign. */
950 if (r->integer_digits == 0 && decimals == 0)
952 /* No digits at all are left. We need to display
953 at least a single digit (a zero). */
963 /* Formats the magnitude represented by R into OUTPUT, rounding
964 to DECIMALS decimal places. Exactly as many characters as
965 indicated by rounder_width are written. No terminating null
968 rounder_format (const struct rounder *r, int decimals, char *output)
970 int base_width = r->integer_digits + (decimals > 0 ? decimals + 1 : 0);
971 if (should_round_up (r, decimals))
973 if (r->leading_nines < base_width)
975 /* Rounding up. This is the common case where rounding
976 up doesn't add an extra digit. */
978 memcpy (output, r->string, base_width);
979 for (p = output + base_width - 1; ; p--)
981 assert (p >= output);
984 else if (*p >= '0' && *p <= '8')
995 /* Rounding up leading 9s causes the result to be a 1
996 followed by a number of 0s, plus a decimal point. */
999 p = mempset (p, '0', r->integer_digits);
1003 p = mempset (p, '0', decimals);
1005 assert (p == output + base_width + 1);
1010 /* Rounding down. */
1011 if (r->integer_digits != 0 || decimals != 0)
1013 /* Common case: just copy the digits. */
1014 memcpy (output, r->string, base_width);
1018 /* No digits remain. The output is just a zero. */
1024 /* Helper functions. */
1026 /* Returns 10**X. */
1027 static double PURE_FUNCTION
1030 static const double p[] =
1032 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1033 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
1034 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
1035 1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39,
1038 return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (10.0, x);
1041 /* Returns 256**X. */
1042 static double PURE_FUNCTION
1045 static const double p[] =
1054 72057594037927936.0,
1055 18446744073709551616.0
1057 return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (256.0, x);
1060 /* Formats non-finite NUMBER into OUTPUT according to the width
1063 output_infinite (double number, const struct fmt_spec *format, char *output)
1065 assert (!isfinite (number));
1073 else if (isinf (number))
1074 s = number > 0 ? "+Infinity" : "-Infinity";
1078 buf_copy_str_lpad (output, format->w, s, ' ');
1081 output_overflow (format, output);
1083 output[format->w] = '\0';
1086 /* Formats OUTPUT as a missing value for the given FORMAT. */
1088 output_missing (const struct fmt_spec *format, char *output)
1090 memset (output, ' ', format->w);
1092 if (format->type != FMT_N)
1094 int dot_ofs = (format->type == FMT_PCT ? 2
1095 : format->type == FMT_E ? 5
1097 output[MAX (0, format->w - format->d - dot_ofs)] = '.';
1100 output[format->w - 1] = '.';
1102 output[format->w] = '\0';
1105 /* Formats OUTPUT for overflow given FORMAT. */
1107 output_overflow (const struct fmt_spec *format, char *output)
1109 memset (output, '*', format->w);
1110 output[format->w] = '\0';
1113 /* Converts the integer part of NUMBER to a packed BCD number
1114 with the given number of DIGITS in OUTPUT. If DIGITS is odd,
1115 the least significant nibble of the final byte in OUTPUT is
1116 set to 0. Returns true if successful, false if NUMBER is not
1117 representable. On failure, OUTPUT is cleared to all zero
1120 output_bcd_integer (double number, int digits, char *output)
1124 assert (digits < sizeof decimal);
1126 output[DIV_RND_UP (digits, 2)] = '\0';
1127 if (number != SYSMIS
1129 && number < power10 (digits)
1130 && c_snprintf (decimal, 64, "%0*.0f", digits, round (number)) == digits)
1132 const char *src = decimal;
1135 for (i = 0; i < digits / 2; i++)
1137 int d0 = *src++ - '0';
1138 int d1 = *src++ - '0';
1139 *output++ = (d0 << 4) + d1;
1142 *output = (*src - '0') << 4;
1148 memset (output, 0, DIV_RND_UP (digits, 2));
1153 /* Writes VALUE to OUTPUT as a BYTES-byte binary integer of the
1154 given INTEGER_FORMAT. */
1156 output_binary_integer (uint64_t value, int bytes,
1157 enum integer_format integer_format, char *output)
1159 integer_put (value, integer_format, output, bytes);
1162 /* Converts the BYTES bytes in DATA to twice as many hexadecimal
1163 digits in OUTPUT. */
1165 output_hex (const void *data_, size_t bytes, char *output)
1167 const uint8_t *data = data_;
1170 for (i = 0; i < bytes; i++)
1172 static const char hex_digits[] = "0123456789ABCDEF";
1173 *output++ = hex_digits[data[i] >> 4];
1174 *output++ = hex_digits[data[i] & 15];