X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fvariable.c;h=d3f9addc4c1c4d1a4dbc23d7491ae756a748d3c8;hb=79100bdd30230890345c1c5a09ae57a19c1e408b;hp=41f9221d436c66201393d7bf4efe2b705bce840d;hpb=fe8dc2171009e90d2335f159d05f7e6660e24780;p=pspp diff --git a/src/data/variable.c b/src/data/variable.c index 41f9221d43..d3f9addc4c 100644 --- a/src/data/variable.c +++ b/src/data/variable.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -26,6 +26,7 @@ #include "data/format.h" #include "data/identifier.h" #include "data/missing-values.h" +#include "data/settings.h" #include "data/value-labels.h" #include "data/vardict.h" #include "libpspp/assertion.h" @@ -53,9 +54,11 @@ struct variable struct fmt_spec write; /* Default format for WRITE. */ struct val_labs *val_labs; /* Value labels. */ char *label; /* Variable label. */ + struct string name_and_label; /* The name and label in the same string */ /* GUI information. */ enum measure measure; /* Nominal, ordinal, or continuous. */ + enum var_role role; /* Intended use. */ int display_width; /* Width of data editor column. */ enum alignment alignment; /* Alignment of data in GUI. */ @@ -70,14 +73,16 @@ struct variable char **short_names; size_t short_name_cnt; - /* Each command may use these fields as needed. */ - void *aux; - void (*aux_dtor) (struct variable *); - /* Custom attributes. */ struct attrset attributes; }; + +static void var_set_print_format_quiet (struct variable *v, const struct fmt_spec *print); +static void var_set_write_format_quiet (struct variable *v, const struct fmt_spec *write); +static bool var_set_label_quiet (struct variable *v, const char *label, bool issue_warning); +static void var_set_name_quiet (struct variable *v, const char *name); + /* Creates and returns a new variable with the given NAME and WIDTH and other fields initialized to default values. The variable is not added to a dictionary; for that, use @@ -90,59 +95,23 @@ var_create (const char *name, int width) assert (width >= 0 && width <= MAX_STRING); - v = xmalloc (sizeof *v); - v->vardict = NULL; - v->name = NULL; - var_set_name (v, name); + v = xzalloc (sizeof *v); + var_set_name_quiet (v, name); v->width = width; mv_init (&v->miss, width); v->leave = var_must_leave (v); type = val_type_from_width (width); v->alignment = var_default_alignment (type); v->measure = var_default_measure (type); + v->role = ROLE_NONE; v->display_width = var_default_display_width (width); v->print = v->write = var_default_formats (width); - v->val_labs = NULL; - v->label = NULL; - v->short_names = NULL; - v->short_name_cnt = 0; - v->aux = NULL; - v->aux_dtor = NULL; attrset_init (&v->attributes); + ds_init_empty (&v->name_and_label); return v; } -/* Creates and returns a clone of OLD_VAR. Most properties of - the new variable are copied from OLD_VAR, except: - - - The variable's short name is not copied, because there is - no reason to give a new variable with potentially a new - name the same short name. - - - The new variable is not added to OLD_VAR's dictionary by - default. Use dict_clone_var, instead, to do that. -*/ -struct variable * -var_clone (const struct variable *old_var) -{ - struct variable *new_var = var_create (var_get_name (old_var), - var_get_width (old_var)); - - var_set_missing_values (new_var, var_get_missing_values (old_var)); - var_set_print_format (new_var, var_get_print_format (old_var)); - var_set_write_format (new_var, var_get_write_format (old_var)); - var_set_value_labels (new_var, var_get_value_labels (old_var)); - var_set_label (new_var, var_get_label (old_var), false); - var_set_measure (new_var, var_get_measure (old_var)); - var_set_display_width (new_var, var_get_display_width (old_var)); - var_set_alignment (new_var, var_get_alignment (old_var)); - var_set_leave (new_var, var_get_leave (old_var)); - var_set_attributes (new_var, var_get_attributes (old_var)); - - return new_var; -} - /* Destroys variable V. V must not belong to a dictionary. If it does, use dict_delete_var instead. */ @@ -154,10 +123,11 @@ var_destroy (struct variable *v) assert (!var_has_vardict (v)); mv_destroy (&v->miss); var_clear_short_names (v); - var_clear_aux (v); val_labs_destroy (v->val_labs); - var_clear_label (v); + var_set_label_quiet (v, NULL, false); + attrset_destroy (var_get_attributes (v)); free (v->name); + ds_destroy (&v->name_and_label); free (v); } } @@ -171,18 +141,32 @@ var_get_name (const struct variable *v) return v->name; } + + /* Sets V's name to NAME, a UTF-8 encoded string. Do not use this function for a variable in a dictionary. Use dict_rename_var instead. */ -void -var_set_name (struct variable *v, const char *name) +static void +var_set_name_quiet (struct variable *v, const char *name) { assert (!var_has_vardict (v)); assert (id_is_plausible (name, false)); free (v->name); v->name = xstrdup (name); - dict_var_changed (v); + ds_destroy (&v->name_and_label); + ds_init_empty (&v->name_and_label); +} + +/* Sets V's name to NAME, a UTF-8 encoded string. + Do not use this function for a variable in a dictionary. Use + dict_rename_var instead. */ +void +var_set_name (struct variable *v, const char *name) +{ + struct variable *ov = var_clone (v); + var_set_name_quiet (v, name); + dict_var_changed (v, VAR_TRAIT_NAME, ov); } /* Returns VAR's dictionary class. */ @@ -200,7 +184,7 @@ compare_vars_by_name (const void *a_, const void *b_, const void *aux UNUSED) const struct variable *a = a_; const struct variable *b = b_; - return strcasecmp (a->name, b->name); + return utf8_strcasecmp (a->name, b->name); } /* A hsh_hash_func that hashes variable V based on its name. */ @@ -209,7 +193,7 @@ hash_var_by_name (const void *v_, const void *aux UNUSED) { const struct variable *v = v_; - return hash_case_string (v->name, 0); + return utf8_hash_case_string (v->name, 0); } /* A hsh_compare_func that orders pointers to variables A and B @@ -221,7 +205,7 @@ compare_var_ptrs_by_name (const void *a_, const void *b_, struct variable *const *a = a_; struct variable *const *b = b_; - return strcasecmp (var_get_name (*a), var_get_name (*b)); + return utf8_strcasecmp (var_get_name (*a), var_get_name (*b)); } /* A hsh_compare_func that orders pointers to variables A and B @@ -245,7 +229,7 @@ hash_var_ptr_by_name (const void *v_, const void *aux UNUSED) { struct variable *const *v = v_; - return hash_case_string (var_get_name (*v), 0); + return utf8_hash_case_string (var_get_name (*v), 0); } /* Returns the type of variable V. */ @@ -262,22 +246,25 @@ var_get_width (const struct variable *v) return v->width; } -/* Changes the width of V to NEW_WIDTH. - This function should be used cautiously. */ void -var_set_width (struct variable *v, int new_width) +var_set_width_and_formats (struct variable *v, int new_width, + const struct fmt_spec *print, const struct fmt_spec *write) { - const int old_width = v->width; + struct variable *ov; + unsigned int traits = 0; - if (old_width == new_width) - return; + ov = var_clone (v); - if (mv_is_resizable (&v->miss, new_width)) - mv_resize (&v->miss, new_width); - else + if (var_has_missing_values (v)) { - mv_destroy (&v->miss); - mv_init (&v->miss, new_width); + if (mv_is_resizable (&v->miss, new_width)) + mv_resize (&v->miss, new_width); + else + { + mv_destroy (&v->miss); + mv_init (&v->miss, new_width); + } + traits |= VAR_TRAIT_MISSING_VALUES; } if (v->val_labs != NULL) @@ -289,16 +276,49 @@ var_set_width (struct variable *v, int new_width) val_labs_destroy (v->val_labs); v->val_labs = NULL; } + traits |= VAR_TRAIT_VALUE_LABELS; } - fmt_resize (&v->print, new_width); - fmt_resize (&v->write, new_width); + if (fmt_resize (&v->print, new_width)) + traits |= VAR_TRAIT_PRINT_FORMAT; + + if (fmt_resize (&v->write, new_width)) + traits |= VAR_TRAIT_WRITE_FORMAT; v->width = new_width; - dict_var_resized (v, old_width); - dict_var_changed (v); + traits |= VAR_TRAIT_WIDTH; + + if (print) + { + var_set_print_format_quiet (v, print); + traits |= VAR_TRAIT_PRINT_FORMAT; + } + + if (write) + { + var_set_write_format_quiet (v, write); + traits |= VAR_TRAIT_WRITE_FORMAT; + } + + dict_var_changed (v, traits, ov); } +/* Changes the width of V to NEW_WIDTH. + This function should be used cautiously. */ +void +var_set_width (struct variable *v, int new_width) +{ + const int old_width = v->width; + + if (old_width == new_width) + return; + + var_set_width_and_formats (v, new_width, NULL, NULL); +} + + + + /* Returns true if variable V is numeric, false otherwise. */ bool var_is_numeric (const struct variable *v) @@ -325,8 +345,8 @@ var_get_missing_values (const struct variable *v) width or at least resizable to V's width. If MISS is null, then V's missing values, if any, are cleared. */ -void -var_set_missing_values (struct variable *v, const struct missing_values *miss) +static void +var_set_missing_values_quiet (struct variable *v, const struct missing_values *miss) { if (miss != NULL) { @@ -337,8 +357,18 @@ var_set_missing_values (struct variable *v, const struct missing_values *miss) } else mv_clear (&v->miss); +} - dict_var_changed (v); +/* Sets variable V's missing values to MISS, which must be of V's + width or at least resizable to V's width. + If MISS is null, then V's missing values, if any, are + cleared. */ +void +var_set_missing_values (struct variable *v, const struct missing_values *miss) +{ + struct variable *ov = var_clone (v); + var_set_missing_values_quiet (v, miss); + dict_var_changed (v, VAR_TRAIT_MISSING_VALUES, ov); } /* Sets variable V to have no user-missing values. */ @@ -403,8 +433,8 @@ var_has_value_labels (const struct variable *v) which must have a width equal to V's width or one that can be changed to V's width. If VLS is null, then V's value labels, if any, are removed. */ -void -var_set_value_labels (struct variable *v, const struct val_labs *vls) +static void +var_set_value_labels_quiet (struct variable *v, const struct val_labs *vls) { val_labs_destroy (v->val_labs); v->val_labs = NULL; @@ -414,10 +444,23 @@ var_set_value_labels (struct variable *v, const struct val_labs *vls) assert (val_labs_can_set_width (vls, v->width)); v->val_labs = val_labs_clone (vls); val_labs_set_width (v->val_labs, v->width); - dict_var_changed (v); } } + +/* Sets variable V's value labels to a copy of VLS, + which must have a width equal to V's width or one that can be + changed to V's width. + If VLS is null, then V's value labels, if any, are removed. */ +void +var_set_value_labels (struct variable *v, const struct val_labs *vls) +{ + struct variable *ov = var_clone (v); + var_set_value_labels_quiet (v, vls); + dict_var_changed (v, VAR_TRAIT_LABEL, ov); +} + + /* Makes sure that V has a set of value labels, by assigning one to it if necessary. */ static void @@ -467,6 +510,19 @@ var_lookup_value_label (const struct variable *v, const union value *value) return val_labs_find (v->val_labs, value); } +/* + Append to STR the string representation of VALUE for variable V. + STR must be a pointer to an initialised struct string. +*/ +static void +append_value (const struct variable *v, const union value *value, + struct string *str) +{ + char *s = data_out (value, var_get_encoding (v), &v->print); + ds_put_cstr (str, s); + free (s); +} + /* Append STR with a string representing VALUE for variable V. That is, if VALUE has a label, append that label, otherwise format VALUE and append the formatted string. @@ -476,15 +532,33 @@ void var_append_value_name (const struct variable *v, const union value *value, struct string *str) { + enum settings_value_style style = settings_get_value_style (); const char *name = var_lookup_value_label (v, value); - if (name == NULL) + + switch (style) { - char *s = data_out (value, var_get_encoding (v), &v->print); - ds_put_cstr (str, s); - free (s); - } - else - ds_put_cstr (str, name); + case SETTINGS_VAL_STYLE_VALUES: + append_value (v, value, str); + break; + + case SETTINGS_VAL_STYLE_LABELS: + if (name == NULL) + append_value (v, value, str); + else + ds_put_cstr (str, name); + break; + + case SETTINGS_VAL_STYLE_BOTH: + default: + append_value (v, value, str); + if (name != NULL) + { + ds_put_cstr (str, " ("); + ds_put_cstr (str, name); + ds_put_cstr (str, ")"); + } + break; + }; } /* Print and write formats. */ @@ -496,6 +570,20 @@ var_get_print_format (const struct variable *v) return &v->print; } +/* Sets V's print format specification to PRINT, which must be a + valid format specification for a variable of V's width + (ordinarily an output format, but input formats are not + rejected). */ +static void +var_set_print_format_quiet (struct variable *v, const struct fmt_spec *print) +{ + if (!fmt_equal (&v->print, print)) + { + assert (fmt_check_width_compat (print, v->width)); + v->print = *print; + } +} + /* Sets V's print format specification to PRINT, which must be a valid format specification for a variable of V's width (ordinarily an output format, but input formats are not @@ -503,9 +591,9 @@ var_get_print_format (const struct variable *v) void var_set_print_format (struct variable *v, const struct fmt_spec *print) { - assert (fmt_check_width_compat (print, v->width)); - v->print = *print; - dict_var_changed (v); + struct variable *ov = var_clone (v); + var_set_print_format_quiet (v, print); + dict_var_changed (v, VAR_TRAIT_PRINT_FORMAT, ov); } /* Returns V's write format specification. */ @@ -515,6 +603,20 @@ var_get_write_format (const struct variable *v) return &v->write; } +/* Sets V's write format specification to WRITE, which must be a + valid format specification for a variable of V's width + (ordinarily an output format, but input formats are not + rejected). */ +static void +var_set_write_format_quiet (struct variable *v, const struct fmt_spec *write) +{ + if (!fmt_equal (&v->write, write)) + { + assert (fmt_check_width_compat (write, v->width)); + v->write = *write; + } +} + /* Sets V's write format specification to WRITE, which must be a valid format specification for a variable of V's width (ordinarily an output format, but input formats are not @@ -522,11 +624,12 @@ var_get_write_format (const struct variable *v) void var_set_write_format (struct variable *v, const struct fmt_spec *write) { - assert (fmt_check_width_compat (write, v->width)); - v->write = *write; - dict_var_changed (v); + struct variable *ov = var_clone (v); + var_set_write_format_quiet (v, write); + dict_var_changed (v, VAR_TRAIT_WRITE_FORMAT, ov); } + /* Sets V's print and write format specifications to FORMAT, which must be a valid format specification for a variable of V's width (ordinarily an output format, but input formats are @@ -534,8 +637,10 @@ var_set_write_format (struct variable *v, const struct fmt_spec *write) void var_set_both_formats (struct variable *v, const struct fmt_spec *format) { - var_set_print_format (v, format); - var_set_write_format (v, format); + struct variable *ov = var_clone (v); + var_set_print_format_quiet (v, format); + var_set_write_format_quiet (v, format); + dict_var_changed (v, VAR_TRAIT_PRINT_FORMAT | VAR_TRAIT_WRITE_FORMAT, ov); } /* Returns the default print and write format for a variable of @@ -549,14 +654,51 @@ var_default_formats (int width) ? fmt_for_output (FMT_F, 8, 2) : fmt_for_output (FMT_A, width, 0)); } + + + +/* Update the combined name and label string if necessary */ +static void +update_vl_string (const struct variable *v) +{ + /* Cast away const! */ + struct string *str = (struct string *) &v->name_and_label; + + if (ds_is_empty (str)) + { + if (v->label) + ds_put_format (str, _("%s (%s)"), v->label, v->name); + else + ds_put_cstr (str, v->name); + } +} + + /* Return a string representing this variable, in the form most appropriate from a human factors perspective, that is, its variable label if it has one, otherwise its name. */ const char * var_to_string (const struct variable *v) { - return v->label != NULL ? v->label : v->name; + enum settings_var_style style = settings_get_var_style (); + + switch (style) + { + case SETTINGS_VAR_STYLE_NAMES: + return v->name; + break; + case SETTINGS_VAR_STYLE_LABELS: + return v->label != NULL ? v->label : v->name; + break; + case SETTINGS_VAR_STYLE_BOTH: + update_vl_string (v); + return ds_cstr (&v->name_and_label); + break; + default: + NOT_REACHED (); + break; + }; } /* Returns V's variable label, or a null pointer if it has none. */ @@ -575,8 +717,8 @@ var_get_label (const struct variable *v) var_get_encoding()). If LABEL fits within this limit, this function returns true. Otherwise, the variable label is set to a truncated value, this function returns false and, if ISSUE_WARNING is true, issues a warning. */ -bool -var_set_label (struct variable *v, const char *label, bool issue_warning) +static bool +var_set_label_quiet (struct variable *v, const char *label, bool issue_warning) { bool truncated = false; @@ -608,11 +750,35 @@ var_set_label (struct variable *v, const char *label, bool issue_warning) v->label = ss_xstrdup (s); } - dict_var_changed (v); + ds_destroy (&v->name_and_label); + ds_init_empty (&v->name_and_label); + + return truncated; +} + + + +/* Sets V's variable label to UTF-8 encoded string LABEL, stripping off leading + and trailing white space. If LABEL is a null pointer or if LABEL is an + empty string (after stripping white space), then V's variable label (if any) + is removed. + + Variable labels are limited to 255 bytes in V's encoding (as returned by + var_get_encoding()). If LABEL fits within this limit, this function returns + true. Otherwise, the variable label is set to a truncated value, this + function returns false and, if ISSUE_WARNING is true, issues a warning. */ +bool +var_set_label (struct variable *v, const char *label, bool issue_warning) +{ + struct variable *ov = var_clone (v); + bool truncated = var_set_label_quiet (v, label, issue_warning); + + dict_var_changed (v, VAR_TRAIT_LABEL, ov); return truncated; } + /* Removes any variable label from V. */ void var_clear_label (struct variable *v) @@ -656,6 +822,27 @@ measure_to_string (enum measure m) } } +/* Returns a string version of measurement level M, for use in PSPP command + syntax. */ +const char * +measure_to_syntax (enum measure m) +{ + switch (m) + { + case MEASURE_NOMINAL: + return "NOMINAL"; + + case MEASURE_ORDINAL: + return "ORDINAL"; + + case MEASURE_SCALE: + return "SCALE"; + + default: + return "Invalid"; + } +} + /* Returns V's measurement level. */ enum measure var_get_measure (const struct variable *v) @@ -664,14 +851,24 @@ var_get_measure (const struct variable *v) } /* Sets V's measurement level to MEASURE. */ -void -var_set_measure (struct variable *v, enum measure measure) +static void +var_set_measure_quiet (struct variable *v, enum measure measure) { assert (measure_is_valid (measure)); v->measure = measure; - dict_var_changed (v); } + +/* Sets V's measurement level to MEASURE. */ +void +var_set_measure (struct variable *v, enum measure measure) +{ + struct variable *ov = var_clone (v); + var_set_measure_quiet (v, measure); + dict_var_changed (v, VAR_TRAIT_MEASURE, ov); +} + + /* Returns the default measurement level for a variable of the given TYPE, as set by var_create. The return value can be used to reset a variable's measurement level to the @@ -682,6 +879,109 @@ var_default_measure (enum val_type type) return type == VAL_NUMERIC ? MEASURE_SCALE : MEASURE_NOMINAL; } +/* Returns true if M is a valid variable role, + false otherwise. */ +bool +var_role_is_valid (enum var_role role) +{ + switch (role) + { + case ROLE_NONE: + case ROLE_INPUT: + case ROLE_OUTPUT: + case ROLE_BOTH: + case ROLE_PARTITION: + case ROLE_SPLIT: + return true; + + default: + return false; + } +} + +/* Returns a string version of ROLE, for display to a user. */ +const char * +var_role_to_string (enum var_role role) +{ + switch (role) + { + case ROLE_NONE: + return _("None"); + + case ROLE_INPUT: + return _("Input"); + + case ROLE_OUTPUT: + return _("Output"); + + case ROLE_BOTH: + return _("Both"); + + case ROLE_PARTITION: + return _("Partition"); + + case ROLE_SPLIT: + return _("Split"); + + default: + return "Invalid"; + } +} + +/* Returns a string version of ROLE, for use in PSPP comamnd syntax. */ +const char * +var_role_to_syntax (enum var_role role) +{ + switch (role) + { + case ROLE_NONE: + return "NONE"; + + case ROLE_INPUT: + return "INPUT"; + + case ROLE_OUTPUT: + return "TARGET"; + + case ROLE_BOTH: + return "BOTH"; + + case ROLE_PARTITION: + return "PARTITION"; + + case ROLE_SPLIT: + return "SPLIT"; + + default: + return ""; + } +} + +/* Returns V's role. */ +enum var_role +var_get_role (const struct variable *v) +{ + return v->role; +} + +/* Sets V's role to ROLE. */ +static void +var_set_role_quiet (struct variable *v, enum var_role role) +{ + assert (var_role_is_valid (role)); + v->role = role; +} + + +/* Sets V's role to ROLE. */ +void +var_set_role (struct variable *v, enum var_role role) +{ + struct variable *ov = var_clone (v); + var_set_role_quiet (v, role); + dict_var_changed (v, VAR_TRAIT_ROLE, ov); +} + /* Returns V's display width, which applies only to GUIs. */ int var_get_display_width (const struct variable *v) @@ -690,19 +990,24 @@ var_get_display_width (const struct variable *v) } /* Sets V's display width to DISPLAY_WIDTH. */ +static void +var_set_display_width_quiet (struct variable *v, int new_width) +{ + if (v->display_width != new_width) + { + v->display_width = new_width; + } +} + void var_set_display_width (struct variable *v, int new_width) { - int old_width = v->display_width; - - v->display_width = new_width; - - if ( old_width != new_width) - dict_var_display_width_changed (v); - - dict_var_changed (v); + struct variable *ov = var_clone (v); + var_set_display_width_quiet (v, new_width); + dict_var_changed (v, VAR_TRAIT_DISPLAY_WIDTH, ov); } + /* Returns the default display width for a variable of the given WIDTH, as set by var_create. The return value can be used to reset a variable's display width to the default. */ @@ -740,6 +1045,26 @@ alignment_to_string (enum alignment a) } } +/* Returns a string version of alignment A, for use in PSPP command syntax. */ +const char * +alignment_to_syntax (enum alignment a) +{ + switch (a) + { + case ALIGN_LEFT: + return "LEFT"; + + case ALIGN_RIGHT: + return "RIGHT"; + + case ALIGN_CENTRE: + return "CENTER"; + + default: + return "Invalid"; + } +} + /* Returns V's display alignment, which applies only to GUIs. */ enum alignment var_get_alignment (const struct variable *v) @@ -748,14 +1073,23 @@ var_get_alignment (const struct variable *v) } /* Sets V's display alignment to ALIGNMENT. */ -void -var_set_alignment (struct variable *v, enum alignment alignment) +static void +var_set_alignment_quiet (struct variable *v, enum alignment alignment) { assert (alignment_is_valid (alignment)); v->alignment = alignment; - dict_var_changed (v); } +/* Sets V's display alignment to ALIGNMENT. */ +void +var_set_alignment (struct variable *v, enum alignment alignment) +{ + struct variable *ov = var_clone (v); + var_set_alignment_quiet (v, alignment); + dict_var_changed (v, VAR_TRAIT_ALIGNMENT, ov); +} + + /* Returns the default display alignment for a variable of the given TYPE, as set by var_create. The return value can be used to reset a variable's display alignment to the default. */ @@ -777,14 +1111,24 @@ var_get_leave (const struct variable *v) } /* Sets V's leave setting to LEAVE. */ -void -var_set_leave (struct variable *v, bool leave) +static void +var_set_leave_quiet (struct variable *v, bool leave) { assert (leave || !var_must_leave (v)); v->leave = leave; - dict_var_changed (v); } + +/* Sets V's leave setting to LEAVE. */ +void +var_set_leave (struct variable *v, bool leave) +{ + struct variable *ov = var_clone (v); + var_set_leave_quiet (v, leave); + dict_var_changed (v, VAR_TRAIT_LEAVE, ov); +} + + /* Returns true if V must be left from case to case, false if it can be set either way. */ bool @@ -828,6 +1172,8 @@ var_get_short_name (const struct variable *var, size_t idx) void var_set_short_name (struct variable *var, size_t idx, const char *short_name) { + struct variable *ov = var_clone (var); + assert (short_name == NULL || id_is_plausible (short_name, false)); /* Clear old short name numbered IDX, if any. */ @@ -850,11 +1196,10 @@ var_set_short_name (struct variable *var, size_t idx, const char *short_name) for (i = old_cnt; i < var->short_name_cnt; i++) var->short_names[i] = NULL; } - var->short_names[idx] = xstrdup (short_name); - str_uppercase (var->short_names[idx]); + var->short_names[idx] = utf8_to_upper (short_name); } - dict_var_changed (var); + dict_var_changed (var, VAR_TRAIT_NAME, ov); } /* Clears V's short names. */ @@ -893,63 +1238,6 @@ var_get_case_index (const struct variable *v) return vardict_get_case_index (v->vardict); } -/* Returns V's auxiliary data, or a null pointer if none has been - attached. */ -void * -var_get_aux (const struct variable *v) -{ - return v->aux; -} - -/* Assign auxiliary data AUX to variable V, which must not - already have auxiliary data. Before V's auxiliary data is - cleared, AUX_DTOR(V) will be called. (var_dtor_free, below, - may be appropriate for use as AUX_DTOR.) */ -void * -var_attach_aux (const struct variable *v_, - void *aux, void (*aux_dtor) (struct variable *)) -{ - struct variable *v = CONST_CAST (struct variable *, v_); - assert (v->aux == NULL); - assert (aux != NULL); - v->aux = aux; - v->aux_dtor = aux_dtor; - return aux; -} - -/* Remove auxiliary data, if any, from V, and return it, without - calling any associated destructor. */ -void * -var_detach_aux (struct variable *v) -{ - void *aux = v->aux; - assert (aux != NULL); - v->aux = NULL; - return aux; -} - -/* Clears auxiliary data, if any, from V, and calls any - associated destructor. */ -void -var_clear_aux (struct variable *v) -{ - if (v->aux != NULL) - { - if (v->aux_dtor != NULL) - v->aux_dtor (v); - v->aux = NULL; - } -} - -/* This function is appropriate for use an auxiliary data - destructor (passed as AUX_DTOR to var_attach_aux()) for the - case where the auxiliary data should be passed to free(). */ -void -var_dtor_free (struct variable *v) -{ - free (v->aux); -} - /* Returns variable V's attribute set. The caller may examine or modify the attribute set, but must not destroy it. Destroying V, or calling var_set_attributes() on V, will also destroy its @@ -961,13 +1249,23 @@ var_get_attributes (const struct variable *v) } /* Replaces variable V's attributes set by a copy of ATTRS. */ -void -var_set_attributes (struct variable *v, const struct attrset *attrs) +static void +var_set_attributes_quiet (struct variable *v, const struct attrset *attrs) { attrset_destroy (&v->attributes); attrset_clone (&v->attributes, attrs); } +/* Replaces variable V's attributes set by a copy of ATTRS. */ +void +var_set_attributes (struct variable *v, const struct attrset *attrs) +{ + struct variable *ov = var_clone (v); + var_set_attributes_quiet (v, attrs); + dict_var_changed (v, VAR_TRAIT_ATTRIBUTES, ov); +} + + /* Returns true if V has any custom attributes, false if it has none. */ bool var_has_attributes (const struct variable *v) @@ -975,6 +1273,40 @@ var_has_attributes (const struct variable *v) return attrset_count (&v->attributes) > 0; } + +/* Creates and returns a clone of OLD_VAR. Most properties of + the new variable are copied from OLD_VAR, except: + + - The variable's short name is not copied, because there is + no reason to give a new variable with potentially a new + name the same short name. + + - The new variable is not added to OLD_VAR's dictionary by + default. Use dict_clone_var, instead, to do that. +*/ +struct variable * +var_clone (const struct variable *old_var) +{ + struct variable *new_var = var_create (var_get_name (old_var), + var_get_width (old_var)); + + var_set_missing_values_quiet (new_var, var_get_missing_values (old_var)); + var_set_print_format_quiet (new_var, var_get_print_format (old_var)); + var_set_write_format_quiet (new_var, var_get_write_format (old_var)); + var_set_value_labels_quiet (new_var, var_get_value_labels (old_var)); + var_set_label_quiet (new_var, var_get_label (old_var), false); + var_set_measure_quiet (new_var, var_get_measure (old_var)); + var_set_role_quiet (new_var, var_get_role (old_var)); + var_set_display_width_quiet (new_var, var_get_display_width (old_var)); + var_set_alignment_quiet (new_var, var_get_alignment (old_var)); + var_set_leave_quiet (new_var, var_get_leave (old_var)); + var_set_attributes_quiet (new_var, var_get_attributes (old_var)); + + return new_var; +} + + + /* Returns the encoding of values of variable VAR. (This is actually a property of the dictionary.) Returns null if no specific encoding has been set. */