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 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.
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 *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, 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 *encoding, const struct fmt_spec *format)
229 return data_out_pool (input, encoding, format, NULL);
233 /* Main conversion functions. */
235 /* Outputs F, COMMA, DOT, DOLLAR, PCT, E, CCA, CCB, CCC, CCD, and
238 output_number (const union value *input, const struct fmt_spec *format,
241 double number = input->f;
243 if (number == SYSMIS)
244 output_missing (format, output);
245 else if (!isfinite (number))
246 output_infinite (number, format, output);
249 if (format->type != FMT_E && fabs (number) < 1.5 * power10 (format->w))
252 rounder_init (&r, number, format->d);
254 if (output_decimal (&r, format, true, output)
255 || output_scientific (number, format, true, output)
256 || output_decimal (&r, format, false, output))
260 if (!output_scientific (number, format, false, output))
261 output_overflow (format, output);
265 /* Outputs N format. */
267 output_N (const union value *input, const struct fmt_spec *format,
270 double number = input->f * power10 (format->d);
271 if (input->f == SYSMIS || number < 0)
272 output_missing (format, output);
276 number = fabs (round (number));
277 if (number < power10 (format->w)
278 && c_snprintf (buf, 128, "%0*.0f", format->w, number) == format->w)
279 memcpy (output, buf, format->w);
281 output_overflow (format, output);
284 output[format->w] = '\0';
287 /* Outputs Z format. */
289 output_Z (const union value *input, const struct fmt_spec *format,
292 double number = input->f * power10 (format->d);
294 if (input->f == SYSMIS)
295 output_missing (format, output);
296 else if (fabs (number) < power10 (format->w)
297 && c_snprintf (buf, 128, "%0*.0f", format->w,
298 fabs (round (number))) == format->w)
300 if (number < 0 && strspn (buf, "0") < format->w)
302 char *p = &buf[format->w - 1];
303 *p = "}JKLMNOPQR"[*p - '0'];
305 memcpy (output, buf, format->w);
306 output[format->w] = '\0';
309 output_overflow (format, output);
312 /* Outputs P format. */
314 output_P (const union value *input, const struct fmt_spec *format,
317 if (output_bcd_integer (fabs (input->f * power10 (format->d)),
318 format->w * 2 - 1, output)
320 output[format->w - 1] |= 0xd;
322 output[format->w - 1] |= 0xf;
325 /* Outputs PK format. */
327 output_PK (const union value *input, const struct fmt_spec *format,
330 output_bcd_integer (input->f * power10 (format->d), format->w * 2, output);
333 /* Outputs IB format. */
335 output_IB (const union value *input, const struct fmt_spec *format,
338 double number = round (input->f * power10 (format->d));
339 if (input->f == SYSMIS
340 || number >= power256 (format->w) / 2 - 1
341 || number < -power256 (format->w) / 2)
342 memset (output, 0, format->w);
345 uint64_t integer = fabs (number);
348 output_binary_integer (integer, format->w,
349 settings_get_output_integer_format (),
353 output[format->w] = '\0';
356 /* Outputs PIB format. */
358 output_PIB (const union value *input, const struct fmt_spec *format,
361 double number = round (input->f * power10 (format->d));
362 if (input->f == SYSMIS
363 || number < 0 || number >= power256 (format->w))
364 memset (output, 0, format->w);
366 output_binary_integer (number, format->w,
367 settings_get_output_integer_format (), output);
369 output[format->w] = '\0';
372 /* Outputs PIBHEX format. */
374 output_PIBHEX (const union value *input, const struct fmt_spec *format,
377 double number = round (input->f);
378 if (input->f == SYSMIS)
379 output_missing (format, output);
380 else if (input->f < 0 || number >= power256 (format->w / 2))
381 output_overflow (format, output);
385 output_binary_integer (number, format->w / 2, INTEGER_MSB_FIRST, tmp);
386 output_hex (tmp, format->w / 2, output);
391 /* Outputs RB format. */
393 output_RB (const union value *input, const struct fmt_spec *format,
397 memcpy (output, &d, format->w);
399 output[format->w] = '\0';
402 /* Outputs RBHEX format. */
404 output_RBHEX (const union value *input, const struct fmt_spec *format,
409 output_hex (&d, format->w / 2, output);
412 /* Outputs DATE, ADATE, EDATE, JDATE, SDATE, QYR, MOYR, WKYR,
413 DATETIME, TIME, and DTIME formats. */
415 output_date (const union value *input, const struct fmt_spec *format,
418 double number = input->f;
419 int year, month, day, yday;
421 const char *template = fmt_date_template (format->type, format->w);
426 if (number == SYSMIS)
429 if (fmt_get_category (format->type) == FMT_CAT_DATE)
433 calendar_offset_to_gregorian (number / 60. / 60. / 24.,
434 &year, &month, &day, &yday);
435 number = fmod (number, 60. * 60. * 24.);
438 year = month = day = yday = 0;
440 while (*template != '\0')
446 while (template[count] == ch)
454 p += sprintf (p, "%02d", day);
456 p += sprintf (p, "%03d", yday);
460 p += sprintf (p, "%02d", month);
463 static const char *const months[12] =
465 "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
466 "JUL", "AUG", "SEP", "OCT", "NOV", "DEC",
468 p = stpcpy (p, months[month - 1]);
475 p += sprintf (p, "%04d", year);
476 else if (format->type == FMT_DATETIME
477 || format->type == FMT_YMDHMS)
478 p = stpcpy (p, "****");
484 int epoch = settings_get_epoch ();
485 int offset = year - epoch;
486 if (offset < 0 || offset > 99)
488 p += sprintf (p, "%02d", abs (year) % 100);
492 p += sprintf (p, "%d", (month - 1) / 3 + 1);
495 p += sprintf (p, "%2d", (yday - 1) / 7 + 1);
500 number = fabs (number);
501 p += c_snprintf (p, 64, "%*.0f", count, floor (number / 60. / 60. / 24.));
502 number = fmod (number, 60. * 60. * 24.);
507 number = fabs (number);
508 p += c_snprintf (p, 64, "%0*.0f", count, floor (number / 60. / 60.));
509 number = fmod (number, 60. * 60.);
514 number = fabs (number);
515 p += sprintf (p, "%02d", (int) floor (number / 60.));
516 number = fmod (number, 60.);
517 excess_width = format->w - (p - tmp);
519 || (format->type == FMT_MTIME && excess_width < 3))
521 if (excess_width == 3 || excess_width == 4
522 || (excess_width >= 5 && format->d == 0))
523 p += sprintf (p, ":%02d", (int) number);
524 else if (excess_width >= 5)
526 int d = MIN (format->d, excess_width - 4);
528 c_snprintf (p, 64, ":%0*.*f", w, d, number);
529 if (settings_get_decimal_char (FMT_F) != '.')
531 char *cp = strchr (p, '.');
533 *cp = settings_get_decimal_char (FMT_F);
546 buf_copy_lpad (output, format->w, tmp, p - tmp, ' ');
547 output[format->w] = '\0';
551 output_overflow (format, output);
555 output_missing (format, output);
559 /* Outputs WKDAY format. */
561 output_WKDAY (const union value *input, const struct fmt_spec *format,
564 static const char *const weekdays[7] =
566 "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY",
567 "THURSDAY", "FRIDAY", "SATURDAY",
570 if (input->f >= 1 && input->f < 8)
572 buf_copy_str_rpad (output, format->w,
573 weekdays[(int) input->f - 1], ' ');
574 output[format->w] = '\0';
578 if (input->f != SYSMIS)
579 msg (ME, _("Weekday number %f is not between 1 and 7."), input->f);
580 output_missing (format, output);
585 /* Outputs MONTH format. */
587 output_MONTH (const union value *input, const struct fmt_spec *format,
590 static const char *const months[12] =
592 "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE",
593 "JULY", "AUGUST", "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER",
596 if (input->f >= 1 && input->f < 13)
598 buf_copy_str_rpad (output, format->w, months[(int) input->f - 1], ' ');
599 output[format->w] = '\0';
603 if (input->f != SYSMIS)
604 msg (ME, _("Month number %f is not between 1 and 12."), input->f);
605 output_missing (format, output);
610 /* Outputs A format. */
612 output_A (const union value *input UNUSED,
613 const struct fmt_spec *format UNUSED, char *output UNUSED)
618 /* Outputs AHEX format. */
620 output_AHEX (const union value *input, const struct fmt_spec *format,
623 output_hex (value_str (input, format->w / 2), format->w / 2, output);
626 /* Decimal and scientific formatting. */
628 /* If REQUEST plus the current *WIDTH fits within MAX_WIDTH,
629 increments *WIDTH by REQUEST and return true.
630 Otherwise returns false without changing *WIDTH. */
632 allocate_space (int request, int max_width, int *width)
634 assert (*width <= max_width);
635 if (request + *width <= max_width)
644 /* Tries to compose the number represented by R, in the style of
645 FORMAT, into OUTPUT. Returns true if successful, false on
646 failure, which occurs if FORMAT's width is too narrow. If
647 REQUIRE_AFFIXES is true, then the prefix and suffix specified
648 by FORMAT's style must be included; otherwise, they may be
649 omitted to make the number fit. */
651 output_decimal (const struct rounder *r, const struct fmt_spec *format,
652 bool require_affixes, char *output)
654 const struct fmt_number_style *style =
655 settings_get_style (format->type);
659 for (decimals = format->d; decimals >= 0; decimals--)
661 /* Formatted version of magnitude of NUMBER. */
664 /* Number of digits in MAGNITUDE's integer and fractional parts. */
667 /* Amount of space within the field width already claimed.
668 Initially this is the width of MAGNITUDE, then it is reduced
669 in stages as space is allocated to prefixes and suffixes and
670 grouping characters. */
673 /* Include various decorations? */
678 /* Position in output. */
681 /* Make sure there's room for the number's magnitude, plus
682 the negative suffix, plus (if negative) the negative
684 width = rounder_width (r, decimals, &integer_digits, &add_neg_prefix);
685 width += style->neg_suffix.width;
687 width += style->neg_prefix.width;
688 if (width > format->w)
691 /* If there's room for the prefix and suffix, allocate
692 space. If the affixes are required, but there's no
694 add_affixes = allocate_space (fmt_affix_width (style),
696 if (!add_affixes && require_affixes)
699 /* Check whether we should include grouping characters.
700 We need room for a complete set or we don't insert any at all.
701 We don't include grouping characters if decimal places were
702 requested but they were all dropped. */
703 add_grouping = (style->grouping != 0
704 && integer_digits > 3
705 && (format->d == 0 || decimals > 0)
706 && allocate_space ((integer_digits - 1) / 3,
709 /* Format the number's magnitude. */
710 rounder_format (r, decimals, magnitude);
712 /* Assemble number. */
714 if (format->w > width)
715 p = mempset (p, ' ', format->w - width);
717 p = stpcpy (p, style->neg_prefix.s);
719 p = stpcpy (p, style->prefix.s);
721 p = mempcpy (p, magnitude, integer_digits);
725 for (i = 0; i < integer_digits; i++)
727 if (i > 0 && (integer_digits - i) % 3 == 0)
728 *p++ = style->grouping;
734 *p++ = style->decimal;
735 p = mempcpy (p, &magnitude[integer_digits + 1], decimals);
738 p = stpcpy (p, style->suffix.s);
740 p = stpcpy (p, style->neg_suffix.s);
742 p = mempset (p, ' ', style->neg_suffix.width);
744 assert (p >= output + format->w);
745 assert (p <= output + format->w + style->extra_bytes);
753 /* Formats NUMBER into OUTPUT in scientific notation according to
754 the style of the format specified in FORMAT. */
756 output_scientific (double number, const struct fmt_spec *format,
757 bool require_affixes, char *output)
759 const struct fmt_number_style *style =
760 settings_get_style (format->type);
766 /* Allocate minimum required space. */
767 width = 6 + style->neg_suffix.width;
769 width += style->neg_prefix.width;
770 if (width > format->w)
773 /* Check for room for prefix and suffix. */
774 add_affixes = allocate_space (fmt_affix_width (style), format->w, &width);
775 if (require_affixes && !add_affixes)
778 /* Figure out number of characters we can use for the fraction,
779 if any. (If that turns out to be 1, then we'll output a
780 decimal point without any digits following; that's what the
781 # flag does in the call to c_snprintf, below.) */
782 fraction_width = MIN (MIN (format->d + 1, format->w - width), 16);
783 if (format->type != FMT_E && fraction_width == 1)
785 width += fraction_width;
787 /* Format (except suffix). */
789 if (width < format->w)
790 p = mempset (p, ' ', format->w - width);
792 p = stpcpy (p, style->neg_prefix.s);
794 p = stpcpy (p, style->prefix.s);
795 if (fraction_width > 0)
796 c_snprintf (p, 64, "%#.*E", fraction_width - 1, fabs (number));
798 c_snprintf (p, 64, "%.0E", fabs (number));
800 /* The C locale always uses a period `.' as a decimal point.
801 Translate to comma if necessary. */
802 if (style->decimal != '.')
804 char *cp = strchr (p, '.');
806 *cp = style->decimal;
809 /* Make exponent have exactly three digits, plus sign. */
811 char *cp = strchr (p, 'E') + 1;
812 long int exponent = strtol (cp, NULL, 10);
813 if (labs (exponent) > 999)
815 sprintf (cp, "%+04ld", exponent);
819 p = strchr (p, '\0');
821 p = stpcpy (p, style->suffix.s);
823 p = stpcpy (p, style->neg_suffix.s);
825 p = mempset (p, ' ', style->neg_suffix.width);
827 assert (p >= output + format->w);
828 assert (p <= output + format->w + style->extra_bytes);
834 /* Returns true if the magnitude represented by R should be
835 rounded up when chopped off at DECIMALS decimal places, false
836 if it should be rounded down. */
838 should_round_up (const struct rounder *r, int decimals)
840 int digit = r->string[r->integer_digits + decimals + 1];
841 assert (digit >= '0' && digit <= '9');
845 /* Initializes R for formatting the magnitude of NUMBER to no
846 more than MAX_DECIMAL decimal places. */
848 rounder_init (struct rounder *r, double number, int max_decimals)
850 assert (fabs (number) < 1e41);
851 assert (max_decimals >= 0 && max_decimals <= 16);
852 if (max_decimals == 0)
854 /* Fast path. No rounding needed.
856 We append ".00" to the integer representation because
857 round_up assumes that fractional digits are present. */
858 c_snprintf (r->string, 64, "%.0f.00", fabs (round (number)));
864 This is more difficult than it really should be because
865 we have to make sure that numbers that are exactly
866 halfway between two representations are always rounded
867 away from zero. This is not what sprintf normally does
868 (usually it rounds to even), so we have to fake it as
869 best we can, by formatting with extra precision and then
870 doing the rounding ourselves.
872 We take up to two rounds to format numbers. In the
873 first round, we obtain 2 digits of precision beyond
874 those requested by the user. If those digits are
875 exactly "50", then in a second round we format with as
876 many digits as are significant in a "double".
878 It might be better to directly implement our own
879 floating-point formatting routine instead of relying on
880 the system's sprintf implementation. But the classic
881 Steele and White paper on printing floating-point
882 numbers does not hint how to do what we want, and it's
883 not obvious how to change their algorithms to do so. It
884 would also be a lot of work. */
885 c_snprintf (r->string, 64, "%.*f", max_decimals + 2, fabs (number));
886 if (!strcmp (r->string + strlen (r->string) - 2, "50"))
888 int binary_exponent, decimal_exponent, format_decimals;
889 frexp (number, &binary_exponent);
890 decimal_exponent = binary_exponent * 3 / 10;
891 format_decimals = (DBL_DIG + 1) - decimal_exponent;
892 if (format_decimals > max_decimals + 2)
893 c_snprintf (r->string, 64, "%.*f", format_decimals, fabs (number));
897 if (r->string[0] == '0')
898 memmove (r->string, &r->string[1], strlen (r->string));
900 r->leading_zeros = strspn (r->string, "0.");
901 r->leading_nines = strspn (r->string, "9.");
902 r->integer_digits = strchr (r->string, '.') - r->string;
903 assert (r->integer_digits < 64);
904 assert (r->integer_digits >= 0);
905 r->negative = number < 0;
908 /* Returns the number of characters required to format the
909 magnitude represented by R to DECIMALS decimal places.
910 The return value includes integer digits and a decimal point
911 and fractional digits, if any, but it does not include any
912 negative prefix or suffix or other affixes.
914 *INTEGER_DIGITS is set to the number of digits before the
915 decimal point in the output, between 0 and 40.
917 If R represents a negative number and its rounded
918 representation would include at least one nonzero digit,
919 *NEGATIVE is set to true; otherwise, it is set to false. */
921 rounder_width (const struct rounder *r, int decimals,
922 int *integer_digits, bool *negative)
924 /* Calculate base measures. */
925 int width = r->integer_digits;
927 width += decimals + 1;
928 *integer_digits = r->integer_digits;
929 *negative = r->negative;
931 /* Rounding can cause adjustments. */
932 if (should_round_up (r, decimals))
934 /* Rounding up leading 9s adds a new digit (a 1). */
935 if (r->leading_nines >= width)
944 if (r->leading_zeros >= width)
946 /* All digits that remain after rounding are zeros.
947 Therefore we drop the negative sign. */
949 if (r->integer_digits == 0 && decimals == 0)
951 /* No digits at all are left. We need to display
952 at least a single digit (a zero). */
962 /* Formats the magnitude represented by R into OUTPUT, rounding
963 to DECIMALS decimal places. Exactly as many characters as
964 indicated by rounder_width are written. No terminating null
967 rounder_format (const struct rounder *r, int decimals, char *output)
969 int base_width = r->integer_digits + (decimals > 0 ? decimals + 1 : 0);
970 if (should_round_up (r, decimals))
972 if (r->leading_nines < base_width)
974 /* Rounding up. This is the common case where rounding
975 up doesn't add an extra digit. */
977 memcpy (output, r->string, base_width);
978 for (p = output + base_width - 1; ; p--)
980 assert (p >= output);
983 else if (*p >= '0' && *p <= '8')
994 /* Rounding up leading 9s causes the result to be a 1
995 followed by a number of 0s, plus a decimal point. */
998 p = mempset (p, '0', r->integer_digits);
1002 p = mempset (p, '0', decimals);
1004 assert (p == output + base_width + 1);
1009 /* Rounding down. */
1010 if (r->integer_digits != 0 || decimals != 0)
1012 /* Common case: just copy the digits. */
1013 memcpy (output, r->string, base_width);
1017 /* No digits remain. The output is just a zero. */
1023 /* Helper functions. */
1025 /* Returns 10**X. */
1026 static double PURE_FUNCTION
1029 static const double p[] =
1031 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1032 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
1033 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
1034 1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39,
1037 return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (10.0, x);
1040 /* Returns 256**X. */
1041 static double PURE_FUNCTION
1044 static const double p[] =
1053 72057594037927936.0,
1054 18446744073709551616.0
1056 return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (256.0, x);
1059 /* Formats non-finite NUMBER into OUTPUT according to the width
1062 output_infinite (double number, const struct fmt_spec *format, char *output)
1064 assert (!isfinite (number));
1072 else if (isinf (number))
1073 s = number > 0 ? "+Infinity" : "-Infinity";
1077 buf_copy_str_lpad (output, format->w, s, ' ');
1080 output_overflow (format, output);
1082 output[format->w] = '\0';
1085 /* Formats OUTPUT as a missing value for the given FORMAT. */
1087 output_missing (const struct fmt_spec *format, char *output)
1089 memset (output, ' ', format->w);
1091 if (format->type != FMT_N)
1093 int dot_ofs = (format->type == FMT_PCT ? 2
1094 : format->type == FMT_E ? 5
1096 output[MAX (0, format->w - format->d - dot_ofs)] = '.';
1099 output[format->w - 1] = '.';
1101 output[format->w] = '\0';
1104 /* Formats OUTPUT for overflow given FORMAT. */
1106 output_overflow (const struct fmt_spec *format, char *output)
1108 memset (output, '*', format->w);
1109 output[format->w] = '\0';
1112 /* Converts the integer part of NUMBER to a packed BCD number
1113 with the given number of DIGITS in OUTPUT. If DIGITS is odd,
1114 the least significant nibble of the final byte in OUTPUT is
1115 set to 0. Returns true if successful, false if NUMBER is not
1116 representable. On failure, OUTPUT is cleared to all zero
1119 output_bcd_integer (double number, int digits, char *output)
1123 assert (digits < sizeof decimal);
1125 output[DIV_RND_UP (digits, 2)] = '\0';
1126 if (number != SYSMIS
1128 && number < power10 (digits)
1129 && c_snprintf (decimal, 64, "%0*.0f", digits, round (number)) == digits)
1131 const char *src = decimal;
1134 for (i = 0; i < digits / 2; i++)
1136 int d0 = *src++ - '0';
1137 int d1 = *src++ - '0';
1138 *output++ = (d0 << 4) + d1;
1141 *output = (*src - '0') << 4;
1147 memset (output, 0, DIV_RND_UP (digits, 2));
1152 /* Writes VALUE to OUTPUT as a BYTES-byte binary integer of the
1153 given INTEGER_FORMAT. */
1155 output_binary_integer (uint64_t value, int bytes,
1156 enum integer_format integer_format, char *output)
1158 integer_put (value, integer_format, output, bytes);
1161 /* Converts the BYTES bytes in DATA to twice as many hexadecimal
1162 digits in OUTPUT. */
1164 output_hex (const void *data_, size_t bytes, char *output)
1166 const uint8_t *data = data_;
1169 for (i = 0; i < bytes; i++)
1171 static const char hex_digits[] = "0123456789ABCDEF";
1172 *output++ = hex_digits[data[i] >> 4];
1173 *output++ = hex_digits[data[i] & 15];