1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2012 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/variable.h"
23 #include "data/attributes.h"
24 #include "data/data-out.h"
25 #include "data/dictionary.h"
26 #include "data/format.h"
27 #include "data/identifier.h"
28 #include "data/missing-values.h"
29 #include "data/settings.h"
30 #include "data/value-labels.h"
31 #include "data/vardict.h"
32 #include "libpspp/assertion.h"
33 #include "libpspp/compiler.h"
34 #include "libpspp/hash-functions.h"
35 #include "libpspp/i18n.h"
36 #include "libpspp/message.h"
37 #include "libpspp/misc.h"
38 #include "libpspp/str.h"
40 #include "gl/minmax.h"
41 #include "gl/xalloc.h"
44 #define _(msgid) gettext (msgid)
49 /* Dictionary information. */
50 char *name; /* Variable name. Mixed case. */
51 int width; /* 0 for numeric, otherwise string width. */
52 struct missing_values miss; /* Missing values. */
53 struct fmt_spec print; /* Default format for PRINT. */
54 struct fmt_spec write; /* Default format for WRITE. */
55 struct val_labs *val_labs; /* Value labels. */
56 char *label; /* Variable label. */
57 struct string name_and_label; /* The name and label in the same string */
59 /* GUI information. */
60 enum measure measure; /* Nominal, ordinal, or continuous. */
61 int display_width; /* Width of data editor column. */
62 enum alignment alignment; /* Alignment of data in GUI. */
64 /* Case information. */
65 bool leave; /* Leave value from case to case? */
67 /* Data for use by containing dictionary. */
68 struct vardict_info *vardict;
70 /* Used only for system and portable file input and output.
73 size_t short_name_cnt;
75 /* Custom attributes. */
76 struct attrset attributes;
80 static bool var_set_label_quiet (struct variable *v, const char *label, bool issue_warning);
81 static void var_set_name_quiet (struct variable *v, const char *name);
83 /* Creates and returns a new variable with the given NAME and
84 WIDTH and other fields initialized to default values. The
85 variable is not added to a dictionary; for that, use
86 dict_create_var instead. */
88 var_create (const char *name, int width)
93 assert (width >= 0 && width <= MAX_STRING);
95 v = xzalloc (sizeof *v);
96 var_set_name_quiet (v, name);
98 mv_init (&v->miss, width);
99 v->leave = var_must_leave (v);
100 type = val_type_from_width (width);
101 v->alignment = var_default_alignment (type);
102 v->measure = var_default_measure (type);
103 v->display_width = var_default_display_width (width);
104 v->print = v->write = var_default_formats (width);
105 attrset_init (&v->attributes);
106 ds_init_empty (&v->name_and_label);
111 /* Destroys variable V.
112 V must not belong to a dictionary. If it does, use
113 dict_delete_var instead. */
115 var_destroy (struct variable *v)
119 assert (!var_has_vardict (v));
120 mv_destroy (&v->miss);
121 var_clear_short_names (v);
122 val_labs_destroy (v->val_labs);
123 var_set_label_quiet (v, NULL, false);
124 attrset_destroy (var_get_attributes (v));
126 ds_destroy (&v->name_and_label);
131 /* Variable names. */
133 /* Return variable V's name, as a UTF-8 encoded string. */
135 var_get_name (const struct variable *v)
142 /* Sets V's name to NAME, a UTF-8 encoded string.
143 Do not use this function for a variable in a dictionary. Use
144 dict_rename_var instead. */
146 var_set_name_quiet (struct variable *v, const char *name)
148 assert (!var_has_vardict (v));
149 assert (id_is_plausible (name, false));
152 v->name = xstrdup (name);
153 ds_destroy (&v->name_and_label);
154 ds_init_empty (&v->name_and_label);
157 /* Sets V's name to NAME, a UTF-8 encoded string.
158 Do not use this function for a variable in a dictionary. Use
159 dict_rename_var instead. */
161 var_set_name (struct variable *v, const char *name)
163 var_set_name_quiet (v, name);
164 dict_var_changed (v, VAR_TRAIT_NAME);
167 /* Returns VAR's dictionary class. */
169 var_get_dict_class (const struct variable *var)
171 return dict_class_from_id (var->name);
174 /* A hsh_compare_func that orders variables A and B by their
177 compare_vars_by_name (const void *a_, const void *b_, const void *aux UNUSED)
179 const struct variable *a = a_;
180 const struct variable *b = b_;
182 return utf8_strcasecmp (a->name, b->name);
185 /* A hsh_hash_func that hashes variable V based on its name. */
187 hash_var_by_name (const void *v_, const void *aux UNUSED)
189 const struct variable *v = v_;
191 return utf8_hash_case_string (v->name, 0);
194 /* A hsh_compare_func that orders pointers to variables A and B
197 compare_var_ptrs_by_name (const void *a_, const void *b_,
198 const void *aux UNUSED)
200 struct variable *const *a = a_;
201 struct variable *const *b = b_;
203 return utf8_strcasecmp (var_get_name (*a), var_get_name (*b));
206 /* A hsh_compare_func that orders pointers to variables A and B
207 by their dictionary indexes. */
209 compare_var_ptrs_by_dict_index (const void *a_, const void *b_,
210 const void *aux UNUSED)
212 struct variable *const *a = a_;
213 struct variable *const *b = b_;
214 size_t a_index = var_get_dict_index (*a);
215 size_t b_index = var_get_dict_index (*b);
217 return a_index < b_index ? -1 : a_index > b_index;
220 /* A hsh_hash_func that hashes pointer to variable V based on its
223 hash_var_ptr_by_name (const void *v_, const void *aux UNUSED)
225 struct variable *const *v = v_;
227 return utf8_hash_case_string (var_get_name (*v), 0);
230 /* Returns the type of variable V. */
232 var_get_type (const struct variable *v)
234 return val_type_from_width (v->width);
237 /* Returns the width of variable V. */
239 var_get_width (const struct variable *v)
244 /* Changes the width of V to NEW_WIDTH.
245 This function should be used cautiously. */
247 var_set_width (struct variable *v, int new_width)
249 const int old_width = v->width;
251 if (old_width == new_width)
254 if (mv_is_resizable (&v->miss, new_width))
255 mv_resize (&v->miss, new_width);
258 mv_destroy (&v->miss);
259 mv_init (&v->miss, new_width);
262 if (v->val_labs != NULL)
264 if (val_labs_can_set_width (v->val_labs, new_width))
265 val_labs_set_width (v->val_labs, new_width);
268 val_labs_destroy (v->val_labs);
273 fmt_resize (&v->print, new_width);
274 fmt_resize (&v->write, new_width);
276 v->width = new_width;
277 dict_var_resized (v, old_width);
278 dict_var_changed (v, VAR_TRAIT_WIDTH);
281 /* Returns true if variable V is numeric, false otherwise. */
283 var_is_numeric (const struct variable *v)
285 return var_get_type (v) == VAL_NUMERIC;
288 /* Returns true if variable V is a string variable, false
291 var_is_alpha (const struct variable *v)
293 return var_get_type (v) == VAL_STRING;
296 /* Returns variable V's missing values. */
297 const struct missing_values *
298 var_get_missing_values (const struct variable *v)
303 /* Sets variable V's missing values to MISS, which must be of V's
304 width or at least resizable to V's width.
305 If MISS is null, then V's missing values, if any, are
308 var_set_missing_values_quiet (struct variable *v, const struct missing_values *miss)
312 assert (mv_is_resizable (miss, v->width));
313 mv_destroy (&v->miss);
314 mv_copy (&v->miss, miss);
315 mv_resize (&v->miss, v->width);
321 /* Sets variable V's missing values to MISS, which must be of V's
322 width or at least resizable to V's width.
323 If MISS is null, then V's missing values, if any, are
326 var_set_missing_values (struct variable *v, const struct missing_values *miss)
328 var_set_missing_values_quiet (v, miss);
329 dict_var_changed (v, VAR_TRAIT_MISSING_VALUES);
332 /* Sets variable V to have no user-missing values. */
334 var_clear_missing_values (struct variable *v)
336 var_set_missing_values (v, NULL);
339 /* Returns true if V has any user-missing values,
342 var_has_missing_values (const struct variable *v)
344 return !mv_is_empty (&v->miss);
347 /* Returns true if VALUE is in the given CLASS of missing values
348 in V, false otherwise. */
350 var_is_value_missing (const struct variable *v, const union value *value,
353 return mv_is_value_missing (&v->miss, value, class);
356 /* Returns true if D is in the given CLASS of missing values in
358 V must be a numeric variable. */
360 var_is_num_missing (const struct variable *v, double d, enum mv_class class)
362 return mv_is_num_missing (&v->miss, d, class);
365 /* Returns true if S[] is a missing value for V, false otherwise.
366 S[] must contain exactly as many characters as V's width.
367 V must be a string variable. */
369 var_is_str_missing (const struct variable *v, const uint8_t s[],
372 return mv_is_str_missing (&v->miss, s, class);
375 /* Returns variable V's value labels,
376 possibly a null pointer if it has none. */
377 const struct val_labs *
378 var_get_value_labels (const struct variable *v)
383 /* Returns true if variable V has at least one value label. */
385 var_has_value_labels (const struct variable *v)
387 return val_labs_count (v->val_labs) > 0;
390 /* Sets variable V's value labels to a copy of VLS,
391 which must have a width equal to V's width or one that can be
392 changed to V's width.
393 If VLS is null, then V's value labels, if any, are removed. */
395 var_set_value_labels_quiet (struct variable *v, const struct val_labs *vls)
397 val_labs_destroy (v->val_labs);
402 assert (val_labs_can_set_width (vls, v->width));
403 v->val_labs = val_labs_clone (vls);
404 val_labs_set_width (v->val_labs, v->width);
409 /* Sets variable V's value labels to a copy of VLS,
410 which must have a width equal to V's width or one that can be
411 changed to V's width.
412 If VLS is null, then V's value labels, if any, are removed. */
414 var_set_value_labels (struct variable *v, const struct val_labs *vls)
416 var_set_value_labels_quiet (v, vls);
417 dict_var_changed (v, VAR_TRAIT_LABEL);
421 /* Makes sure that V has a set of value labels,
422 by assigning one to it if necessary. */
424 alloc_value_labels (struct variable *v)
426 if (v->val_labs == NULL)
427 v->val_labs = val_labs_create (v->width);
430 /* Attempts to add a value label with the given VALUE and UTF-8 encoded LABEL
431 to V. Returns true if successful, false otherwise (probably due to an
434 In LABEL, the two-byte sequence "\\n" is interpreted as a new-line. */
436 var_add_value_label (struct variable *v,
437 const union value *value, const char *label)
439 alloc_value_labels (v);
440 return val_labs_add (v->val_labs, value, label);
443 /* Adds or replaces a value label with the given VALUE and UTF-8 encoded LABEL
446 In LABEL, the two-byte sequence "\\n" is interpreted as a new-line. */
448 var_replace_value_label (struct variable *v,
449 const union value *value, const char *label)
451 alloc_value_labels (v);
452 val_labs_replace (v->val_labs, value, label);
455 /* Removes V's value labels, if any. */
457 var_clear_value_labels (struct variable *v)
459 var_set_value_labels (v, NULL);
462 /* Returns the label associated with VALUE for variable V, as a UTF-8 string in
463 a format suitable for output, or a null pointer if none. */
465 var_lookup_value_label (const struct variable *v, const union value *value)
467 return val_labs_find (v->val_labs, value);
471 Append to STR the string representation of VALUE for variable V.
472 STR must be a pointer to an initialised struct string.
475 append_value (const struct variable *v, const union value *value,
478 char *s = data_out (value, var_get_encoding (v), &v->print);
479 ds_put_cstr (str, s);
483 /* Append STR with a string representing VALUE for variable V.
484 That is, if VALUE has a label, append that label,
485 otherwise format VALUE and append the formatted string.
486 STR must be a pointer to an initialised struct string.
489 var_append_value_name (const struct variable *v, const union value *value,
492 enum settings_value_style style = settings_get_value_style ();
493 const char *name = var_lookup_value_label (v, value);
497 case SETTINGS_VAL_STYLE_VALUES:
498 append_value (v, value, str);
501 case SETTINGS_VAL_STYLE_LABELS:
503 append_value (v, value, str);
505 ds_put_cstr (str, name);
508 case SETTINGS_VAL_STYLE_BOTH:
510 append_value (v, value, str);
513 ds_put_cstr (str, " (");
514 ds_put_cstr (str, name);
515 ds_put_cstr (str, ")");
521 /* Print and write formats. */
523 /* Returns V's print format specification. */
524 const struct fmt_spec *
525 var_get_print_format (const struct variable *v)
530 /* Sets V's print format specification to PRINT, which must be a
531 valid format specification for a variable of V's width
532 (ordinarily an output format, but input formats are not
535 var_set_print_format_quiet (struct variable *v, const struct fmt_spec *print)
537 if (!fmt_equal (&v->print, print))
539 assert (fmt_check_width_compat (print, v->width));
544 /* Sets V's print format specification to PRINT, which must be a
545 valid format specification for a variable of V's width
546 (ordinarily an output format, but input formats are not
549 var_set_print_format (struct variable *v, const struct fmt_spec *print)
551 var_set_print_format_quiet (v, print);
552 dict_var_changed (v, VAR_TRAIT_FORMAT);
555 /* Returns V's write format specification. */
556 const struct fmt_spec *
557 var_get_write_format (const struct variable *v)
562 /* Sets V's write format specification to WRITE, which must be a
563 valid format specification for a variable of V's width
564 (ordinarily an output format, but input formats are not
567 var_set_write_format_quiet (struct variable *v, const struct fmt_spec *write)
569 if (!fmt_equal (&v->write, write))
571 assert (fmt_check_width_compat (write, v->width));
576 /* Sets V's write format specification to WRITE, which must be a
577 valid format specification for a variable of V's width
578 (ordinarily an output format, but input formats are not
581 var_set_write_format (struct variable *v, const struct fmt_spec *write)
583 var_set_write_format_quiet (v, write);
584 dict_var_changed (v, VAR_TRAIT_FORMAT);
588 /* Sets V's print and write format specifications to FORMAT,
589 which must be a valid format specification for a variable of
590 V's width (ordinarily an output format, but input formats are
593 var_set_both_formats (struct variable *v, const struct fmt_spec *format)
595 var_set_print_format_quiet (v, format);
596 var_set_write_format_quiet (v, format);
597 dict_var_changed (v, VAR_TRAIT_FORMAT);
600 /* Returns the default print and write format for a variable of
601 the given TYPE, as set by var_create. The return value can be
602 used to reset a variable's print and write formats to the
605 var_default_formats (int width)
608 ? fmt_for_output (FMT_F, 8, 2)
609 : fmt_for_output (FMT_A, width, 0));
615 /* Update the combined name and label string if necessary */
617 update_vl_string (const struct variable *v)
619 /* Cast away const! */
620 struct string *str = (struct string *) &v->name_and_label;
622 if (ds_is_empty (str))
625 ds_put_format (str, _("%s (%s)"), v->label, v->name);
627 ds_put_cstr (str, v->name);
632 /* Return a string representing this variable, in the form most
633 appropriate from a human factors perspective, that is, its
634 variable label if it has one, otherwise its name. */
636 var_to_string (const struct variable *v)
638 enum settings_var_style style = settings_get_var_style ();
642 case SETTINGS_VAR_STYLE_NAMES:
645 case SETTINGS_VAR_STYLE_LABELS:
646 return v->label != NULL ? v->label : v->name;
648 case SETTINGS_VAR_STYLE_BOTH:
649 update_vl_string (v);
650 return ds_cstr (&v->name_and_label);
658 /* Returns V's variable label, or a null pointer if it has none. */
660 var_get_label (const struct variable *v)
665 /* Sets V's variable label to UTF-8 encoded string LABEL, stripping off leading
666 and trailing white space. If LABEL is a null pointer or if LABEL is an
667 empty string (after stripping white space), then V's variable label (if any)
670 Variable labels are limited to 255 bytes in V's encoding (as returned by
671 var_get_encoding()). If LABEL fits within this limit, this function returns
672 true. Otherwise, the variable label is set to a truncated value, this
673 function returns false and, if ISSUE_WARNING is true, issues a warning. */
675 var_set_label_quiet (struct variable *v, const char *label, bool issue_warning)
677 bool truncated = false;
682 if (label != NULL && label[strspn (label, CC_SPACES)])
684 const char *dict_encoding = var_get_encoding (v);
685 struct substring s = ss_cstr (label);
688 if (dict_encoding != NULL)
690 enum { MAX_LABEL_LEN = 255 };
692 trunc_len = utf8_encoding_trunc_len (label, dict_encoding,
694 if (ss_length (s) > trunc_len)
697 msg (SW, _("Truncating variable label for variable `%s' to %d "
698 "bytes."), var_get_name (v), MAX_LABEL_LEN);
699 ss_truncate (&s, trunc_len);
704 v->label = ss_xstrdup (s);
707 ds_destroy (&v->name_and_label);
708 ds_init_empty (&v->name_and_label);
715 /* Sets V's variable label to UTF-8 encoded string LABEL, stripping off leading
716 and trailing white space. If LABEL is a null pointer or if LABEL is an
717 empty string (after stripping white space), then V's variable label (if any)
720 Variable labels are limited to 255 bytes in V's encoding (as returned by
721 var_get_encoding()). If LABEL fits within this limit, this function returns
722 true. Otherwise, the variable label is set to a truncated value, this
723 function returns false and, if ISSUE_WARNING is true, issues a warning. */
725 var_set_label (struct variable *v, const char *label, bool issue_warning)
727 bool truncated = var_set_label_quiet (v, label, issue_warning);
729 dict_var_changed (v, VAR_TRAIT_LABEL);
735 /* Removes any variable label from V. */
737 var_clear_label (struct variable *v)
739 var_set_label (v, NULL, false);
742 /* Returns true if V has a variable V,
745 var_has_label (const struct variable *v)
747 return v->label != NULL;
750 /* Returns true if M is a valid variable measurement level,
753 measure_is_valid (enum measure m)
755 return m == MEASURE_NOMINAL || m == MEASURE_ORDINAL || m == MEASURE_SCALE;
758 /* Returns a string version of measurement level M, for display to a user. */
760 measure_to_string (enum measure m)
764 case MEASURE_NOMINAL:
767 case MEASURE_ORDINAL:
778 /* Returns V's measurement level. */
780 var_get_measure (const struct variable *v)
785 /* Sets V's measurement level to MEASURE. */
787 var_set_measure_quiet (struct variable *v, enum measure measure)
789 assert (measure_is_valid (measure));
790 v->measure = measure;
794 /* Sets V's measurement level to MEASURE. */
796 var_set_measure (struct variable *v, enum measure measure)
798 var_set_measure_quiet (v, measure);
799 dict_var_changed (v, VAR_TRAIT_MEASURE);
803 /* Returns the default measurement level for a variable of the
804 given TYPE, as set by var_create. The return value can be
805 used to reset a variable's measurement level to the
808 var_default_measure (enum val_type type)
810 return type == VAL_NUMERIC ? MEASURE_SCALE : MEASURE_NOMINAL;
813 /* Returns V's display width, which applies only to GUIs. */
815 var_get_display_width (const struct variable *v)
817 return v->display_width;
820 /* Sets V's display width to DISPLAY_WIDTH. */
822 var_set_display_width_quiet (struct variable *v, int new_width)
824 if (v->display_width != new_width)
826 v->display_width = new_width;
827 dict_var_display_width_changed (v);
832 var_set_display_width (struct variable *v, int new_width)
834 var_set_display_width_quiet (v, new_width);
835 dict_var_changed (v, VAR_TRAIT_DISPLAY_WIDTH);
839 /* Returns the default display width for a variable of the given
840 WIDTH, as set by var_create. The return value can be used to
841 reset a variable's display width to the default. */
843 var_default_display_width (int width)
845 return width == 0 ? 8 : MIN (width, 32);
848 /* Returns true if A is a valid alignment,
851 alignment_is_valid (enum alignment a)
853 return a == ALIGN_LEFT || a == ALIGN_RIGHT || a == ALIGN_CENTRE;
856 /* Returns a string version of alignment A, for display to a user. */
858 alignment_to_string (enum alignment a)
876 /* Returns V's display alignment, which applies only to GUIs. */
878 var_get_alignment (const struct variable *v)
883 /* Sets V's display alignment to ALIGNMENT. */
885 var_set_alignment_quiet (struct variable *v, enum alignment alignment)
887 assert (alignment_is_valid (alignment));
888 v->alignment = alignment;
891 /* Sets V's display alignment to ALIGNMENT. */
893 var_set_alignment (struct variable *v, enum alignment alignment)
895 var_set_alignment_quiet (v, alignment);
896 dict_var_changed (v, VAR_TRAIT_ALIGNMENT);
900 /* Returns the default display alignment for a variable of the
901 given TYPE, as set by var_create. The return value can be
902 used to reset a variable's display alignment to the default. */
904 var_default_alignment (enum val_type type)
906 return type == VAL_NUMERIC ? ALIGN_RIGHT : ALIGN_LEFT;
909 /* Whether variables' values should be preserved from case to
912 /* Returns true if variable V's value should be left from case to
913 case, instead of being reset to system-missing or blanks. */
915 var_get_leave (const struct variable *v)
920 /* Sets V's leave setting to LEAVE. */
922 var_set_leave_quiet (struct variable *v, bool leave)
924 assert (leave || !var_must_leave (v));
929 /* Sets V's leave setting to LEAVE. */
931 var_set_leave (struct variable *v, bool leave)
933 var_set_leave_quiet (v, leave);
934 dict_var_changed (v, VAR_TRAIT_LEAVE);
938 /* Returns true if V must be left from case to case,
939 false if it can be set either way. */
941 var_must_leave (const struct variable *v)
943 return var_get_dict_class (v) == DC_SCRATCH;
946 /* Returns the number of short names stored in VAR.
948 Short names are used only for system and portable file input
949 and output. They are upper-case only, not necessarily unique,
950 and limited to SHORT_NAME_LEN characters (plus a null
951 terminator). Ordinarily a variable has at most one short
952 name, but very long string variables (longer than 255 bytes)
953 may have more. A variable might not have any short name at
954 all if it hasn't been saved to or read from a system or
957 var_get_short_name_cnt (const struct variable *var)
959 return var->short_name_cnt;
962 /* Returns VAR's short name with the given IDX, if it has one
963 with that index, or a null pointer otherwise. Short names may
964 be sparse: even if IDX is less than the number of short names
965 in VAR, this function may return a null pointer. */
967 var_get_short_name (const struct variable *var, size_t idx)
969 return idx < var->short_name_cnt ? var->short_names[idx] : NULL;
972 /* Sets VAR's short name with the given IDX to the UTF-8 string SHORT_NAME.
973 The caller must already have checked that, in the dictionary encoding,
974 SHORT_NAME is no more than SHORT_NAME_LEN bytes long. The new short name
975 will be converted to uppercase.
977 Specifying a null pointer for SHORT_NAME clears the specified short name. */
979 var_set_short_name (struct variable *var, size_t idx, const char *short_name)
981 assert (short_name == NULL || id_is_plausible (short_name, false));
983 /* Clear old short name numbered IDX, if any. */
984 if (idx < var->short_name_cnt)
986 free (var->short_names[idx]);
987 var->short_names[idx] = NULL;
990 /* Install new short name for IDX. */
991 if (short_name != NULL)
993 if (idx >= var->short_name_cnt)
995 size_t old_cnt = var->short_name_cnt;
997 var->short_name_cnt = MAX (idx * 2, 1);
998 var->short_names = xnrealloc (var->short_names, var->short_name_cnt,
999 sizeof *var->short_names);
1000 for (i = old_cnt; i < var->short_name_cnt; i++)
1001 var->short_names[i] = NULL;
1003 var->short_names[idx] = utf8_to_upper (short_name);
1006 dict_var_changed (var, VAR_TRAIT_NAME);
1009 /* Clears V's short names. */
1011 var_clear_short_names (struct variable *v)
1015 for (i = 0; i < v->short_name_cnt; i++)
1016 free (v->short_names[i]);
1017 free (v->short_names);
1018 v->short_names = NULL;
1019 v->short_name_cnt = 0;
1022 /* Relationship with dictionary. */
1024 /* Returns V's index within its dictionary, the value
1025 for which "dict_get_var (dict, index)" will return V.
1026 V must be in a dictionary. */
1028 var_get_dict_index (const struct variable *v)
1030 assert (var_has_vardict (v));
1031 return vardict_get_dict_index (v->vardict);
1034 /* Returns V's index within the case represented by its
1035 dictionary, that is, the value for which "case_data_idx (case,
1036 index)" will return the data for V in that case.
1037 V must be in a dictionary. */
1039 var_get_case_index (const struct variable *v)
1041 assert (var_has_vardict (v));
1042 return vardict_get_case_index (v->vardict);
1045 /* Returns variable V's attribute set. The caller may examine or
1046 modify the attribute set, but must not destroy it. Destroying
1047 V, or calling var_set_attributes() on V, will also destroy its
1050 var_get_attributes (const struct variable *v)
1052 return CONST_CAST (struct attrset *, &v->attributes);
1055 /* Replaces variable V's attributes set by a copy of ATTRS. */
1057 var_set_attributes_quiet (struct variable *v, const struct attrset *attrs)
1059 attrset_destroy (&v->attributes);
1060 attrset_clone (&v->attributes, attrs);
1063 /* Replaces variable V's attributes set by a copy of ATTRS. */
1065 var_set_attributes (struct variable *v, const struct attrset *attrs)
1067 var_set_attributes_quiet (v, attrs);
1068 dict_var_changed (v, VAR_TRAIT_ATTRIBUTES);
1072 /* Returns true if V has any custom attributes, false if it has none. */
1074 var_has_attributes (const struct variable *v)
1076 return attrset_count (&v->attributes) > 0;
1080 /* Creates and returns a clone of OLD_VAR. Most properties of
1081 the new variable are copied from OLD_VAR, except:
1083 - The variable's short name is not copied, because there is
1084 no reason to give a new variable with potentially a new
1085 name the same short name.
1087 - The new variable is not added to OLD_VAR's dictionary by
1088 default. Use dict_clone_var, instead, to do that.
1091 var_clone (const struct variable *old_var)
1093 struct variable *new_var = var_create (var_get_name (old_var),
1094 var_get_width (old_var));
1096 var_set_missing_values_quiet (new_var, var_get_missing_values (old_var));
1097 var_set_print_format_quiet (new_var, var_get_print_format (old_var));
1098 var_set_write_format_quiet (new_var, var_get_write_format (old_var));
1099 var_set_value_labels_quiet (new_var, var_get_value_labels (old_var));
1100 var_set_label_quiet (new_var, var_get_label (old_var), false);
1101 var_set_measure_quiet (new_var, var_get_measure (old_var));
1102 var_set_display_width_quiet (new_var, var_get_display_width (old_var));
1103 var_set_alignment_quiet (new_var, var_get_alignment (old_var));
1104 var_set_leave_quiet (new_var, var_get_leave (old_var));
1105 var_set_attributes_quiet (new_var, var_get_attributes (old_var));
1112 /* Returns the encoding of values of variable VAR. (This is actually a
1113 property of the dictionary.) Returns null if no specific encoding has been
1116 var_get_encoding (const struct variable *var)
1118 return (var_has_vardict (var)
1119 ? dict_get_encoding (vardict_get_dictionary (var->vardict))
1123 /* Returns V's vardict structure. */
1124 struct vardict_info *
1125 var_get_vardict (const struct variable *v)
1127 return CONST_CAST (struct vardict_info *, v->vardict);
1130 /* Sets V's vardict data to VARDICT. */
1132 var_set_vardict (struct variable *v, struct vardict_info *vardict)
1134 v->vardict = vardict;
1137 /* Returns true if V has vardict data. */
1139 var_has_vardict (const struct variable *v)
1141 return v->vardict != NULL;
1144 /* Clears V's vardict data. */
1146 var_clear_vardict (struct variable *v)