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 *, const struct fmt_number_style *,
62 double number, int max_decimals);
63 static int rounder_width (const struct rounder *, int decimals,
64 int *integer_digits, bool *negative);
65 static void rounder_format (const struct rounder *, int decimals,
68 typedef void data_out_converter_func (const union value *,
69 const struct fmt_spec *,
70 const struct fmt_settings *, char *);
71 #define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) \
72 static data_out_converter_func output_##METHOD;
75 static bool output_decimal (const struct rounder *, const struct fmt_spec *,
76 const struct fmt_number_style *,
77 bool require_affixes, char *);
78 static bool output_scientific (double, const struct fmt_spec *,
79 const struct fmt_number_style *,
80 bool require_affixes, char *);
82 static double power10 (int) PURE_FUNCTION;
83 static double power256 (int) PURE_FUNCTION;
85 static void output_infinite (double, const struct fmt_spec *, char *);
86 static void output_missing (const struct fmt_spec *, char *);
87 static void output_overflow (const struct fmt_spec *, char *);
88 static bool output_bcd_integer (double, int digits, char *);
89 static void output_binary_integer (uint64_t, int bytes, enum integer_format,
91 static void output_hex (const void *, size_t bytes, char *);
94 static data_out_converter_func *const converters[FMT_NUMBER_OF_FORMATS] =
96 #define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) output_##METHOD,
100 /* Converts the INPUT value, encoded in INPUT_ENCODING, according to format
101 specification FORMAT, appending the output to OUTPUT in OUTPUT_ENCODING.
102 However, binary formats (FMT_P, FMT_PK, FMT_IB, FMT_PIB, FMT_RB) yield the
103 binary results, which may not be properly encoded for OUTPUT_ENCODING.
105 VALUE must be the correct width for FORMAT, that is, its width must be
106 fmt_var_width(FORMAT).
108 INPUT_ENCODING can normally be obtained by calling dict_get_encoding() on
109 the dictionary with which INPUT is associated. ENCODING is only important
110 when FORMAT's type is FMT_A. */
112 data_out_recode (const union value *input, const char *input_encoding,
113 const struct fmt_spec *format,
114 const struct fmt_settings *settings,
115 struct string *output, const char *output_encoding)
117 assert (fmt_check_output (format));
118 if (format->type == FMT_A)
120 char *in = CHAR_CAST (char *, input->s);
121 char *out = recode_string (output_encoding, input_encoding,
123 ds_put_cstr (output, out);
126 else if (fmt_get_category (format->type) == FMT_CAT_BINARY)
127 converters[format->type] (input, format, settings,
128 ds_put_uninit (output, format->w));
131 char *utf8_encoded = data_out (input, input_encoding, format, settings);
132 char *output_encoded = recode_string (output_encoding, UTF8,
134 ds_put_cstr (output, output_encoded);
135 free (output_encoded);
141 binary_to_utf8 (const char *in, struct pool *pool)
143 uint8_t *out = pool_alloc_unaligned (pool, strlen (in) * 2 + 1);
148 uint8_t byte = *in++;
149 int mblen = u8_uctomb (p, byte, 2);
155 return CHAR_CAST (char *, out);
158 /* Converts the INPUT value into a UTF-8 encoded string, according to format
159 specification FORMAT.
161 VALUE must be the correct width for FORMAT, that is, its width must be
162 fmt_var_width(FORMAT).
164 INPUT_ENCODING must be the encoding of INPUT. Normally this can be obtained
165 by calling dict_get_encoding() on the dictionary with which INPUT is
166 associated. INPUT_ENCODING is only important when FORMAT's type is FMT_A.
168 The return value is dynamically allocated, and must be freed by the caller.
169 If POOL is non-null, then the return value is allocated on that pool. */
171 data_out_pool (const union value *input, const char *input_encoding,
172 const struct fmt_spec *format,
173 const struct fmt_settings *settings, struct pool *pool)
175 assert (fmt_check_output (format));
176 if (format->type == FMT_A)
178 char *in = CHAR_CAST (char *, input->s);
179 return recode_string_pool (UTF8, input_encoding, in, format->w, pool);
181 else if (fmt_get_category (format->type) == FMT_CAT_BINARY)
185 assert (format->w + 1 <= sizeof tmp);
186 converters[format->type] (input, format, settings, tmp);
187 return binary_to_utf8 (tmp, pool);
191 const struct fmt_number_style *style = fmt_settings_get_style (
192 settings, format->type);
193 size_t size = format->w + style->extra_bytes + 1;
196 output = pool_alloc_unaligned (pool, size);
197 converters[format->type] (input, format, settings, output);
202 /* Like data_out_pool(), except that for basic numeric formats (F, COMMA, DOT,
203 COLLAR, PCT, E) and custom currency formats are formatted as wide as
204 necessary to fully display the selected number of decimal places. */
206 data_out_stretchy (const union value *input, const char *encoding,
207 const struct fmt_spec *format,
208 const struct fmt_settings *settings, struct pool *pool)
211 if (fmt_get_category (format->type) & (FMT_CAT_BASIC | FMT_CAT_CUSTOM))
213 const struct fmt_number_style *style
214 = fmt_settings_get_style (settings, format->type);
215 struct fmt_spec wide_format;
219 wide_format.type = format->type;
221 wide_format.d = format->d;
223 size = format->w + style->extra_bytes + 1;
224 if (size <= sizeof tmp)
226 output_number (input, &wide_format, settings, tmp);
227 return pool_strdup (pool, tmp + strspn (tmp, " "));
231 return data_out_pool (input, encoding, format, settings, pool);
235 data_out (const union value *input, const char *input_encoding,
236 const struct fmt_spec *format, const struct fmt_settings *settings)
238 return data_out_pool (input, input_encoding, format, settings, NULL);
242 /* Main conversion functions. */
244 /* Outputs F, COMMA, DOT, DOLLAR, PCT, E, CCA, CCB, CCC, CCD, and
247 output_number (const union value *input, const struct fmt_spec *format,
248 const struct fmt_settings *settings, char *output)
250 double number = input->f;
252 if (number == SYSMIS)
253 output_missing (format, output);
254 else if (!isfinite (number))
255 output_infinite (number, format, output);
258 const struct fmt_number_style *style =
259 fmt_settings_get_style (settings, format->type);
261 if (format->type != FMT_E && fabs (number) < 1.5 * power10 (format->w))
264 rounder_init (&r, style, number, format->d);
266 if (output_decimal (&r, format, style, true, output)
267 || output_scientific (number, format, style, true, output)
268 || output_decimal (&r, format, style, false, output))
272 if (!output_scientific (number, format, style, false, output))
273 output_overflow (format, output);
277 /* Outputs N format. */
279 output_N (const union value *input, const struct fmt_spec *format,
280 const struct fmt_settings *settings UNUSED, char *output)
282 double number = input->f * power10 (format->d);
283 if (input->f == SYSMIS || number < 0)
284 output_missing (format, output);
288 number = fabs (round (number));
289 if (number < power10 (format->w)
290 && c_snprintf (buf, 128, "%0*.0f", format->w, number) == format->w)
291 memcpy (output, buf, format->w);
293 output_overflow (format, output);
296 output[format->w] = '\0';
299 /* Outputs Z format. */
301 output_Z (const union value *input, const struct fmt_spec *format,
302 const struct fmt_settings *settings UNUSED, char *output)
304 double number = input->f * power10 (format->d);
306 if (input->f == SYSMIS)
307 output_missing (format, output);
308 else if (fabs (number) < power10 (format->w)
309 && c_snprintf (buf, 128, "%0*.0f", format->w,
310 fabs (round (number))) == format->w)
312 if (number < 0 && strspn (buf, "0") < format->w)
314 char *p = &buf[format->w - 1];
315 *p = "}JKLMNOPQR"[*p - '0'];
317 memcpy (output, buf, format->w);
318 output[format->w] = '\0';
321 output_overflow (format, output);
324 /* Outputs P format. */
326 output_P (const union value *input, const struct fmt_spec *format,
327 const struct fmt_settings *settings UNUSED, char *output)
329 if (output_bcd_integer (fabs (input->f * power10 (format->d)),
330 format->w * 2 - 1, output)
332 output[format->w - 1] |= 0xd;
334 output[format->w - 1] |= 0xf;
337 /* Outputs PK format. */
339 output_PK (const union value *input, const struct fmt_spec *format,
340 const struct fmt_settings *settings UNUSED, char *output)
342 output_bcd_integer (input->f * power10 (format->d), format->w * 2, output);
345 /* Outputs IB format. */
347 output_IB (const union value *input, const struct fmt_spec *format,
348 const struct fmt_settings *settings UNUSED, char *output)
350 double number = round (input->f * power10 (format->d));
351 if (input->f == SYSMIS
352 || number >= power256 (format->w) / 2 - 1
353 || number < -power256 (format->w) / 2)
354 memset (output, 0, format->w);
357 uint64_t integer = fabs (number);
360 output_binary_integer (integer, format->w,
361 settings_get_output_integer_format (),
365 output[format->w] = '\0';
368 /* Outputs PIB format. */
370 output_PIB (const union value *input, const struct fmt_spec *format,
371 const struct fmt_settings *settings UNUSED, char *output)
373 double number = round (input->f * power10 (format->d));
374 if (input->f == SYSMIS
375 || number < 0 || number >= power256 (format->w))
376 memset (output, 0, format->w);
378 output_binary_integer (number, format->w,
379 settings_get_output_integer_format (), output);
381 output[format->w] = '\0';
384 /* Outputs PIBHEX format. */
386 output_PIBHEX (const union value *input, const struct fmt_spec *format,
387 const struct fmt_settings *settings UNUSED, char *output)
389 double number = round (input->f);
390 if (input->f == SYSMIS)
391 output_missing (format, output);
392 else if (input->f < 0 || number >= power256 (format->w / 2))
393 output_overflow (format, output);
397 output_binary_integer (number, format->w / 2, INTEGER_MSB_FIRST, tmp);
398 output_hex (tmp, format->w / 2, output);
403 /* Outputs RB format. */
405 output_RB (const union value *input, const struct fmt_spec *format,
406 const struct fmt_settings *settings UNUSED, char *output)
409 memcpy (output, &d, format->w);
411 output[format->w] = '\0';
414 /* Outputs RBHEX format. */
416 output_RBHEX (const union value *input, const struct fmt_spec *format,
417 const struct fmt_settings *settings UNUSED, char *output)
421 output_hex (&d, format->w / 2, output);
424 /* Outputs DATE, ADATE, EDATE, JDATE, SDATE, QYR, MOYR, WKYR,
425 DATETIME, TIME, and DTIME formats. */
427 output_date (const union value *input, const struct fmt_spec *format,
428 const struct fmt_settings *settings, char *output)
430 double number = input->f;
431 int year, month, day, yday;
433 const char *template = fmt_date_template (format->type, format->w);
438 if (number == SYSMIS)
441 if (fmt_get_category (format->type) == FMT_CAT_DATE)
445 calendar_offset_to_gregorian (number / 60. / 60. / 24.,
446 &year, &month, &day, &yday);
447 number = fmod (number, 60. * 60. * 24.);
450 year = month = day = yday = 0;
452 while (*template != '\0')
458 while (template[count] == ch)
466 p += sprintf (p, "%02d", day);
468 p += sprintf (p, "%03d", yday);
472 p += sprintf (p, "%02d", month);
475 static const char *const months[12] =
477 "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
478 "JUL", "AUG", "SEP", "OCT", "NOV", "DEC",
480 p = stpcpy (p, months[month - 1]);
487 p += sprintf (p, "%04d", year);
488 else if (format->type == FMT_DATETIME
489 || format->type == FMT_YMDHMS)
490 p = stpcpy (p, "****");
496 int epoch = fmt_settings_get_epoch (settings);
497 int offset = year - epoch;
498 if (offset < 0 || offset > 99)
500 p += sprintf (p, "%02d", abs (year) % 100);
504 p += sprintf (p, "%d", (month - 1) / 3 + 1);
507 p += sprintf (p, "%2d", (yday - 1) / 7 + 1);
512 number = fabs (number);
513 p += c_snprintf (p, 64, "%*.0f", count, floor (number / 60. / 60. / 24.));
514 number = fmod (number, 60. * 60. * 24.);
519 number = fabs (number);
520 p += c_snprintf (p, 64, "%0*.0f", count, floor (number / 60. / 60.));
521 number = fmod (number, 60. * 60.);
526 number = fabs (number);
527 p += sprintf (p, "%02d", (int) floor (number / 60.));
528 number = fmod (number, 60.);
529 excess_width = format->w - (p - tmp);
531 || (format->type == FMT_MTIME && excess_width < 3))
533 if (excess_width == 3 || excess_width == 4
534 || (excess_width >= 5 && format->d == 0))
535 p += sprintf (p, ":%02d", (int) number);
536 else if (excess_width >= 5)
538 int d = MIN (format->d, excess_width - 4);
540 c_snprintf (p, 64, ":%0*.*f", w, d, number);
541 if (settings->decimal != '.')
543 char *cp = strchr (p, '.');
545 *cp = settings->decimal;
558 buf_copy_lpad (output, format->w, tmp, p - tmp, ' ');
559 output[format->w] = '\0';
563 output_overflow (format, output);
567 output_missing (format, output);
571 /* Outputs WKDAY format. */
573 output_WKDAY (const union value *input, const struct fmt_spec *format,
574 const struct fmt_settings *settings UNUSED, char *output)
576 static const char *const weekdays[7] =
578 "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY",
579 "THURSDAY", "FRIDAY", "SATURDAY",
582 if (input->f >= 1 && input->f < 8)
584 buf_copy_str_rpad (output, format->w,
585 weekdays[(int) input->f - 1], ' ');
586 output[format->w] = '\0';
590 if (input->f != SYSMIS)
591 msg (ME, _("Weekday number %f is not between 1 and 7."), input->f);
592 output_missing (format, output);
597 /* Outputs MONTH format. */
599 output_MONTH (const union value *input, const struct fmt_spec *format,
600 const struct fmt_settings *settings UNUSED, char *output)
602 static const char *const months[12] =
604 "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE",
605 "JULY", "AUGUST", "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER",
608 if (input->f >= 1 && input->f < 13)
610 buf_copy_str_rpad (output, format->w, months[(int) input->f - 1], ' ');
611 output[format->w] = '\0';
615 if (input->f != SYSMIS)
616 msg (ME, _("Month number %f is not between 1 and 12."), input->f);
617 output_missing (format, output);
622 /* Outputs A format. */
624 output_A (const union value *input UNUSED,
625 const struct fmt_spec *format UNUSED,
626 const struct fmt_settings *settings UNUSED, char *output UNUSED)
631 /* Outputs AHEX format. */
633 output_AHEX (const union value *input, const struct fmt_spec *format,
634 const struct fmt_settings *settings UNUSED, char *output)
636 output_hex (input->s, format->w / 2, output);
639 /* Decimal and scientific formatting. */
641 /* If REQUEST plus the current *WIDTH fits within MAX_WIDTH,
642 increments *WIDTH by REQUEST and return true.
643 Otherwise returns false without changing *WIDTH. */
645 allocate_space (int request, int max_width, int *width)
647 assert (*width <= max_width);
648 if (request + *width <= max_width)
657 /* Tries to compose the number represented by R, in the style of
658 FORMAT and STYLE, into OUTPUT. Returns true if successful, false on
659 failure, which cocurs if FORMAT's width is too narrow. If
660 REQUIRE_AFFIXES is true, then the prefix and suffix specified
661 by FORMAT's style must be included; otherwise, they may be
662 omitted to make the number fit. */
664 output_decimal (const struct rounder *r, const struct fmt_spec *format,
665 const struct fmt_number_style *style, bool require_affixes,
670 for (decimals = format->d; decimals >= 0; decimals--)
672 /* Formatted version of magnitude of NUMBER. */
675 /* Number of digits in MAGNITUDE's integer and fractional parts. */
678 /* Amount of space within the field width already claimed.
679 Initially this is the width of MAGNITUDE, then it is reduced
680 in stages as space is allocated to prefixes and suffixes and
681 grouping characters. */
684 /* Include various decorations? */
689 /* Position in output. */
692 /* Make sure there's room for the number's magnitude, plus
693 the negative suffix, plus (if negative) the negative
695 width = rounder_width (r, decimals, &integer_digits, &add_neg_prefix);
696 width += style->neg_suffix.width;
698 width += style->neg_prefix.width;
699 if (width > format->w)
702 /* If there's room for the prefix and suffix, allocate
703 space. If the affixes are required, but there's no
705 add_affixes = allocate_space (fmt_affix_width (style),
707 if (!add_affixes && require_affixes)
710 /* Check whether we should include grouping characters.
711 We need room for a complete set or we don't insert any at all.
712 We don't include grouping characters if decimal places were
713 requested but they were all dropped. */
714 add_grouping = (style->grouping != 0
715 && integer_digits > 3
716 && (format->d == 0 || decimals > 0)
717 && allocate_space ((integer_digits - 1) / 3,
720 /* Format the number's magnitude. */
721 rounder_format (r, decimals, magnitude);
723 /* Assemble number. */
725 if (format->w > width)
726 p = mempset (p, ' ', format->w - width);
728 p = stpcpy (p, style->neg_prefix.s);
730 p = stpcpy (p, style->prefix.s);
732 p = mempcpy (p, magnitude, integer_digits);
736 for (i = 0; i < integer_digits; i++)
738 if (i > 0 && (integer_digits - i) % 3 == 0)
739 *p++ = style->grouping;
745 *p++ = style->decimal;
746 p = mempcpy (p, &magnitude[integer_digits + 1], decimals);
749 p = stpcpy (p, style->suffix.s);
751 p = stpcpy (p, style->neg_suffix.s);
753 p = mempset (p, ' ', style->neg_suffix.width);
755 assert (p >= output + format->w);
756 assert (p <= output + format->w + style->extra_bytes);
764 /* Formats NUMBER into OUTPUT in scientific notation according to FORMAT and
767 output_scientific (double number, const struct fmt_spec *format,
768 const struct fmt_number_style *style,
769 bool require_affixes, char *output)
776 /* Allocate minimum required space. */
777 width = 6 + style->neg_suffix.width;
779 width += style->neg_prefix.width;
780 if (width > format->w)
783 /* Check for room for prefix and suffix. */
784 add_affixes = allocate_space (fmt_affix_width (style), format->w, &width);
785 if (require_affixes && !add_affixes)
788 /* Figure out number of characters we can use for the fraction,
789 if any. (If that turns out to be 1, then we'll output a
790 decimal point without any digits following; that's what the
791 # flag does in the call to c_snprintf, below.) */
792 fraction_width = MIN (MIN (format->d + 1, format->w - width), 16);
793 if (format->type != FMT_E && fraction_width == 1)
795 width += fraction_width;
797 /* Format (except suffix). */
799 if (width < format->w)
800 p = mempset (p, ' ', format->w - width);
802 p = stpcpy (p, style->neg_prefix.s);
804 p = stpcpy (p, style->prefix.s);
805 if (fraction_width > 0)
806 c_snprintf (p, 64, "%#.*E", fraction_width - 1, fabs (number));
808 c_snprintf (p, 64, "%.0E", fabs (number));
810 /* The C locale always uses a period `.' as a decimal point.
811 Translate to comma if necessary. */
812 if (style->decimal != '.')
814 char *cp = strchr (p, '.');
816 *cp = style->decimal;
819 /* Make exponent have exactly three digits, plus sign. */
821 char *cp = strchr (p, 'E') + 1;
822 long int exponent = strtol (cp, NULL, 10);
823 if (labs (exponent) > 999)
825 sprintf (cp, "%+04ld", exponent);
829 p = strchr (p, '\0');
831 p = stpcpy (p, style->suffix.s);
833 p = stpcpy (p, style->neg_suffix.s);
835 p = mempset (p, ' ', style->neg_suffix.width);
837 assert (p >= output + format->w);
838 assert (p <= output + format->w + style->extra_bytes);
844 /* Returns true if the magnitude represented by R should be
845 rounded up when chopped off at DECIMALS decimal places, false
846 if it should be rounded down. */
848 should_round_up (const struct rounder *r, int decimals)
850 int digit = r->string[r->integer_digits + decimals + 1];
851 assert (digit >= '0' && digit <= '9');
855 /* Initializes R for formatting the magnitude of NUMBER with STYLE to no
856 more than MAX_DECIMAL decimal places. */
858 rounder_init (struct rounder *r, const struct fmt_number_style *style,
859 double number, int max_decimals)
861 assert (fabs (number) < 1e41);
862 assert (max_decimals >= 0 && max_decimals <= 16);
863 if (max_decimals == 0)
865 /* Fast path. No rounding needed.
867 We append ".00" to the integer representation because
868 round_up assumes that fractional digits are present. */
869 c_snprintf (r->string, 64, "%.0f.00", fabs (round (number)));
875 This is more difficult than it really should be because
876 we have to make sure that numbers that are exactly
877 halfway between two representations are always rounded
878 away from zero. This is not what sprintf normally does
879 (usually it rounds to even), so we have to fake it as
880 best we can, by formatting with extra precision and then
881 doing the rounding ourselves.
883 We take up to two rounds to format numbers. In the
884 first round, we obtain 2 digits of precision beyond
885 those requested by the user. If those digits are
886 exactly "50", then in a second round we format with as
887 many digits as are significant in a "double".
889 It might be better to directly implement our own
890 floating-point formatting routine instead of relying on
891 the system's sprintf implementation. But the classic
892 Steele and White paper on printing floating-point
893 numbers does not hint how to do what we want, and it's
894 not obvious how to change their algorithms to do so. It
895 would also be a lot of work. */
896 c_snprintf (r->string, 64, "%.*f", max_decimals + 2, fabs (number));
897 if (!strcmp (r->string + strlen (r->string) - 2, "50"))
899 int binary_exponent, decimal_exponent, format_decimals;
900 frexp (number, &binary_exponent);
901 decimal_exponent = binary_exponent * 3 / 10;
902 format_decimals = (DBL_DIG + 1) - decimal_exponent;
903 if (format_decimals > max_decimals + 2)
904 c_snprintf (r->string, 64, "%.*f", format_decimals, fabs (number));
908 if (r->string[0] == '0' && !style->include_leading_zero)
909 memmove (r->string, &r->string[1], strlen (r->string));
911 r->leading_zeros = strspn (r->string, "0.");
912 r->leading_nines = strspn (r->string, "9.");
913 r->integer_digits = strchr (r->string, '.') - r->string;
914 assert (r->integer_digits < 64);
915 assert (r->integer_digits >= 0);
916 r->negative = number < 0;
919 /* Returns the number of characters required to format the
920 magnitude represented by R to DECIMALS decimal places.
921 The return value includes integer digits and a decimal point
922 and fractional digits, if any, but it does not include any
923 negative prefix or suffix or other affixes.
925 *INTEGER_DIGITS is set to the number of digits before the
926 decimal point in the output, between 0 and 40.
928 If R represents a negative number and its rounded
929 representation would include at least one nonzero digit,
930 *NEGATIVE is set to true; otherwise, it is set to false. */
932 rounder_width (const struct rounder *r, int decimals,
933 int *integer_digits, bool *negative)
935 /* Calculate base measures. */
936 int width = r->integer_digits;
938 width += decimals + 1;
939 *integer_digits = r->integer_digits;
940 *negative = r->negative;
942 /* Rounding can cause adjustments. */
943 if (should_round_up (r, decimals))
945 /* Rounding up leading 9s adds a new digit (a 1). */
946 if (r->leading_nines >= width)
955 if (r->leading_zeros >= width)
957 /* All digits that remain after rounding are zeros.
958 Therefore we drop the negative sign. */
960 if (r->integer_digits == 0 && decimals == 0)
962 /* No digits at all are left. We need to display
963 at least a single digit (a zero). */
973 /* Formats the magnitude represented by R into OUTPUT, rounding
974 to DECIMALS decimal places. Exactly as many characters as
975 indicated by rounder_width are written. No terminating null
978 rounder_format (const struct rounder *r, int decimals, char *output)
980 int base_width = r->integer_digits + (decimals > 0 ? decimals + 1 : 0);
981 if (should_round_up (r, decimals))
983 if (r->leading_nines < base_width)
985 /* Rounding up. This is the common case where rounding
986 up doesn't add an extra digit. */
988 memcpy (output, r->string, base_width);
989 for (p = output + base_width - 1; ; p--)
991 assert (p >= output);
994 else if (*p >= '0' && *p <= '8')
1005 /* Rounding up leading 9s causes the result to be a 1
1006 followed by a number of 0s, plus a decimal point. */
1009 p = mempset (p, '0', r->integer_digits);
1013 p = mempset (p, '0', decimals);
1015 assert (p == output + base_width + 1);
1020 /* Rounding down. */
1021 if (r->integer_digits != 0 || decimals != 0)
1023 /* Common case: just copy the digits. */
1024 memcpy (output, r->string, base_width);
1028 /* No digits remain. The output is just a zero. */
1034 /* Helper functions. */
1036 /* Returns 10**X. */
1037 static double PURE_FUNCTION
1040 static const double p[] =
1042 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1043 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
1044 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
1045 1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39,
1048 return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (10.0, x);
1051 /* Returns 256**X. */
1052 static double PURE_FUNCTION
1055 static const double p[] =
1064 72057594037927936.0,
1065 18446744073709551616.0
1067 return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (256.0, x);
1070 /* Formats non-finite NUMBER into OUTPUT according to the width
1073 output_infinite (double number, const struct fmt_spec *format, char *output)
1075 assert (!isfinite (number));
1083 else if (isinf (number))
1084 s = number > 0 ? "+Infinity" : "-Infinity";
1088 buf_copy_str_lpad (output, format->w, s, ' ');
1091 output_overflow (format, output);
1093 output[format->w] = '\0';
1096 /* Formats OUTPUT as a missing value for the given FORMAT. */
1098 output_missing (const struct fmt_spec *format, char *output)
1100 memset (output, ' ', format->w);
1102 if (format->type != FMT_N)
1104 int dot_ofs = (format->type == FMT_PCT ? 2
1105 : format->type == FMT_E ? 5
1107 output[MAX (0, format->w - format->d - dot_ofs)] = '.';
1110 output[format->w - 1] = '.';
1112 output[format->w] = '\0';
1115 /* Formats OUTPUT for overflow given FORMAT. */
1117 output_overflow (const struct fmt_spec *format, char *output)
1119 memset (output, '*', format->w);
1120 output[format->w] = '\0';
1123 /* Converts the integer part of NUMBER to a packed BCD number
1124 with the given number of DIGITS in OUTPUT. If DIGITS is odd,
1125 the least significant nibble of the final byte in OUTPUT is
1126 set to 0. Returns true if successful, false if NUMBER is not
1127 representable. On failure, OUTPUT is cleared to all zero
1130 output_bcd_integer (double number, int digits, char *output)
1134 assert (digits < sizeof decimal);
1136 output[DIV_RND_UP (digits, 2)] = '\0';
1137 if (number != SYSMIS
1139 && number < power10 (digits)
1140 && c_snprintf (decimal, 64, "%0*.0f", digits, round (number)) == digits)
1142 const char *src = decimal;
1145 for (i = 0; i < digits / 2; i++)
1147 int d0 = *src++ - '0';
1148 int d1 = *src++ - '0';
1149 *output++ = (d0 << 4) + d1;
1152 *output = (*src - '0') << 4;
1158 memset (output, 0, DIV_RND_UP (digits, 2));
1163 /* Writes VALUE to OUTPUT as a BYTES-byte binary integer of the
1164 given INTEGER_FORMAT. */
1166 output_binary_integer (uint64_t value, int bytes,
1167 enum integer_format integer_format, char *output)
1169 integer_put (value, integer_format, output, bytes);
1172 /* Converts the BYTES bytes in DATA to twice as many hexadecimal
1173 digits in OUTPUT. */
1175 output_hex (const void *data_, size_t bytes, char *output)
1177 const uint8_t *data = data_;
1180 for (i = 0; i < bytes; i++)
1182 static const char hex_digits[] = "0123456789ABCDEF";
1183 *output++ = hex_digits[data[i] >> 4];
1184 *output++ = hex_digits[data[i] & 15];