1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2006, 2009 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/>. */
22 #include <data/attributes.h>
23 #include <data/category.h>
24 #include <data/data-out.h>
25 #include <data/format.h>
26 #include <data/dictionary.h>
27 #include <data/identifier.h>
28 #include <data/missing-values.h>
29 #include <data/value-labels.h>
30 #include <data/vardict.h>
32 #include <libpspp/misc.h>
33 #include <libpspp/assertion.h>
34 #include <libpspp/compiler.h>
35 #include <libpspp/hash.h>
36 #include <libpspp/message.h>
37 #include <libpspp/str.h>
43 #define _(msgid) gettext (msgid)
48 /* Dictionary information. */
49 char name[VAR_NAME_LEN + 1]; /* Variable name. Mixed case. */
50 int width; /* 0 for numeric, otherwise string width. */
51 struct missing_values miss; /* Missing values. */
52 struct fmt_spec print; /* Default format for PRINT. */
53 struct fmt_spec write; /* Default format for WRITE. */
54 struct val_labs *val_labs; /* Value labels. */
55 char *label; /* Variable label. */
57 /* GUI information. */
58 enum measure measure; /* Nominal, ordinal, or continuous. */
59 int display_width; /* Width of data editor column. */
60 enum alignment alignment; /* Alignment of data in GUI. */
62 /* Case information. */
63 bool leave; /* Leave value from case to case? */
65 /* Data for use by containing dictionary. */
66 struct vardict_info vardict;
68 /* Used only for system and portable file input and output.
71 size_t short_name_cnt;
73 /* Each command may use these fields as needed. */
75 void (*aux_dtor) (struct variable *);
77 /* Values of a categorical variable. Procedures need
78 vectors with binary entries, so any variable of type ALPHA will
79 have its values stored here. */
80 struct cat_vals *obs_vals;
82 /* Custom attributes. */
83 struct attrset attributes;
86 /* Creates and returns a new variable with the given NAME and
87 WIDTH and other fields initialized to default values. The
88 variable is not added to a dictionary; for that, use
89 dict_create_var instead. */
91 var_create (const char *name, int width)
96 assert (width >= 0 && width <= MAX_STRING);
98 v = xmalloc (sizeof *v);
99 v->vardict.dict_index = v->vardict.case_index = -1;
100 var_set_name (v, name);
102 mv_init (&v->miss, width);
103 v->leave = var_must_leave (v);
104 type = val_type_from_width (width);
105 v->alignment = var_default_alignment (type);
106 v->measure = var_default_measure (type);
107 v->display_width = var_default_display_width (width);
108 v->print = v->write = var_default_formats (width);
111 v->short_names = NULL;
112 v->short_name_cnt = 0;
116 attrset_init (&v->attributes);
121 /* Creates and returns a clone of OLD_VAR. Most properties of
122 the new variable are copied from OLD_VAR, except:
124 - The variable's short name is not copied, because there is
125 no reason to give a new variable with potentially a new
126 name the same short name.
128 - The new variable is not added to OLD_VAR's dictionary by
129 default. Use dict_clone_var, instead, to do that.
131 - Auxiliary data and obs_vals are not copied. */
133 var_clone (const struct variable *old_var)
135 struct variable *new_var = var_create (var_get_name (old_var),
136 var_get_width (old_var));
138 var_set_missing_values (new_var, var_get_missing_values (old_var));
139 var_set_print_format (new_var, var_get_print_format (old_var));
140 var_set_write_format (new_var, var_get_write_format (old_var));
141 var_set_value_labels (new_var, var_get_value_labels (old_var));
142 var_set_label (new_var, var_get_label (old_var));
143 var_set_measure (new_var, var_get_measure (old_var));
144 var_set_display_width (new_var, var_get_display_width (old_var));
145 var_set_alignment (new_var, var_get_alignment (old_var));
146 var_set_leave (new_var, var_get_leave (old_var));
147 var_set_attributes (new_var, var_get_attributes (old_var));
152 /* Create a variable of the specified WIDTH to be used for
153 internal calculations only. The variable is assigned a unique
154 dictionary index and a case index of CASE_IDX. */
156 var_create_internal (int case_idx, int width)
158 struct variable *v = var_create ("$internal", width);
159 struct vardict_info vdi;
160 static int counter = INT_MAX / 2;
163 vdi.case_index = case_idx;
164 vdi.dict_index = counter++;
165 if (counter == INT_MAX)
166 counter = INT_MAX / 2;
168 var_set_vardict (v, &vdi);
173 /* Destroys variable V.
174 V must not belong to a dictionary. If it does, use
175 dict_delete_var instead. */
177 var_destroy (struct variable *v)
181 if (var_has_vardict (v))
183 const struct vardict_info *vdi = var_get_vardict (v);
184 assert (vdi->dict == NULL);
186 mv_destroy (&v->miss);
187 cat_stored_values_destroy (v->obs_vals);
188 var_clear_short_names (v);
190 val_labs_destroy (v->val_labs);
196 /* Variable names. */
198 /* Return variable V's name. */
200 var_get_name (const struct variable *v)
205 /* Sets V's name to NAME.
206 Do not use this function for a variable in a dictionary. Use
207 dict_rename_var instead. */
209 var_set_name (struct variable *v, const char *name)
211 assert (v->vardict.dict_index == -1);
212 assert (var_is_plausible_name (name, false));
214 str_copy_trunc (v->name, sizeof v->name, name);
215 dict_var_changed (v);
218 /* Returns true if NAME is an acceptable name for a variable,
219 false otherwise. If ISSUE_ERROR is true, issues an
220 explanatory error message on failure. */
222 var_is_valid_name (const char *name, bool issue_error)
227 assert (name != NULL);
229 /* Note that strlen returns number of BYTES, not the number of
231 length = strlen (name);
233 plausible = var_is_plausible_name(name, issue_error);
239 if (!lex_is_id1 (name[0]))
242 msg (SE, _("Character `%c' (in %s) may not appear "
243 "as the first character in a variable name."),
249 for (i = 0; i < length; i++)
251 if (!lex_is_idn (name[i]))
254 msg (SE, _("Character `%c' (in %s) may not appear in "
264 /* Returns true if NAME is an plausible name for a variable,
265 false otherwise. If ISSUE_ERROR is true, issues an
266 explanatory error message on failure.
267 This function makes no use of LC_CTYPE.
270 var_is_plausible_name (const char *name, bool issue_error)
274 assert (name != NULL);
276 /* Note that strlen returns number of BYTES, not the number of
278 length = strlen (name);
282 msg (SE, _("Variable name cannot be empty string."));
285 else if (length > VAR_NAME_LEN)
288 msg (SE, _("Variable name %s exceeds %d-character limit."),
289 name, (int) VAR_NAME_LEN);
293 if (lex_id_to_token (ss_cstr (name)) != T_ID)
296 msg (SE, _("`%s' may not be used as a variable name because it "
297 "is a reserved word."), name);
304 /* Returns VAR's dictionary class. */
306 var_get_dict_class (const struct variable *var)
308 return dict_class_from_id (var->name);
311 /* A hsh_compare_func that orders variables A and B by their
314 compare_vars_by_name (const void *a_, const void *b_, const void *aux UNUSED)
316 const struct variable *a = a_;
317 const struct variable *b = b_;
319 return strcasecmp (a->name, b->name);
322 /* A hsh_hash_func that hashes variable V based on its name. */
324 hash_var_by_name (const void *v_, const void *aux UNUSED)
326 const struct variable *v = v_;
328 return hash_case_string (v->name, 0);
331 /* A hsh_compare_func that orders pointers to variables A and B
334 compare_var_ptrs_by_name (const void *a_, const void *b_,
335 const void *aux UNUSED)
337 struct variable *const *a = a_;
338 struct variable *const *b = b_;
340 return strcasecmp (var_get_name (*a), var_get_name (*b));
343 /* A hsh_compare_func that orders pointers to variables A and B
344 by their dictionary indexes. */
346 compare_var_ptrs_by_dict_index (const void *a_, const void *b_,
347 const void *aux UNUSED)
349 struct variable *const *a = a_;
350 struct variable *const *b = b_;
351 size_t a_index = var_get_dict_index (*a);
352 size_t b_index = var_get_dict_index (*b);
354 return a_index < b_index ? -1 : a_index > b_index;
357 /* A hsh_hash_func that hashes pointer to variable V based on its
360 hash_var_ptr_by_name (const void *v_, const void *aux UNUSED)
362 struct variable *const *v = v_;
364 return hash_case_string (var_get_name (*v), 0);
367 /* Returns the type of variable V. */
369 var_get_type (const struct variable *v)
371 return val_type_from_width (v->width);
374 /* Returns the width of variable V. */
376 var_get_width (const struct variable *v)
381 /* Changes the width of V to NEW_WIDTH.
382 This function should be used cautiously. */
384 var_set_width (struct variable *v, int new_width)
386 const int old_width = v->width;
388 if (old_width == new_width)
391 if (mv_is_resizable (&v->miss, new_width))
392 mv_resize (&v->miss, new_width);
395 mv_destroy (&v->miss);
396 mv_init (&v->miss, new_width);
399 if (v->val_labs != NULL)
401 if (val_labs_can_set_width (v->val_labs, new_width))
402 val_labs_set_width (v->val_labs, new_width);
405 val_labs_destroy (v->val_labs);
410 fmt_resize (&v->print, new_width);
411 fmt_resize (&v->write, new_width);
413 v->width = new_width;
414 dict_var_resized (v, old_width);
415 dict_var_changed (v);
418 /* Returns true if variable V is numeric, false otherwise. */
420 var_is_numeric (const struct variable *v)
422 return var_get_type (v) == VAL_NUMERIC;
425 /* Returns true if variable V is a string variable, false
428 var_is_alpha (const struct variable *v)
430 return var_get_type (v) == VAL_STRING;
433 /* Returns variable V's missing values. */
434 const struct missing_values *
435 var_get_missing_values (const struct variable *v)
440 /* Sets variable V's missing values to MISS, which must be of V's
441 width or at least resizable to V's width.
442 If MISS is null, then V's missing values, if any, are
445 var_set_missing_values (struct variable *v, const struct missing_values *miss)
449 assert (mv_is_resizable (miss, v->width));
450 mv_destroy (&v->miss);
451 mv_copy (&v->miss, miss);
452 mv_resize (&v->miss, v->width);
457 dict_var_changed (v);
460 /* Sets variable V to have no user-missing values. */
462 var_clear_missing_values (struct variable *v)
464 var_set_missing_values (v, NULL);
467 /* Returns true if V has any user-missing values,
470 var_has_missing_values (const struct variable *v)
472 return !mv_is_empty (&v->miss);
475 /* Returns true if VALUE is in the given CLASS of missing values
476 in V, false otherwise. */
478 var_is_value_missing (const struct variable *v, const union value *value,
481 return mv_is_value_missing (&v->miss, value, class);
484 /* Returns true if D is in the given CLASS of missing values in
486 V must be a numeric variable. */
488 var_is_num_missing (const struct variable *v, double d, enum mv_class class)
490 return mv_is_num_missing (&v->miss, d, class);
493 /* Returns true if S[] is a missing value for V, false otherwise.
494 S[] must contain exactly as many characters as V's width.
495 V must be a string variable. */
497 var_is_str_missing (const struct variable *v, const uint8_t s[],
500 return mv_is_str_missing (&v->miss, s, class);
503 /* Returns variable V's value labels,
504 possibly a null pointer if it has none. */
505 const struct val_labs *
506 var_get_value_labels (const struct variable *v)
511 /* Returns true if variable V has at least one value label. */
513 var_has_value_labels (const struct variable *v)
515 return val_labs_count (v->val_labs) > 0;
518 /* Sets variable V's value labels to a copy of VLS,
519 which must have a width equal to V's width or one that can be
520 changed to V's width.
521 If VLS is null, then V's value labels, if any, are removed. */
523 var_set_value_labels (struct variable *v, const struct val_labs *vls)
525 val_labs_destroy (v->val_labs);
530 assert (val_labs_can_set_width (vls, v->width));
531 v->val_labs = val_labs_clone (vls);
532 val_labs_set_width (v->val_labs, v->width);
533 dict_var_changed (v);
537 /* Makes sure that V has a set of value labels,
538 by assigning one to it if necessary. */
540 alloc_value_labels (struct variable *v)
542 if (v->val_labs == NULL)
543 v->val_labs = val_labs_create (v->width);
546 /* Attempts to add a value label with the given VALUE and LABEL
547 to V. Returns true if successful, false if VALUE has an
548 existing label or if V is a long string variable. */
550 var_add_value_label (struct variable *v,
551 const union value *value, const char *label)
553 alloc_value_labels (v);
554 return val_labs_add (v->val_labs, value, label);
557 /* Adds or replaces a value label with the given VALUE and LABEL
559 Has no effect if V is a long string variable. */
561 var_replace_value_label (struct variable *v,
562 const union value *value, const char *label)
564 alloc_value_labels (v);
565 val_labs_replace (v->val_labs, value, label);
568 /* Removes V's value labels, if any. */
570 var_clear_value_labels (struct variable *v)
572 var_set_value_labels (v, NULL);
575 /* Returns the label associated with VALUE for variable V,
576 or a null pointer if none. */
578 var_lookup_value_label (const struct variable *v, const union value *value)
580 return val_labs_find (v->val_labs, value);
583 /* Append STR with a string representing VALUE for variable V.
584 That is, if VALUE has a label, append that label,
585 otherwise format VALUE and append the formatted string.
586 STR must be a pointer to an initialised struct string.
589 var_append_value_name (const struct variable *v, const union value *value,
592 const char *name = var_lookup_value_label (v, value);
593 const struct dictionary *dict = var_get_vardict (v)->dict;
596 char *s = data_out (value, dict_get_encoding (dict), &v->print);
597 ds_put_cstr (str, s);
601 ds_put_cstr (str, name);
604 /* Print and write formats. */
606 /* Returns V's print format specification. */
607 const struct fmt_spec *
608 var_get_print_format (const struct variable *v)
613 /* Sets V's print format specification to PRINT, which must be a
614 valid format specification for a variable of V's width
615 (ordinarily an output format, but input formats are not
618 var_set_print_format (struct variable *v, const struct fmt_spec *print)
620 assert (fmt_check_width_compat (print, v->width));
622 dict_var_changed (v);
625 /* Returns V's write format specification. */
626 const struct fmt_spec *
627 var_get_write_format (const struct variable *v)
632 /* Sets V's write format specification to WRITE, which must be a
633 valid format specification for a variable of V's width
634 (ordinarily an output format, but input formats are not
637 var_set_write_format (struct variable *v, const struct fmt_spec *write)
639 assert (fmt_check_width_compat (write, v->width));
641 dict_var_changed (v);
644 /* Sets V's print and write format specifications to FORMAT,
645 which must be a valid format specification for a variable of
646 V's width (ordinarily an output format, but input formats are
649 var_set_both_formats (struct variable *v, const struct fmt_spec *format)
651 var_set_print_format (v, format);
652 var_set_write_format (v, format);
655 /* Returns the default print and write format for a variable of
656 the given TYPE, as set by var_create. The return value can be
657 used to reset a variable's print and write formats to the
660 var_default_formats (int width)
663 ? fmt_for_output (FMT_F, 8, 2)
664 : fmt_for_output (FMT_A, width, 0));
667 /* Return a string representing this variable, in the form most
668 appropriate from a human factors perspective, that is, its
669 variable label if it has one, otherwise its name. */
671 var_to_string (const struct variable *v)
673 return v->label != NULL ? v->label : v->name;
676 /* Returns V's variable label, or a null pointer if it has none. */
678 var_get_label (const struct variable *v)
683 /* Sets V's variable label to LABEL, stripping off leading and
684 trailing white space and truncating to 255 characters.
685 If LABEL is a null pointer or if LABEL is an empty string
686 (after stripping white space), then V's variable label (if
689 var_set_label (struct variable *v, const char *label)
696 struct substring s = ss_cstr (label);
697 ss_trim (&s, ss_cstr (CC_SPACES));
698 ss_truncate (&s, 255);
699 if (!ss_is_empty (s))
700 v->label = ss_xstrdup (s);
702 dict_var_changed (v);
705 /* Removes any variable label from V. */
707 var_clear_label (struct variable *v)
709 var_set_label (v, NULL);
712 /* Returns true if V has a variable V,
715 var_has_label (const struct variable *v)
717 return v->label != NULL;
720 /* Returns true if M is a valid variable measurement level,
723 measure_is_valid (enum measure m)
725 return m == MEASURE_NOMINAL || m == MEASURE_ORDINAL || m == MEASURE_SCALE;
728 /* Returns V's measurement level. */
730 var_get_measure (const struct variable *v)
735 /* Sets V's measurement level to MEASURE. */
737 var_set_measure (struct variable *v, enum measure measure)
739 assert (measure_is_valid (measure));
740 v->measure = measure;
741 dict_var_changed (v);
744 /* Returns the default measurement level for a variable of the
745 given TYPE, as set by var_create. The return value can be
746 used to reset a variable's measurement level to the
749 var_default_measure (enum val_type type)
751 return type == VAL_NUMERIC ? MEASURE_SCALE : MEASURE_NOMINAL;
754 /* Returns V's display width, which applies only to GUIs. */
756 var_get_display_width (const struct variable *v)
758 return v->display_width;
761 /* Sets V's display width to DISPLAY_WIDTH. */
763 var_set_display_width (struct variable *v, int new_width)
765 int old_width = v->display_width;
767 v->display_width = new_width;
769 if ( old_width != new_width)
770 dict_var_display_width_changed (v);
772 dict_var_changed (v);
775 /* Returns the default display width for a variable of the given
776 WIDTH, as set by var_create. The return value can be used to
777 reset a variable's display width to the default. */
779 var_default_display_width (int width)
781 return width == 0 ? 8 : MIN (width, 32);
784 /* Returns true if A is a valid alignment,
787 alignment_is_valid (enum alignment a)
789 return a == ALIGN_LEFT || a == ALIGN_RIGHT || a == ALIGN_CENTRE;
792 /* Returns V's display alignment, which applies only to GUIs. */
794 var_get_alignment (const struct variable *v)
799 /* Sets V's display alignment to ALIGNMENT. */
801 var_set_alignment (struct variable *v, enum alignment alignment)
803 assert (alignment_is_valid (alignment));
804 v->alignment = alignment;
805 dict_var_changed (v);
808 /* Returns the default display alignment for a variable of the
809 given TYPE, as set by var_create. The return value can be
810 used to reset a variable's display alignment to the default. */
812 var_default_alignment (enum val_type type)
814 return type == VAL_NUMERIC ? ALIGN_RIGHT : ALIGN_LEFT;
817 /* Whether variables' values should be preserved from case to
820 /* Returns true if variable V's value should be left from case to
821 case, instead of being reset to system-missing or blanks. */
823 var_get_leave (const struct variable *v)
828 /* Sets V's leave setting to LEAVE. */
830 var_set_leave (struct variable *v, bool leave)
832 assert (leave || !var_must_leave (v));
834 dict_var_changed (v);
837 /* Returns true if V must be left from case to case,
838 false if it can be set either way. */
840 var_must_leave (const struct variable *v)
842 return var_get_dict_class (v) == DC_SCRATCH;
845 /* Returns the number of short names stored in VAR.
847 Short names are used only for system and portable file input
848 and output. They are upper-case only, not necessarily unique,
849 and limited to SHORT_NAME_LEN characters (plus a null
850 terminator). Ordinarily a variable has at most one short
851 name, but very long string variables (longer than 255 bytes)
852 may have more. A variable might not have any short name at
853 all if it hasn't been saved to or read from a system or
856 var_get_short_name_cnt (const struct variable *var)
858 return var->short_name_cnt;
861 /* Returns VAR's short name with the given IDX, if it has one
862 with that index, or a null pointer otherwise. Short names may
863 be sparse: even if IDX is less than the number of short names
864 in VAR, this function may return a null pointer. */
866 var_get_short_name (const struct variable *var, size_t idx)
868 return idx < var->short_name_cnt ? var->short_names[idx] : NULL;
871 /* Sets VAR's short name with the given IDX to SHORT_NAME,
872 truncating it to SHORT_NAME_LEN characters and converting it
873 to uppercase in the process. Specifying a null pointer for
874 SHORT_NAME clears the specified short name. */
876 var_set_short_name (struct variable *var, size_t idx, const char *short_name)
878 assert (var != NULL);
879 assert (short_name == NULL || var_is_plausible_name (short_name, false));
881 /* Clear old short name numbered IDX, if any. */
882 if (idx < var->short_name_cnt)
884 free (var->short_names[idx]);
885 var->short_names[idx] = NULL;
888 /* Install new short name for IDX. */
889 if (short_name != NULL)
891 if (idx >= var->short_name_cnt)
893 size_t old_cnt = var->short_name_cnt;
895 var->short_name_cnt = MAX (idx * 2, 1);
896 var->short_names = xnrealloc (var->short_names, var->short_name_cnt,
897 sizeof *var->short_names);
898 for (i = old_cnt; i < var->short_name_cnt; i++)
899 var->short_names[i] = NULL;
901 var->short_names[idx] = xstrndup (short_name, MAX_SHORT_STRING);
902 str_uppercase (var->short_names[idx]);
905 dict_var_changed (var);
908 /* Clears V's short names. */
910 var_clear_short_names (struct variable *v)
914 for (i = 0; i < v->short_name_cnt; i++)
915 free (v->short_names[i]);
916 free (v->short_names);
917 v->short_names = NULL;
918 v->short_name_cnt = 0;
921 /* Relationship with dictionary. */
923 /* Returns V's index within its dictionary, the value
924 for which "dict_get_var (dict, index)" will return V.
925 V must be in a dictionary. */
927 var_get_dict_index (const struct variable *v)
929 assert (v->vardict.dict_index != -1);
930 return v->vardict.dict_index;
933 /* Returns V's index within the case represented by its
934 dictionary, that is, the value for which "case_data_idx (case,
935 index)" will return the data for V in that case.
936 V must be in a dictionary. */
938 var_get_case_index (const struct variable *v)
940 assert (v->vardict.case_index != -1);
941 return v->vardict.case_index;
944 /* Returns V's auxiliary data, or a null pointer if none has been
947 var_get_aux (const struct variable *v)
952 /* Assign auxiliary data AUX to variable V, which must not
953 already have auxiliary data. Before V's auxiliary data is
954 cleared, AUX_DTOR(V) will be called. (var_dtor_free, below,
955 may be appropriate for use as AUX_DTOR.) */
957 var_attach_aux (const struct variable *v_,
958 void *aux, void (*aux_dtor) (struct variable *))
960 struct variable *v = CONST_CAST (struct variable *, v_);
961 assert (v->aux == NULL);
962 assert (aux != NULL);
964 v->aux_dtor = aux_dtor;
968 /* Remove auxiliary data, if any, from V, and return it, without
969 calling any associated destructor. */
971 var_detach_aux (struct variable *v)
974 assert (aux != NULL);
979 /* Clears auxiliary data, if any, from V, and calls any
980 associated destructor. */
982 var_clear_aux (struct variable *v)
987 if (v->aux_dtor != NULL)
993 /* This function is appropriate for use an auxiliary data
994 destructor (passed as AUX_DTOR to var_attach_aux()) for the
995 case where the auxiliary data should be passed to free(). */
997 var_dtor_free (struct variable *v)
1002 /* Observed categorical values. */
1004 /* Returns V's observed categorical values,
1005 which V must have. */
1007 var_get_obs_vals (const struct variable *v)
1009 assert (v->obs_vals != NULL);
1013 /* Sets V's observed categorical values to CAT_VALS.
1014 V becomes the owner of CAT_VALS. */
1016 var_set_obs_vals (const struct variable *v_, struct cat_vals *cat_vals)
1018 struct variable *v = CONST_CAST (struct variable *, v_ );
1019 cat_stored_values_destroy (v->obs_vals);
1020 v->obs_vals = cat_vals;
1023 /* Returns true if V has observed categorical values,
1026 var_has_obs_vals (const struct variable *v)
1028 return v->obs_vals != NULL;
1031 /* Returns variable V's attribute set. The caller may examine or
1032 modify the attribute set, but must not destroy it. Destroying
1033 V, or calling var_set_attributes() on V, will also destroy its
1036 var_get_attributes (const struct variable *v)
1038 return CONST_CAST (struct attrset *, &v->attributes);
1041 /* Replaces variable V's attributes set by a copy of ATTRS. */
1043 var_set_attributes (struct variable *v, const struct attrset *attrs)
1045 attrset_destroy (&v->attributes);
1046 attrset_clone (&v->attributes, attrs);
1049 /* Returns true if V has any custom attributes, false if it has none. */
1051 var_has_attributes (const struct variable *v)
1053 return attrset_count (&v->attributes) > 0;
1056 /* Returns V's vardict structure. */
1057 const struct vardict_info *
1058 var_get_vardict (const struct variable *v)
1060 assert (var_has_vardict (v));
1064 /* Sets V's vardict data to VARDICT. */
1066 var_set_vardict (struct variable *v, const struct vardict_info *vardict)
1068 assert (vardict->dict_index >= 0);
1069 assert (vardict->case_index >= 0);
1070 v->vardict = *vardict;
1073 /* Returns true if V has vardict data. */
1075 var_has_vardict (const struct variable *v)
1077 return v->vardict.dict_index != -1;
1080 /* Clears V's vardict data. */
1082 var_clear_vardict (struct variable *v)
1084 v->vardict.dict_index = v->vardict.case_index = -1;