1 /* PSPP - computes sample statistics.
2 Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
3 Written by Ben Pfaff <blp@gnu.org>.
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
27 #include <data/identifier.h>
28 #include <data/settings.h>
29 #include <data/variable.h>
30 #include <libpspp/assertion.h>
31 #include <libpspp/compiler.h>
32 #include <libpspp/message.h>
33 #include <libpspp/misc.h>
34 #include <libpspp/str.h>
40 #define _(msgid) gettext (msgid)
42 static bool is_fmt_type (enum fmt_type);
44 static int min_width (enum fmt_type, bool for_input);
45 static int max_width (enum fmt_type);
46 static bool valid_width (enum fmt_type, int width, bool for_input);
47 static int max_decimals (enum fmt_type, int width, bool for_input);
49 static int max_digits_for_bytes (int bytes);
51 /* Initialize the format module. */
55 static bool inited = false;
59 fmt_set_decimal ('.');
63 static struct fmt_number_style *styles[FMT_NUMBER_OF_FORMATS];
65 /* Deinitialize the format module. */
70 for (t = 0 ; t < FMT_NUMBER_OF_FORMATS ; ++t )
71 fmt_number_style_destroy (styles[t]);
74 /* Returns an input format specification with type TYPE, width W,
77 fmt_for_input (enum fmt_type type, int w, int d)
83 assert (fmt_check_input (&f));
87 /* Returns an output format specification with type TYPE, width
90 fmt_for_output (enum fmt_type type, int w, int d)
96 assert (fmt_check_output (&f));
100 /* Returns the output format specifier corresponding to input
101 format specifier INPUT. */
103 fmt_for_output_from_input (const struct fmt_spec *input)
105 struct fmt_spec output;
107 assert (fmt_check_input (input));
109 output.type = fmt_input_to_output (input->type);
111 if (output.w > fmt_max_output_width (output.type))
112 output.w = fmt_max_output_width (output.type);
113 else if (output.w < fmt_min_output_width (output.type))
114 output.w = fmt_min_output_width (output.type);
131 const struct fmt_number_style *style = fmt_get_style (input->type);
132 output.w += fmt_affix_width (style);
133 if (style->grouping != 0 && input->w - input->d >= 3)
134 output.w += (input->w - input->d - 1) / 3;
146 output.d = MAX (input->d, 3);
147 output.w = MAX (input->w, output.d + 7);
151 output.w = max_digits_for_bytes (input->w / 2) + 1;
162 output.w = 2 * input->w + (input->d > 0);
167 output.w = max_digits_for_bytes (input->w) + 1;
183 output.w = input->w / 2;
205 if (output.w > fmt_max_output_width (output.type))
206 output.w = fmt_max_output_width (output.type);
208 assert (fmt_check_output (&output));
212 /* Checks whether SPEC is valid as an input format (if FOR_INPUT)
213 or an output format (otherwise) and returns nonzero if so.
214 Otherwise, emits an error message and returns zero. */
216 fmt_check (const struct fmt_spec *spec, bool for_input)
218 const char *io_fmt = for_input ? _("Input format") : _("Output format");
219 char str[FMT_STRING_LEN_MAX + 1];
220 int min_w, max_w, max_d;
222 assert (is_fmt_type (spec->type));
223 fmt_to_string (spec, str);
225 if (for_input && !fmt_usable_for_input (spec->type))
227 msg (SE, _("Format %s may not be used for input."), str);
231 if (spec->w % fmt_step_width (spec->type))
233 assert (fmt_step_width (spec->type) == 2);
234 msg (SE, _("%s specifies width %d, but %s requires an even width."),
235 str, spec->w, fmt_name (spec->type));
239 min_w = min_width (spec->type, for_input);
240 max_w = max_width (spec->type);
241 if (spec->w < min_w || spec->w > max_w)
243 msg (SE, _("%s %s specifies width %d, but "
244 "%s requires a width between %d and %d."),
245 io_fmt, str, spec->w, fmt_name (spec->type), min_w, max_w);
249 max_d = max_decimals (spec->type, spec->w, for_input);
250 if (!fmt_takes_decimals (spec->type) && spec->d != 0)
252 msg (SE, ngettext ("%s %s specifies %d decimal place, but "
253 "%s does not allow any decimals.",
254 "%s %s specifies %d decimal places, but "
255 "%s does not allow any decimals.",
257 io_fmt, str, spec->d, fmt_name (spec->type));
260 else if (spec->d > max_d)
263 msg (SE, ngettext ("%s %s specifies %d decimal place, but "
264 "the given width allows at most %d decimals.",
265 "%s %s specifies %d decimal places, but "
266 "the given width allows at most %d decimals.",
268 io_fmt, str, spec->d, max_d);
270 msg (SE, ngettext ("%s %s specifies %d decimal place, but "
271 "the given width does not allow for any decimals.",
272 "%s %s specifies %d decimal places, but "
273 "the given width does not allow for any decimals.",
275 io_fmt, str, spec->d);
282 /* Checks whether SPEC is valid as an input format and returns
283 nonzero if so. Otherwise, emits an error message and returns
286 fmt_check_input (const struct fmt_spec *spec)
288 return fmt_check (spec, true);
291 /* Checks whether SPEC is valid as an output format and returns
292 true if so. Otherwise, emits an error message and returns false. */
294 fmt_check_output (const struct fmt_spec *spec)
296 return fmt_check (spec, false);
299 /* Checks that FORMAT is appropriate for a variable of the given
300 TYPE and returns true if so. Otherwise returns false and
301 emits an error message. */
303 fmt_check_type_compat (const struct fmt_spec *format, int var_type)
305 assert (var_type == NUMERIC || var_type == ALPHA);
306 if ((var_type == ALPHA) != (fmt_is_string (format->type) != 0))
308 char str[FMT_STRING_LEN_MAX + 1];
309 msg (SE, _("%s variables are not compatible with %s format %s."),
310 var_type == ALPHA ? _("String") : _("Numeric"),
311 var_type == ALPHA ? _("numeric") : _("string"),
312 fmt_to_string (format, str));
318 /* Checks that FORMAT is appropriate for a variable of the given
319 WIDTH and returns true if so. Otherwise returns false and
320 emits an error message. */
322 fmt_check_width_compat (const struct fmt_spec *format, int width)
324 if (!fmt_check_type_compat (format, width != 0 ? ALPHA : NUMERIC))
326 if (fmt_var_width (format) != width)
328 char str[FMT_STRING_LEN_MAX + 1];
329 msg (SE, _("String variable with width %d is not compatible with "
331 width, fmt_to_string (format, str));
337 /* Returns the width corresponding to the format specifier. The
338 return value is the value of the `width' member of a `struct
339 variable' for such an input format. */
341 fmt_var_width (const struct fmt_spec *spec)
343 return (spec->type == FMT_AHEX ? spec->w / 2
344 : spec->type == FMT_A ? spec->w
348 /* Converts F to its string representation (for instance, "F8.2")
349 in BUFFER. Returns BUFFER.
351 If F has decimals, they are included in the output string,
352 even if F's format type does not allow decimals, to allow
353 accurately presenting incorrect formats to the user. */
355 fmt_to_string (const struct fmt_spec *f, char buffer[FMT_STRING_LEN_MAX + 1])
357 if (fmt_takes_decimals (f->type) || f->d > 0)
358 snprintf (buffer, FMT_STRING_LEN_MAX + 1,
359 "%s%d.%d", fmt_name (f->type), f->w, f->d);
361 snprintf (buffer, FMT_STRING_LEN_MAX + 1,
362 "%s%d", fmt_name (f->type), f->w);
366 /* Describes a display format. */
370 int min_input_width, min_output_width;
372 enum fmt_category category;
375 static const struct fmt_desc *get_fmt_desc (enum fmt_type type);
377 /* Returns the name of the given format TYPE. */
379 fmt_name (enum fmt_type type)
381 return get_fmt_desc (type)->name;
384 /* Tries to parse NAME as a format type.
385 If successful, stores the type in *TYPE and returns true.
386 On failure, returns false. */
388 fmt_from_name (const char *name, enum fmt_type *type)
392 for (i = 0; i < FMT_NUMBER_OF_FORMATS; i++)
393 if (!strcasecmp (name, get_fmt_desc (i)->name))
401 /* Returns true if TYPE accepts decimal places,
404 fmt_takes_decimals (enum fmt_type type)
406 return fmt_max_output_decimals (type, fmt_max_output_width (type)) > 0;
409 /* Returns the minimum acceptable width for an input field
410 formatted with the given TYPE. */
412 fmt_min_input_width (enum fmt_type type)
414 return get_fmt_desc (type)->min_input_width;
417 /* Returns the maximum acceptable width for an input field
418 formatted with the given TYPE. */
420 fmt_max_input_width (enum fmt_type type)
422 return max_width (type);
425 /* Returns the maximum number of decimal places allowed in an
426 input field of the given TYPE and WIDTH. */
428 fmt_max_input_decimals (enum fmt_type type, int width)
430 assert (valid_width (type, width, true));
431 return max_decimals (type, width, true);
434 /* Returns the minimum acceptable width for an output field
435 formatted with the given TYPE. */
437 fmt_min_output_width (enum fmt_type type)
439 return get_fmt_desc (type)->min_output_width;
442 /* Returns the maximum acceptable width for an output field
443 formatted with the given TYPE. */
445 fmt_max_output_width (enum fmt_type type)
447 return max_width (type);
450 /* Returns the maximum number of decimal places allowed in an
451 output field of the given TYPE and WIDTH. */
453 fmt_max_output_decimals (enum fmt_type type, int width)
455 assert (valid_width (type, width, false));
456 return max_decimals (type, width, false);
459 /* Returns the width step for a field formatted with the given
460 TYPE. Field width must be a multiple of the width step. */
462 fmt_step_width (enum fmt_type type)
464 return fmt_get_category (type) == FMT_CAT_HEXADECIMAL ? 2 : 1;
467 /* Returns true if TYPE is used for string fields,
468 false if it is used for numeric fields. */
470 fmt_is_string (enum fmt_type type)
472 return fmt_get_category (type) == FMT_CAT_STRING;
475 /* Returns true if TYPE is used for numeric fields,
476 false if it is used for string fields. */
478 fmt_is_numeric (enum fmt_type type)
480 return !fmt_is_string (type);
483 /* Returns the format TYPE's category.
484 Each format type is in exactly one category,
485 and each category's value is bitwise disjoint from every other
486 category. Thus, the return value may be tested for equality
487 or compared bitwise against a mask of FMT_CAT_* values. */
489 fmt_get_category (enum fmt_type type)
491 return get_fmt_desc (type)->category;
494 /* Returns the output format selected by default when TYPE is
495 used as an input format. */
497 fmt_input_to_output (enum fmt_type type)
499 switch (fmt_get_category (type))
506 case FMT_CAT_HEXADECIMAL:
514 /* Returns the SPSS format type corresponding to the given PSPP
517 fmt_to_io (enum fmt_type type)
519 return get_fmt_desc (type)->io;
522 /* Determines the PSPP format corresponding to the given SPSS
523 format type. If successful, sets *FMT_TYPE to the PSPP format
524 and returns true. On failure, return false. */
526 fmt_from_io (int io, enum fmt_type *fmt_type)
530 for (type = 0; type < FMT_NUMBER_OF_FORMATS; type++)
531 if (get_fmt_desc (type)->io == io)
539 /* Returns true if TYPE may be used as an input format,
542 fmt_usable_for_input (enum fmt_type type)
544 assert (is_fmt_type (type));
545 return fmt_get_category (type) != FMT_CAT_CUSTOM;
548 /* For time and date formats, returns a template used for input
551 fmt_date_template (enum fmt_type type)
572 return "dd-mmm-yyyy HH:MM";
582 /* Returns true if TYPE is a valid format type,
585 is_fmt_type (enum fmt_type type)
587 return type < FMT_NUMBER_OF_FORMATS;
590 /* Returns the minimum width of the given format TYPE,
591 for input if FOR_INPUT is true,
592 for output otherwise. */
594 min_width (enum fmt_type type, bool for_input)
596 return for_input ? fmt_min_input_width (type) : fmt_min_output_width (type);
599 /* Returns the maximum width of the given format TYPE,
600 which is invariant between input and output. */
602 max_width (enum fmt_type type)
604 assert (is_fmt_type (type));
622 return 2 * MAX_STRING;
629 /* Returns true if WIDTH is a valid width for the given format
631 for input if FOR_INPUT is true,
632 for output otherwise. */
634 valid_width (enum fmt_type type, int width, bool for_input)
636 return (width >= min_width (type, for_input)
637 && width <= max_width (type));
640 /* Returns the maximum number of decimal places allowed for the
641 given format TYPE with a width of WIDTH places,
642 for input if FOR_INPUT is true,
643 for output otherwise. */
645 max_decimals (enum fmt_type type, int width, bool for_input)
654 max_d = for_input ? width : width - 1;
659 max_d = for_input ? width : width - 2;
663 max_d = for_input ? width : width - 7;
681 max_d = width * 2 - 1;
690 max_d = max_digits_for_bytes (width);
743 /* Returns the maximum number of decimal digits in an unsigned
744 binary number that is BYTES bytes long. */
746 max_digits_for_bytes (int bytes)
748 int map[8] = {3, 5, 8, 10, 13, 15, 17, 20};
749 assert (bytes > 0 && bytes <= sizeof map / sizeof *map);
750 return map[bytes - 1];
754 /* Creates and returns a new struct fmt_number_style,
755 initializing all affixes to empty strings. */
756 struct fmt_number_style *
757 fmt_number_style_create (void)
759 struct fmt_number_style *style = xmalloc (sizeof *style);
760 style->neg_prefix = ss_empty ();
761 style->prefix = ss_empty ();
762 style->suffix = ss_empty ();
763 style->neg_suffix = ss_empty ();
764 style->decimal = '.';
769 /* Destroys a struct fmt_number_style. */
771 fmt_number_style_destroy (struct fmt_number_style *style)
775 ss_dealloc (&style->neg_prefix);
776 ss_dealloc (&style->prefix);
777 ss_dealloc (&style->suffix);
778 ss_dealloc (&style->neg_suffix);
783 /* Returns the number formatting style associated with the given
785 const struct fmt_number_style *
786 fmt_get_style (enum fmt_type type)
788 assert (is_fmt_type (type));
789 assert (styles[type] != NULL);
793 /* Sets STYLE as the number formatting style associated with the
794 given format TYPE, transferring ownership of STYLE. */
796 fmt_set_style (enum fmt_type type, struct fmt_number_style *style)
798 assert (ss_length (style->neg_prefix) <= FMT_STYLE_AFFIX_MAX);
799 assert (ss_length (style->prefix) <= FMT_STYLE_AFFIX_MAX);
800 assert (ss_length (style->suffix) <= FMT_STYLE_AFFIX_MAX);
801 assert (ss_length (style->neg_suffix) <= FMT_STYLE_AFFIX_MAX);
802 assert (style->decimal == '.' || style->decimal == ',');
803 assert (style->grouping != style->decimal
804 && (style->grouping == '.' || style->grouping == ','
805 || style->grouping == 0));
807 assert (fmt_get_category (type) == FMT_CAT_CUSTOM);
808 assert (styles[type] != NULL);
810 fmt_number_style_destroy (styles[type]);
811 styles[type] = style;
814 /* Returns the total width of the standard prefix and suffix for
817 fmt_affix_width (const struct fmt_number_style *style)
819 return ss_length (style->prefix) + ss_length (style->suffix);
822 /* Returns the total width of the negative prefix and suffix for
825 fmt_neg_affix_width (const struct fmt_number_style *style)
827 return ss_length (style->neg_prefix) + ss_length (style->neg_suffix);
830 /* Returns the decimal point character for the given format
833 fmt_decimal_char (enum fmt_type type)
835 return fmt_get_style (type)->decimal;
838 /* Returns the grouping character for the given format TYPE, or 0
839 if the format type does not group digits. */
841 fmt_grouping_char (enum fmt_type type)
843 return fmt_get_style (type)->grouping;
846 /* Sets the number style for TYPE to have the given standard
847 PREFIX and SUFFIX, "-" as prefix suffix, an empty negative
848 suffix, DECIMAL as the decimal point character, and GROUPING
849 as the grouping character. */
851 set_style (enum fmt_type type,
852 const char *prefix, const char *suffix,
853 char decimal, char grouping)
855 struct fmt_number_style *style;
857 assert (is_fmt_type (type));
859 fmt_number_style_destroy (styles[type]);
861 style = styles[type] = fmt_number_style_create ();
862 ss_alloc_substring (&style->neg_prefix, ss_cstr ("-"));
863 ss_alloc_substring (&style->prefix, ss_cstr (prefix));
864 ss_alloc_substring (&style->suffix, ss_cstr (suffix));
865 style->decimal = decimal;
866 style->grouping = grouping;
869 /* Sets the number style for TYPE as with set_style, but only if
870 TYPE has not already been initialized. */
872 init_style (enum fmt_type type,
873 const char *prefix, const char *suffix,
874 char decimal, char grouping)
876 assert (is_fmt_type (type));
877 if (styles[type] == NULL)
878 set_style (type, prefix, suffix, decimal, grouping);
881 /* Sets the decimal point character to DECIMAL. */
883 fmt_set_decimal (char decimal)
885 int grouping = decimal == '.' ? ',' : '.';
886 assert (decimal == '.' || decimal == ',');
888 set_style (FMT_F, "", "", decimal, 0);
889 set_style (FMT_E, "", "", decimal, 0);
890 set_style (FMT_COMMA, "", "", decimal, grouping);
891 set_style (FMT_DOT, "", "", grouping, decimal);
892 set_style (FMT_DOLLAR, "$", "", decimal, grouping);
893 set_style (FMT_PCT, "", "%", decimal, 0);
895 init_style (FMT_CCA, "", "", decimal, grouping);
896 init_style (FMT_CCB, "", "", decimal, grouping);
897 init_style (FMT_CCC, "", "", decimal, grouping);
898 init_style (FMT_CCD, "", "", decimal, grouping);
899 init_style (FMT_CCE, "", "", decimal, grouping);
902 /* Returns true if M is a valid variable measurement level,
905 measure_is_valid (enum measure m)
907 return m > 0 && m < n_MEASURES;
910 /* Returns true if A is a valid alignment,
913 alignment_is_valid (enum alignment a)
918 /* Returns the struct fmt_desc for the given format TYPE. */
919 static const struct fmt_desc *
920 get_fmt_desc (enum fmt_type type)
922 static const struct fmt_desc formats[FMT_NUMBER_OF_FORMATS] =
924 #define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) \
925 {#NAME, IMIN, OMIN, IO, CATEGORY},
926 #include "format.def"
929 assert (is_fmt_type (type));
930 return &formats[type];