1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2006, 2009, 2011, 2012, 2013 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)
203 struct fmt_spec wide_format;
205 if (fmt_get_category (format->type) & (FMT_CAT_BASIC | FMT_CAT_CUSTOM))
207 /* XXX In the common case this wastes memory for 40 bytes of mostly
209 wide_format.type = format->type;
211 wide_format.d = format->d;
212 format = &wide_format;
215 return data_out_pool (input, encoding, format, pool);
219 data_out (const union value *input, const char *encoding, const struct fmt_spec *format)
221 return data_out_pool (input, encoding, format, NULL);
225 /* Main conversion functions. */
227 /* Outputs F, COMMA, DOT, DOLLAR, PCT, E, CCA, CCB, CCC, CCD, and
230 output_number (const union value *input, const struct fmt_spec *format,
233 double number = input->f;
235 if (number == SYSMIS)
236 output_missing (format, output);
237 else if (!isfinite (number))
238 output_infinite (number, format, output);
241 if (format->type != FMT_E && fabs (number) < 1.5 * power10 (format->w))
244 rounder_init (&r, number, format->d);
246 if (output_decimal (&r, format, true, output)
247 || output_scientific (number, format, true, output)
248 || output_decimal (&r, format, false, output))
252 if (!output_scientific (number, format, false, output))
253 output_overflow (format, output);
257 /* Outputs N format. */
259 output_N (const union value *input, const struct fmt_spec *format,
262 double number = input->f * power10 (format->d);
263 if (input->f == SYSMIS || number < 0)
264 output_missing (format, output);
268 number = fabs (round (number));
269 if (number < power10 (format->w)
270 && c_snprintf (buf, 128, "%0*.0f", format->w, number) == format->w)
271 memcpy (output, buf, format->w);
273 output_overflow (format, output);
276 output[format->w] = '\0';
279 /* Outputs Z format. */
281 output_Z (const union value *input, const struct fmt_spec *format,
284 double number = input->f * power10 (format->d);
286 if (input->f == SYSMIS)
287 output_missing (format, output);
288 else if (fabs (number) < power10 (format->w)
289 && c_snprintf (buf, 128, "%0*.0f", format->w,
290 fabs (round (number))) == format->w)
292 if (number < 0 && strspn (buf, "0") < format->w)
294 char *p = &buf[format->w - 1];
295 *p = "}JKLMNOPQR"[*p - '0'];
297 memcpy (output, buf, format->w);
298 output[format->w] = '\0';
301 output_overflow (format, output);
304 /* Outputs P format. */
306 output_P (const union value *input, const struct fmt_spec *format,
309 if (output_bcd_integer (fabs (input->f * power10 (format->d)),
310 format->w * 2 - 1, output)
312 output[format->w - 1] |= 0xd;
314 output[format->w - 1] |= 0xf;
317 /* Outputs PK format. */
319 output_PK (const union value *input, const struct fmt_spec *format,
322 output_bcd_integer (input->f * power10 (format->d), format->w * 2, output);
325 /* Outputs IB format. */
327 output_IB (const union value *input, const struct fmt_spec *format,
330 double number = round (input->f * power10 (format->d));
331 if (input->f == SYSMIS
332 || number >= power256 (format->w) / 2 - 1
333 || number < -power256 (format->w) / 2)
334 memset (output, 0, format->w);
337 uint64_t integer = fabs (number);
340 output_binary_integer (integer, format->w,
341 settings_get_output_integer_format (),
345 output[format->w] = '\0';
348 /* Outputs PIB format. */
350 output_PIB (const union value *input, const struct fmt_spec *format,
353 double number = round (input->f * power10 (format->d));
354 if (input->f == SYSMIS
355 || number < 0 || number >= power256 (format->w))
356 memset (output, 0, format->w);
358 output_binary_integer (number, format->w,
359 settings_get_output_integer_format (), output);
361 output[format->w] = '\0';
364 /* Outputs PIBHEX format. */
366 output_PIBHEX (const union value *input, const struct fmt_spec *format,
369 double number = round (input->f);
370 if (input->f == SYSMIS)
371 output_missing (format, output);
372 else if (input->f < 0 || number >= power256 (format->w / 2))
373 output_overflow (format, output);
377 output_binary_integer (number, format->w / 2, INTEGER_MSB_FIRST, tmp);
378 output_hex (tmp, format->w / 2, output);
383 /* Outputs RB format. */
385 output_RB (const union value *input, const struct fmt_spec *format,
389 memcpy (output, &d, format->w);
391 output[format->w] = '\0';
394 /* Outputs RBHEX format. */
396 output_RBHEX (const union value *input, const struct fmt_spec *format,
401 output_hex (&d, format->w / 2, output);
404 /* Outputs DATE, ADATE, EDATE, JDATE, SDATE, QYR, MOYR, WKYR,
405 DATETIME, TIME, and DTIME formats. */
407 output_date (const union value *input, const struct fmt_spec *format,
410 double number = input->f;
411 int year, month, day, yday;
413 const char *template = fmt_date_template (format->type, format->w);
418 if (number == SYSMIS)
421 if (fmt_get_category (format->type) == FMT_CAT_DATE)
425 calendar_offset_to_gregorian (number / 60. / 60. / 24.,
426 &year, &month, &day, &yday);
427 number = fmod (number, 60. * 60. * 24.);
430 year = month = day = yday = 0;
432 while (*template != '\0')
438 while (template[count] == ch)
446 p += sprintf (p, "%02d", day);
448 p += sprintf (p, "%03d", yday);
452 p += sprintf (p, "%02d", month);
455 static const char *const months[12] =
457 "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
458 "JUL", "AUG", "SEP", "OCT", "NOV", "DEC",
460 p = stpcpy (p, months[month - 1]);
467 p += sprintf (p, "%04d", year);
468 else if (format->type == FMT_DATETIME)
469 p = stpcpy (p, "****");
475 int epoch = settings_get_epoch ();
476 int offset = year - epoch;
477 if (offset < 0 || offset > 99)
479 p += sprintf (p, "%02d", abs (year) % 100);
483 p += sprintf (p, "%d", (month - 1) / 3 + 1);
486 p += sprintf (p, "%2d", (yday - 1) / 7 + 1);
491 number = fabs (number);
492 p += c_snprintf (p, 64, "%*.0f", count, floor (number / 60. / 60. / 24.));
493 number = fmod (number, 60. * 60. * 24.);
498 number = fabs (number);
499 p += c_snprintf (p, 64, "%0*.0f", count, floor (number / 60. / 60.));
500 number = fmod (number, 60. * 60.);
503 p += sprintf (p, "%02d", (int) floor (number / 60.));
504 number = fmod (number, 60.);
505 excess_width = format->w - (p - tmp);
506 if (excess_width < 0)
508 if (excess_width == 3 || excess_width == 4
509 || (excess_width >= 5 && format->d == 0))
510 p += sprintf (p, ":%02d", (int) number);
511 else if (excess_width >= 5)
513 int d = MIN (format->d, excess_width - 4);
515 c_snprintf (p, 64, ":%0*.*f", w, d, number);
516 if (settings_get_decimal_char (FMT_F) != '.')
518 char *cp = strchr (p, '.');
520 *cp = settings_get_decimal_char (FMT_F);
533 buf_copy_lpad (output, format->w, tmp, p - tmp, ' ');
534 output[format->w] = '\0';
538 output_overflow (format, output);
542 output_missing (format, output);
546 /* Outputs WKDAY format. */
548 output_WKDAY (const union value *input, const struct fmt_spec *format,
551 static const char *const weekdays[7] =
553 "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY",
554 "THURSDAY", "FRIDAY", "SATURDAY",
557 if (input->f >= 1 && input->f < 8)
559 buf_copy_str_rpad (output, format->w,
560 weekdays[(int) input->f - 1], ' ');
561 output[format->w] = '\0';
565 if (input->f != SYSMIS)
566 msg (ME, _("Weekday number %f is not between 1 and 7."), input->f);
567 output_missing (format, output);
572 /* Outputs MONTH format. */
574 output_MONTH (const union value *input, const struct fmt_spec *format,
577 static const char *const months[12] =
579 "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE",
580 "JULY", "AUGUST", "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER",
583 if (input->f >= 1 && input->f < 13)
585 buf_copy_str_rpad (output, format->w, months[(int) input->f - 1], ' ');
586 output[format->w] = '\0';
590 if (input->f != SYSMIS)
591 msg (ME, _("Month number %f is not between 1 and 12."), input->f);
592 output_missing (format, output);
597 /* Outputs A format. */
599 output_A (const union value *input UNUSED,
600 const struct fmt_spec *format UNUSED, char *output UNUSED)
605 /* Outputs AHEX format. */
607 output_AHEX (const union value *input, const struct fmt_spec *format,
610 output_hex (value_str (input, format->w), format->w / 2, output);
613 /* Decimal and scientific formatting. */
615 /* If REQUEST plus the current *WIDTH fits within MAX_WIDTH,
616 increments *WIDTH by REQUEST and return true.
617 Otherwise returns false without changing *WIDTH. */
619 allocate_space (int request, int max_width, int *width)
621 assert (*width <= max_width);
622 if (request + *width <= max_width)
631 /* Tries to compose the number represented by R, in the style of
632 FORMAT, into OUTPUT. Returns true if successful, false on
633 failure, which occurs if FORMAT's width is too narrow. If
634 REQUIRE_AFFIXES is true, then the prefix and suffix specified
635 by FORMAT's style must be included; otherwise, they may be
636 omitted to make the number fit. */
638 output_decimal (const struct rounder *r, const struct fmt_spec *format,
639 bool require_affixes, char *output)
641 const struct fmt_number_style *style =
642 settings_get_style (format->type);
646 for (decimals = format->d; decimals >= 0; decimals--)
648 /* Formatted version of magnitude of NUMBER. */
651 /* Number of digits in MAGNITUDE's integer and fractional parts. */
654 /* Amount of space within the field width already claimed.
655 Initially this is the width of MAGNITUDE, then it is reduced
656 in stages as space is allocated to prefixes and suffixes and
657 grouping characters. */
660 /* Include various decorations? */
665 /* Position in output. */
668 /* Make sure there's room for the number's magnitude, plus
669 the negative suffix, plus (if negative) the negative
671 width = rounder_width (r, decimals, &integer_digits, &add_neg_prefix);
672 width += style->neg_suffix.width;
674 width += style->neg_prefix.width;
675 if (width > format->w)
678 /* If there's room for the prefix and suffix, allocate
679 space. If the affixes are required, but there's no
681 add_affixes = allocate_space (fmt_affix_width (style),
683 if (!add_affixes && require_affixes)
686 /* Check whether we should include grouping characters.
687 We need room for a complete set or we don't insert any at all.
688 We don't include grouping characters if decimal places were
689 requested but they were all dropped. */
690 add_grouping = (style->grouping != 0
691 && integer_digits > 3
692 && (format->d == 0 || decimals > 0)
693 && allocate_space ((integer_digits - 1) / 3,
696 /* Format the number's magnitude. */
697 rounder_format (r, decimals, magnitude);
699 /* Assemble number. */
701 if (format->w > width)
702 p = mempset (p, ' ', format->w - width);
704 p = stpcpy (p, style->neg_prefix.s);
706 p = stpcpy (p, style->prefix.s);
708 p = mempcpy (p, magnitude, integer_digits);
712 for (i = 0; i < integer_digits; i++)
714 if (i > 0 && (integer_digits - i) % 3 == 0)
715 *p++ = style->grouping;
721 *p++ = style->decimal;
722 p = mempcpy (p, &magnitude[integer_digits + 1], decimals);
725 p = stpcpy (p, style->suffix.s);
727 p = stpcpy (p, style->neg_suffix.s);
729 p = mempset (p, ' ', style->neg_suffix.width);
731 assert (p >= output + format->w);
732 assert (p <= output + format->w + style->extra_bytes);
740 /* Formats NUMBER into OUTPUT in scientific notation according to
741 the style of the format specified in FORMAT. */
743 output_scientific (double number, const struct fmt_spec *format,
744 bool require_affixes, char *output)
746 const struct fmt_number_style *style =
747 settings_get_style (format->type);
753 /* Allocate minimum required space. */
754 width = 6 + style->neg_suffix.width;
756 width += style->neg_prefix.width;
757 if (width > format->w)
760 /* Check for room for prefix and suffix. */
761 add_affixes = allocate_space (fmt_affix_width (style), format->w, &width);
762 if (require_affixes && !add_affixes)
765 /* Figure out number of characters we can use for the fraction,
766 if any. (If that turns out to be 1, then we'll output a
767 decimal point without any digits following; that's what the
768 # flag does in the call to c_snprintf, below.) */
769 fraction_width = MIN (MIN (format->d + 1, format->w - width), 16);
770 if (format->type != FMT_E && fraction_width == 1)
772 width += fraction_width;
774 /* Format (except suffix). */
776 if (width < format->w)
777 p = mempset (p, ' ', format->w - width);
779 p = stpcpy (p, style->neg_prefix.s);
781 p = stpcpy (p, style->prefix.s);
782 if (fraction_width > 0)
783 c_snprintf (p, 64, "%#.*E", fraction_width - 1, fabs (number));
785 c_snprintf (p, 64, "%.0E", fabs (number));
787 /* The C locale always uses a period `.' as a decimal point.
788 Translate to comma if necessary. */
789 if (style->decimal != '.')
791 char *cp = strchr (p, '.');
793 *cp = style->decimal;
796 /* Make exponent have exactly three digits, plus sign. */
798 char *cp = strchr (p, 'E') + 1;
799 long int exponent = strtol (cp, NULL, 10);
800 if (abs (exponent) > 999)
802 sprintf (cp, "%+04ld", exponent);
806 p = strchr (p, '\0');
808 p = stpcpy (p, style->suffix.s);
810 p = stpcpy (p, style->neg_suffix.s);
812 p = mempset (p, ' ', style->neg_suffix.width);
814 assert (p >= output + format->w);
815 assert (p <= output + format->w + style->extra_bytes);
821 /* Returns true if the magnitude represented by R should be
822 rounded up when chopped off at DECIMALS decimal places, false
823 if it should be rounded down. */
825 should_round_up (const struct rounder *r, int decimals)
827 int digit = r->string[r->integer_digits + decimals + 1];
828 assert (digit >= '0' && digit <= '9');
832 /* Initializes R for formatting the magnitude of NUMBER to no
833 more than MAX_DECIMAL decimal places. */
835 rounder_init (struct rounder *r, double number, int max_decimals)
837 assert (fabs (number) < 1e41);
838 assert (max_decimals >= 0 && max_decimals <= 16);
839 if (max_decimals == 0)
841 /* Fast path. No rounding needed.
843 We append ".00" to the integer representation because
844 round_up assumes that fractional digits are present. */
845 c_snprintf (r->string, 64, "%.0f.00", fabs (round (number)));
851 This is more difficult than it really should be because
852 we have to make sure that numbers that are exactly
853 halfway between two representations are always rounded
854 away from zero. This is not what sprintf normally does
855 (usually it rounds to even), so we have to fake it as
856 best we can, by formatting with extra precision and then
857 doing the rounding ourselves.
859 We take up to two rounds to format numbers. In the
860 first round, we obtain 2 digits of precision beyond
861 those requested by the user. If those digits are
862 exactly "50", then in a second round we format with as
863 many digits as are significant in a "double".
865 It might be better to directly implement our own
866 floating-point formatting routine instead of relying on
867 the system's sprintf implementation. But the classic
868 Steele and White paper on printing floating-point
869 numbers does not hint how to do what we want, and it's
870 not obvious how to change their algorithms to do so. It
871 would also be a lot of work. */
872 c_snprintf (r->string, 64, "%.*f", max_decimals + 2, fabs (number));
873 if (!strcmp (r->string + strlen (r->string) - 2, "50"))
875 int binary_exponent, decimal_exponent, format_decimals;
876 frexp (number, &binary_exponent);
877 decimal_exponent = binary_exponent * 3 / 10;
878 format_decimals = (DBL_DIG + 1) - decimal_exponent;
879 if (format_decimals > max_decimals + 2)
880 c_snprintf (r->string, 64, "%.*f", format_decimals, fabs (number));
884 if (r->string[0] == '0')
885 memmove (r->string, &r->string[1], strlen (r->string));
887 r->leading_zeros = strspn (r->string, "0.");
888 r->leading_nines = strspn (r->string, "9.");
889 r->integer_digits = strchr (r->string, '.') - r->string;
890 assert (r->integer_digits < 64);
891 assert (r->integer_digits >= 0);
892 r->negative = number < 0;
895 /* Returns the number of characters required to format the
896 magnitude represented by R to DECIMALS decimal places.
897 The return value includes integer digits and a decimal point
898 and fractional digits, if any, but it does not include any
899 negative prefix or suffix or other affixes.
901 *INTEGER_DIGITS is set to the number of digits before the
902 decimal point in the output, between 0 and 40.
904 If R represents a negative number and its rounded
905 representation would include at least one nonzero digit,
906 *NEGATIVE is set to true; otherwise, it is set to false. */
908 rounder_width (const struct rounder *r, int decimals,
909 int *integer_digits, bool *negative)
911 /* Calculate base measures. */
912 int width = r->integer_digits;
914 width += decimals + 1;
915 *integer_digits = r->integer_digits;
916 *negative = r->negative;
918 /* Rounding can cause adjustments. */
919 if (should_round_up (r, decimals))
921 /* Rounding up leading 9s adds a new digit (a 1). */
922 if (r->leading_nines >= width)
931 if (r->leading_zeros >= width)
933 /* All digits that remain after rounding are zeros.
934 Therefore we drop the negative sign. */
936 if (r->integer_digits == 0 && decimals == 0)
938 /* No digits at all are left. We need to display
939 at least a single digit (a zero). */
949 /* Formats the magnitude represented by R into OUTPUT, rounding
950 to DECIMALS decimal places. Exactly as many characters as
951 indicated by rounder_width are written. No terminating null
954 rounder_format (const struct rounder *r, int decimals, char *output)
956 int base_width = r->integer_digits + (decimals > 0 ? decimals + 1 : 0);
957 if (should_round_up (r, decimals))
959 if (r->leading_nines < base_width)
961 /* Rounding up. This is the common case where rounding
962 up doesn't add an extra digit. */
964 memcpy (output, r->string, base_width);
965 for (p = output + base_width - 1; ; p--)
967 assert (p >= output);
970 else if (*p >= '0' && *p <= '8')
981 /* Rounding up leading 9s causes the result to be a 1
982 followed by a number of 0s, plus a decimal point. */
985 p = mempset (p, '0', r->integer_digits);
989 p = mempset (p, '0', decimals);
991 assert (p == output + base_width + 1);
997 if (r->integer_digits != 0 || decimals != 0)
999 /* Common case: just copy the digits. */
1000 memcpy (output, r->string, base_width);
1004 /* No digits remain. The output is just a zero. */
1010 /* Helper functions. */
1012 /* Returns 10**X. */
1013 static double PURE_FUNCTION
1016 static const double p[] =
1018 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1019 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
1020 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
1021 1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39,
1024 return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (10.0, x);
1027 /* Returns 256**X. */
1028 static double PURE_FUNCTION
1031 static const double p[] =
1040 72057594037927936.0,
1041 18446744073709551616.0
1043 return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (256.0, x);
1046 /* Formats non-finite NUMBER into OUTPUT according to the width
1049 output_infinite (double number, const struct fmt_spec *format, char *output)
1051 assert (!isfinite (number));
1059 else if (isinf (number))
1060 s = number > 0 ? "+Infinity" : "-Infinity";
1064 buf_copy_str_lpad (output, format->w, s, ' ');
1067 output_overflow (format, output);
1069 output[format->w] = '\0';
1072 /* Formats OUTPUT as a missing value for the given FORMAT. */
1074 output_missing (const struct fmt_spec *format, char *output)
1076 memset (output, ' ', format->w);
1078 if (format->type != FMT_N)
1080 int dot_ofs = (format->type == FMT_PCT ? 2
1081 : format->type == FMT_E ? 5
1083 output[MAX (0, format->w - format->d - dot_ofs)] = '.';
1086 output[format->w - 1] = '.';
1088 output[format->w] = '\0';
1091 /* Formats OUTPUT for overflow given FORMAT. */
1093 output_overflow (const struct fmt_spec *format, char *output)
1095 memset (output, '*', format->w);
1096 output[format->w] = '\0';
1099 /* Converts the integer part of NUMBER to a packed BCD number
1100 with the given number of DIGITS in OUTPUT. If DIGITS is odd,
1101 the least significant nibble of the final byte in OUTPUT is
1102 set to 0. Returns true if successful, false if NUMBER is not
1103 representable. On failure, OUTPUT is cleared to all zero
1106 output_bcd_integer (double number, int digits, char *output)
1110 assert (digits < sizeof decimal);
1112 output[DIV_RND_UP (digits, 2)] = '\0';
1113 if (number != SYSMIS
1115 && number < power10 (digits)
1116 && c_snprintf (decimal, 64, "%0*.0f", digits, round (number)) == digits)
1118 const char *src = decimal;
1121 for (i = 0; i < digits / 2; i++)
1123 int d0 = *src++ - '0';
1124 int d1 = *src++ - '0';
1125 *output++ = (d0 << 4) + d1;
1128 *output = (*src - '0') << 4;
1134 memset (output, 0, DIV_RND_UP (digits, 2));
1139 /* Writes VALUE to OUTPUT as a BYTES-byte binary integer of the
1140 given INTEGER_FORMAT. */
1142 output_binary_integer (uint64_t value, int bytes,
1143 enum integer_format integer_format, char *output)
1145 integer_put (value, integer_format, output, bytes);
1148 /* Converts the BYTES bytes in DATA to twice as many hexadecimal
1149 digits in OUTPUT. */
1151 output_hex (const void *data_, size_t bytes, char *output)
1153 const uint8_t *data = data_;
1156 for (i = 0; i < bytes; i++)
1158 static const char hex_digits[] = "0123456789ABCDEF";
1159 *output++ = hex_digits[data[i] >> 4];
1160 *output++ = hex_digits[data[i] & 15];