1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2006, 2009, 2011 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/>. */
29 #include <data/calendar.h>
30 #include <data/format.h>
31 #include <data/settings.h>
32 #include <data/value.h>
34 #include <libpspp/assertion.h>
35 #include <libpspp/cast.h>
36 #include <libpspp/float-format.h>
37 #include <libpspp/integer-format.h>
38 #include <libpspp/message.h>
39 #include <libpspp/misc.h>
40 #include <libpspp/str.h>
41 #include <libpspp/pool.h>
42 #include <libpspp/i18n.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);
197 data_out (const union value *input, const char *encoding, const struct fmt_spec *format)
199 return data_out_pool (input, encoding, format, NULL);
203 /* Main conversion functions. */
205 /* Outputs F, COMMA, DOT, DOLLAR, PCT, E, CCA, CCB, CCC, CCD, and
208 output_number (const union value *input, const struct fmt_spec *format,
211 double number = input->f;
213 if (number == SYSMIS)
214 output_missing (format, output);
215 else if (!isfinite (number))
216 output_infinite (number, format, output);
219 if (format->type != FMT_E && fabs (number) < 1.5 * power10 (format->w))
222 rounder_init (&r, number, format->d);
224 if (output_decimal (&r, format, true, output)
225 || output_scientific (number, format, true, output)
226 || output_decimal (&r, format, false, output))
230 if (!output_scientific (number, format, false, output))
231 output_overflow (format, output);
235 /* Outputs N format. */
237 output_N (const union value *input, const struct fmt_spec *format,
240 double number = input->f * power10 (format->d);
241 if (input->f == SYSMIS || number < 0)
242 output_missing (format, output);
246 number = fabs (round (number));
247 if (number < power10 (format->w)
248 && sprintf (buf, "%0*.0f", format->w, number) == format->w)
249 memcpy (output, buf, format->w);
251 output_overflow (format, output);
254 output[format->w] = '\0';
257 /* Outputs Z format. */
259 output_Z (const union value *input, const struct fmt_spec *format,
262 double number = input->f * power10 (format->d);
264 if (input->f == SYSMIS)
265 output_missing (format, output);
266 else if (fabs (number) < power10 (format->w)
267 && sprintf (buf, "%0*.0f", format->w,
268 fabs (round (number))) == format->w)
270 if (number < 0 && strspn (buf, "0") < format->w)
272 char *p = &buf[format->w - 1];
273 *p = "}JKLMNOPQR"[*p - '0'];
275 memcpy (output, buf, format->w);
276 output[format->w] = '\0';
279 output_overflow (format, output);
282 /* Outputs P format. */
284 output_P (const union value *input, const struct fmt_spec *format,
287 if (output_bcd_integer (fabs (input->f * power10 (format->d)),
288 format->w * 2 - 1, output)
290 output[format->w - 1] |= 0xd;
292 output[format->w - 1] |= 0xf;
295 /* Outputs PK format. */
297 output_PK (const union value *input, const struct fmt_spec *format,
300 output_bcd_integer (input->f * power10 (format->d), format->w * 2, output);
303 /* Outputs IB format. */
305 output_IB (const union value *input, const struct fmt_spec *format,
308 double number = round (input->f * power10 (format->d));
309 if (input->f == SYSMIS
310 || number >= power256 (format->w) / 2 - 1
311 || number < -power256 (format->w) / 2)
312 memset (output, 0, format->w);
315 uint64_t integer = fabs (number);
318 output_binary_integer (integer, format->w,
319 settings_get_output_integer_format (),
323 output[format->w] = '\0';
326 /* Outputs PIB format. */
328 output_PIB (const union value *input, const struct fmt_spec *format,
331 double number = round (input->f * power10 (format->d));
332 if (input->f == SYSMIS
333 || number < 0 || number >= power256 (format->w))
334 memset (output, 0, format->w);
336 output_binary_integer (number, format->w,
337 settings_get_output_integer_format (), output);
339 output[format->w] = '\0';
342 /* Outputs PIBHEX format. */
344 output_PIBHEX (const union value *input, const struct fmt_spec *format,
347 double number = round (input->f);
348 if (input->f == SYSMIS)
349 output_missing (format, output);
350 else if (input->f < 0 || number >= power256 (format->w / 2))
351 output_overflow (format, output);
355 output_binary_integer (number, format->w / 2, INTEGER_MSB_FIRST, tmp);
356 output_hex (tmp, format->w / 2, output);
361 /* Outputs RB format. */
363 output_RB (const union value *input, const struct fmt_spec *format,
367 memcpy (output, &d, format->w);
369 output[format->w] = '\0';
372 /* Outputs RBHEX format. */
374 output_RBHEX (const union value *input, const struct fmt_spec *format,
379 output_hex (&d, format->w / 2, output);
382 /* Outputs DATE, ADATE, EDATE, JDATE, SDATE, QYR, MOYR, WKYR,
383 DATETIME, TIME, and DTIME formats. */
385 output_date (const union value *input, const struct fmt_spec *format,
388 double number = input->f;
389 int year, month, day, yday;
391 const char *template = fmt_date_template (format->type);
392 size_t template_width = strlen (template);
393 int excess_width = format->w - template_width;
398 assert (format->w >= template_width);
399 if (number == SYSMIS)
402 if (fmt_get_category (format->type) == FMT_CAT_DATE)
406 calendar_offset_to_gregorian (number / 60. / 60. / 24.,
407 &year, &month, &day, &yday);
408 number = fmod (number, 60. * 60. * 24.);
411 year = month = day = yday = 0;
413 while (*template != '\0')
417 while (template[count] == ch)
425 p += sprintf (p, "%02d", day);
427 p += sprintf (p, "%03d", yday);
431 p += sprintf (p, "%02d", month);
434 static const char *const months[12] =
436 "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
437 "JUL", "AUG", "SEP", "OCT", "NOV", "DEC",
439 p = stpcpy (p, months[month - 1]);
443 if (count >= 4 || excess_width >= 2)
446 p += sprintf (p, "%04d", year);
447 else if (format->type == FMT_DATETIME)
448 p = stpcpy (p, "****");
454 int epoch = settings_get_epoch ();
455 int offset = year - epoch;
456 if (offset < 0 || offset > 99)
458 p += sprintf (p, "%02d", abs (year) % 100);
462 p += sprintf (p, "%d", (month - 1) / 3 + 1);
465 p += sprintf (p, "%2d", (yday - 1) / 7 + 1);
470 number = fabs (number);
471 p += sprintf (p, "%*.0f", count, floor (number / 60. / 60. / 24.));
472 number = fmod (number, 60. * 60. * 24.);
477 number = fabs (number);
478 p += sprintf (p, "%0*.0f", count, floor (number / 60. / 60.));
479 number = fmod (number, 60. * 60.);
482 p += sprintf (p, "%02d", (int) floor (number / 60.));
483 number = fmod (number, 60.);
484 excess_width = format->w - (p - tmp);
485 if (excess_width < 0)
487 if (excess_width == 3 || excess_width == 4
488 || (excess_width >= 5 && format->d == 0))
489 p += sprintf (p, ":%02d", (int) number);
490 else if (excess_width >= 5)
492 int d = MIN (format->d, excess_width - 4);
494 sprintf (p, ":%0*.*f", w, d, number);
495 if (settings_get_decimal_char (FMT_F) != '.')
497 char *cp = strchr (p, '.');
499 *cp = settings_get_decimal_char (FMT_F);
514 buf_copy_lpad (output, format->w, tmp, p - tmp, ' ');
515 output[format->w] = '\0';
519 output_overflow (format, output);
523 output_missing (format, output);
527 /* Outputs WKDAY format. */
529 output_WKDAY (const union value *input, const struct fmt_spec *format,
532 static const char *const weekdays[7] =
534 "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY",
535 "THURSDAY", "FRIDAY", "SATURDAY",
538 if (input->f >= 1 && input->f < 8)
540 buf_copy_str_rpad (output, format->w,
541 weekdays[(int) input->f - 1], ' ');
542 output[format->w] = '\0';
546 if (input->f != SYSMIS)
547 msg (ME, _("Weekday number %f is not between 1 and 7."), input->f);
548 output_missing (format, output);
553 /* Outputs MONTH format. */
555 output_MONTH (const union value *input, const struct fmt_spec *format,
558 static const char *const months[12] =
560 "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE",
561 "JULY", "AUGUST", "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER",
564 if (input->f >= 1 && input->f < 13)
566 buf_copy_str_rpad (output, format->w, months[(int) input->f - 1], ' ');
567 output[format->w] = '\0';
571 if (input->f != SYSMIS)
572 msg (ME, _("Month number %f is not between 1 and 12."), input->f);
573 output_missing (format, output);
578 /* Outputs A format. */
580 output_A (const union value *input UNUSED,
581 const struct fmt_spec *format UNUSED, char *output UNUSED)
586 /* Outputs AHEX format. */
588 output_AHEX (const union value *input, const struct fmt_spec *format,
591 output_hex (value_str (input, format->w), format->w / 2, output);
594 /* Decimal and scientific formatting. */
596 /* If REQUEST plus the current *WIDTH fits within MAX_WIDTH,
597 increments *WIDTH by REQUEST and return true.
598 Otherwise returns false without changing *WIDTH. */
600 allocate_space (int request, int max_width, int *width)
602 assert (*width <= max_width);
603 if (request + *width <= max_width)
612 /* Tries to compose the number represented by R, in the style of
613 FORMAT, into OUTPUT. Returns true if successful, false on
614 failure, which occurs if FORMAT's width is too narrow. If
615 REQUIRE_AFFIXES is true, then the prefix and suffix specified
616 by FORMAT's style must be included; otherwise, they may be
617 omitted to make the number fit. */
619 output_decimal (const struct rounder *r, const struct fmt_spec *format,
620 bool require_affixes, char *output)
622 const struct fmt_number_style *style =
623 settings_get_style (format->type);
627 for (decimals = format->d; decimals >= 0; decimals--)
629 /* Formatted version of magnitude of NUMBER. */
632 /* Number of digits in MAGNITUDE's integer and fractional parts. */
635 /* Amount of space within the field width already claimed.
636 Initially this is the width of MAGNITUDE, then it is reduced
637 in stages as space is allocated to prefixes and suffixes and
638 grouping characters. */
641 /* Include various decorations? */
646 /* Position in output. */
649 /* Make sure there's room for the number's magnitude, plus
650 the negative suffix, plus (if negative) the negative
652 width = rounder_width (r, decimals, &integer_digits, &add_neg_prefix);
653 width += style->neg_suffix.width;
655 width += style->neg_prefix.width;
656 if (width > format->w)
659 /* If there's room for the prefix and suffix, allocate
660 space. If the affixes are required, but there's no
662 add_affixes = allocate_space (fmt_affix_width (style),
664 if (!add_affixes && require_affixes)
667 /* Check whether we should include grouping characters.
668 We need room for a complete set or we don't insert any at all.
669 We don't include grouping characters if decimal places were
670 requested but they were all dropped. */
671 add_grouping = (style->grouping != 0
672 && integer_digits > 3
673 && (format->d == 0 || decimals > 0)
674 && allocate_space ((integer_digits - 1) / 3,
677 /* Format the number's magnitude. */
678 rounder_format (r, decimals, magnitude);
680 /* Assemble number. */
682 if (format->w > width)
683 p = mempset (p, ' ', format->w - width);
685 p = stpcpy (p, style->neg_prefix.s);
687 p = stpcpy (p, style->prefix.s);
689 p = mempcpy (p, magnitude, integer_digits);
693 for (i = 0; i < integer_digits; i++)
695 if (i > 0 && (integer_digits - i) % 3 == 0)
696 *p++ = style->grouping;
702 *p++ = style->decimal;
703 p = mempcpy (p, &magnitude[integer_digits + 1], decimals);
706 p = stpcpy (p, style->suffix.s);
708 p = stpcpy (p, style->neg_suffix.s);
710 p = mempset (p, ' ', style->neg_suffix.width);
712 assert (p >= output + format->w);
713 assert (p <= output + format->w + style->extra_bytes);
721 /* Formats NUMBER into OUTPUT in scientific notation according to
722 the style of the format specified in FORMAT. */
724 output_scientific (double number, const struct fmt_spec *format,
725 bool require_affixes, char *output)
727 const struct fmt_number_style *style =
728 settings_get_style (format->type);
734 /* Allocate minimum required space. */
735 width = 6 + style->neg_suffix.width;
737 width += style->neg_prefix.width;
738 if (width > format->w)
741 /* Check for room for prefix and suffix. */
742 add_affixes = allocate_space (fmt_affix_width (style), format->w, &width);
743 if (require_affixes && !add_affixes)
746 /* Figure out number of characters we can use for the fraction,
747 if any. (If that turns out to be 1, then we'll output a
748 decimal point without any digits following; that's what the
749 # flag does in the call to sprintf, below.) */
750 fraction_width = MIN (MIN (format->d + 1, format->w - width), 16);
751 if (format->type != FMT_E && fraction_width == 1)
753 width += fraction_width;
755 /* Format (except suffix). */
757 if (width < format->w)
758 p = mempset (p, ' ', format->w - width);
760 p = stpcpy (p, style->neg_prefix.s);
762 p = stpcpy (p, style->prefix.s);
763 if (fraction_width > 0)
764 sprintf (p, "%#.*E", fraction_width - 1, fabs (number));
766 sprintf (p, "%.0E", fabs (number));
768 /* The C locale always uses a period `.' as a decimal point.
769 Translate to comma if necessary. */
770 if (style->decimal != '.')
772 char *cp = strchr (p, '.');
774 *cp = style->decimal;
777 /* Make exponent have exactly three digits, plus sign. */
779 char *cp = strchr (p, 'E') + 1;
780 long int exponent = strtol (cp, NULL, 10);
781 if (abs (exponent) > 999)
783 sprintf (cp, "%+04ld", exponent);
787 p = strchr (p, '\0');
789 p = stpcpy (p, style->suffix.s);
791 p = stpcpy (p, style->neg_suffix.s);
793 p = mempset (p, ' ', style->neg_suffix.width);
795 assert (p >= output + format->w);
796 assert (p <= output + format->w + style->extra_bytes);
802 /* Returns true if the magnitude represented by R should be
803 rounded up when chopped off at DECIMALS decimal places, false
804 if it should be rounded down. */
806 should_round_up (const struct rounder *r, int decimals)
808 int digit = r->string[r->integer_digits + decimals + 1];
809 assert (digit >= '0' && digit <= '9');
813 /* Initializes R for formatting the magnitude of NUMBER to no
814 more than MAX_DECIMAL decimal places. */
816 rounder_init (struct rounder *r, double number, int max_decimals)
818 assert (fabs (number) < 1e41);
819 assert (max_decimals >= 0 && max_decimals <= 16);
820 if (max_decimals == 0)
822 /* Fast path. No rounding needed.
824 We append ".00" to the integer representation because
825 round_up assumes that fractional digits are present. */
826 sprintf (r->string, "%.0f.00", fabs (round (number)));
832 This is more difficult than it really should be because
833 we have to make sure that numbers that are exactly
834 halfway between two representations are always rounded
835 away from zero. This is not what sprintf normally does
836 (usually it rounds to even), so we have to fake it as
837 best we can, by formatting with extra precision and then
838 doing the rounding ourselves.
840 We take up to two rounds to format numbers. In the
841 first round, we obtain 2 digits of precision beyond
842 those requested by the user. If those digits are
843 exactly "50", then in a second round we format with as
844 many digits as are significant in a "double".
846 It might be better to directly implement our own
847 floating-point formatting routine instead of relying on
848 the system's sprintf implementation. But the classic
849 Steele and White paper on printing floating-point
850 numbers does not hint how to do what we want, and it's
851 not obvious how to change their algorithms to do so. It
852 would also be a lot of work. */
853 sprintf (r->string, "%.*f", max_decimals + 2, fabs (number));
854 if (!strcmp (r->string + strlen (r->string) - 2, "50"))
856 int binary_exponent, decimal_exponent, format_decimals;
857 frexp (number, &binary_exponent);
858 decimal_exponent = binary_exponent * 3 / 10;
859 format_decimals = (DBL_DIG + 1) - decimal_exponent;
860 if (format_decimals > max_decimals + 2)
861 sprintf (r->string, "%.*f", format_decimals, fabs (number));
865 if (r->string[0] == '0')
866 memmove (r->string, &r->string[1], strlen (r->string));
868 r->leading_zeros = strspn (r->string, "0.");
869 r->leading_nines = strspn (r->string, "9.");
870 r->integer_digits = strchr (r->string, '.') - r->string;
871 r->negative = number < 0;
874 /* Returns the number of characters required to format the
875 magnitude represented by R to DECIMALS decimal places.
876 The return value includes integer digits and a decimal point
877 and fractional digits, if any, but it does not include any
878 negative prefix or suffix or other affixes.
880 *INTEGER_DIGITS is set to the number of digits before the
881 decimal point in the output, between 0 and 40.
883 If R represents a negative number and its rounded
884 representation would include at least one nonzero digit,
885 *NEGATIVE is set to true; otherwise, it is set to false. */
887 rounder_width (const struct rounder *r, int decimals,
888 int *integer_digits, bool *negative)
890 /* Calculate base measures. */
891 int width = r->integer_digits;
893 width += decimals + 1;
894 *integer_digits = r->integer_digits;
895 *negative = r->negative;
897 /* Rounding can cause adjustments. */
898 if (should_round_up (r, decimals))
900 /* Rounding up leading 9s adds a new digit (a 1). */
901 if (r->leading_nines >= width)
910 if (r->leading_zeros >= width)
912 /* All digits that remain after rounding are zeros.
913 Therefore we drop the negative sign. */
915 if (r->integer_digits == 0 && decimals == 0)
917 /* No digits at all are left. We need to display
918 at least a single digit (a zero). */
928 /* Formats the magnitude represented by R into OUTPUT, rounding
929 to DECIMALS decimal places. Exactly as many characters as
930 indicated by rounder_width are written. No terminating null
933 rounder_format (const struct rounder *r, int decimals, char *output)
935 int base_width = r->integer_digits + (decimals > 0 ? decimals + 1 : 0);
936 if (should_round_up (r, decimals))
938 if (r->leading_nines < base_width)
940 /* Rounding up. This is the common case where rounding
941 up doesn't add an extra digit. */
943 memcpy (output, r->string, base_width);
944 for (p = output + base_width - 1; ; p--)
946 assert (p >= output);
949 else if (*p >= '0' && *p <= '8')
960 /* Rounding up leading 9s causes the result to be a 1
961 followed by a number of 0s, plus a decimal point. */
964 p = mempset (p, '0', r->integer_digits);
968 p = mempset (p, '0', decimals);
970 assert (p == output + base_width + 1);
976 if (r->integer_digits != 0 || decimals != 0)
978 /* Common case: just copy the digits. */
979 memcpy (output, r->string, base_width);
983 /* No digits remain. The output is just a zero. */
989 /* Helper functions. */
992 static double PURE_FUNCTION
995 static const double p[] =
997 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
998 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
999 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
1000 1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39,
1003 return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (10.0, x);
1006 /* Returns 256**X. */
1007 static double PURE_FUNCTION
1010 static const double p[] =
1019 72057594037927936.0,
1020 18446744073709551616.0
1022 return x >= 0 && x < sizeof p / sizeof *p ? p[x] : pow (256.0, x);
1025 /* Formats non-finite NUMBER into OUTPUT according to the width
1028 output_infinite (double number, const struct fmt_spec *format, char *output)
1030 assert (!isfinite (number));
1038 else if (isinf (number))
1039 s = number > 0 ? "+Infinity" : "-Infinity";
1043 buf_copy_str_lpad (output, format->w, s, ' ');
1046 output_overflow (format, output);
1048 output[format->w] = '\0';
1051 /* Formats OUTPUT as a missing value for the given FORMAT. */
1053 output_missing (const struct fmt_spec *format, char *output)
1055 memset (output, ' ', format->w);
1057 if (format->type != FMT_N)
1059 int dot_ofs = (format->type == FMT_PCT ? 2
1060 : format->type == FMT_E ? 5
1062 output[MAX (0, format->w - format->d - dot_ofs)] = '.';
1065 output[format->w - 1] = '.';
1067 output[format->w] = '\0';
1070 /* Formats OUTPUT for overflow given FORMAT. */
1072 output_overflow (const struct fmt_spec *format, char *output)
1074 memset (output, '*', format->w);
1075 output[format->w] = '\0';
1078 /* Converts the integer part of NUMBER to a packed BCD number
1079 with the given number of DIGITS in OUTPUT. If DIGITS is odd,
1080 the least significant nibble of the final byte in OUTPUT is
1081 set to 0. Returns true if successful, false if NUMBER is not
1082 representable. On failure, OUTPUT is cleared to all zero
1085 output_bcd_integer (double number, int digits, char *output)
1089 assert (digits < sizeof decimal);
1091 output[DIV_RND_UP (digits, 2)] = '\0';
1092 if (number != SYSMIS
1094 && number < power10 (digits)
1095 && sprintf (decimal, "%0*.0f", digits, round (number)) == digits)
1097 const char *src = decimal;
1100 for (i = 0; i < digits / 2; i++)
1102 int d0 = *src++ - '0';
1103 int d1 = *src++ - '0';
1104 *output++ = (d0 << 4) + d1;
1107 *output = (*src - '0') << 4;
1113 memset (output, 0, DIV_RND_UP (digits, 2));
1118 /* Writes VALUE to OUTPUT as a BYTES-byte binary integer of the
1119 given INTEGER_FORMAT. */
1121 output_binary_integer (uint64_t value, int bytes,
1122 enum integer_format integer_format, char *output)
1124 integer_put (value, integer_format, output, bytes);
1127 /* Converts the BYTES bytes in DATA to twice as many hexadecimal
1128 digits in OUTPUT. */
1130 output_hex (const void *data_, size_t bytes, char *output)
1132 const uint8_t *data = data_;
1135 for (i = 0; i < bytes; i++)
1137 static const char hex_digits[] = "0123456789ABCDEF";
1138 *output++ = hex_digits[data[i] >> 4];
1139 *output++ = hex_digits[data[i] & 15];