X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fvariable.c;h=720def8e6c6708d655db98ced2e51b995daf4bfc;hb=refs%2Fbuilds%2F20130812030507%2Fpspp;hp=707b2813eccb172bdbee017ff92f2bea009ac8f2;hpb=a258e53c63a08b0ec48aea8f03808eb651729424;p=pspp
diff --git a/src/data/variable.c b/src/data/variable.c
index 707b2813ec..720def8e6c 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 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
@@ -15,28 +15,30 @@
along with this program. If not, see . */
#include
-#include "variable.h"
+
+#include "data/variable.h"
#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-
-#include
-#include
-#include
-#include
-#include
-#include
-
-#include "minmax.h"
-#include "xalloc.h"
+#include "data/attributes.h"
+#include "data/data-out.h"
+#include "data/dictionary.h"
+#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"
+#include "libpspp/compiler.h"
+#include "libpspp/hash-functions.h"
+#include "libpspp/i18n.h"
+#include "libpspp/message.h"
+#include "libpspp/misc.h"
+#include "libpspp/str.h"
+
+#include "gl/minmax.h"
+#include "gl/xalloc.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
@@ -45,13 +47,14 @@
struct variable
{
/* Dictionary information. */
- char name[VAR_NAME_LEN + 1]; /* Variable name. Mixed case. */
+ char *name; /* Variable name. Mixed case. */
int width; /* 0 for numeric, otherwise string width. */
struct missing_values miss; /* Missing values. */
struct fmt_spec print; /* Default format for PRINT. */
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. */
@@ -69,14 +72,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
@@ -89,9 +94,8 @@ var_create (const char *name, int width)
assert (width >= 0 && width <= MAX_STRING);
- v = xmalloc (sizeof *v);
- v->vardict = 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);
@@ -100,47 +104,12 @@ var_create (const char *name, int width)
v->measure = var_default_measure (type);
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));
- 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. */
@@ -152,115 +121,50 @@ 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);
}
}
/* Variable names. */
-/* Return variable V's name. */
+/* Return variable V's name, as a UTF-8 encoded string. */
const char *
var_get_name (const struct variable *v)
{
return v->name;
}
-/* Sets V's name to 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 (var_is_plausible_name (name, false));
-
- str_copy_trunc (v->name, sizeof v->name, name);
- dict_var_changed (v);
-}
-
-/* Returns true if NAME is an acceptable name for a variable,
- false otherwise. If ISSUE_ERROR is true, issues an
- explanatory error message on failure. */
-bool
-var_is_valid_name (const char *name, bool issue_error)
-{
- bool plausible;
- size_t length, i;
-
- /* Note that strlen returns number of BYTES, not the number of
- CHARACTERS */
- length = strlen (name);
-
- plausible = var_is_plausible_name(name, issue_error);
-
- if ( ! plausible )
- return false;
-
+ assert (id_is_plausible (name, false));
- if (!lex_is_id1 (name[0]))
- {
- if (issue_error)
- msg (SE, _("Character `%c' (in %s) may not appear "
- "as the first character in a variable name."),
- name[0], name);
- return false;
- }
-
-
- for (i = 0; i < length; i++)
- {
- if (!lex_is_idn (name[i]))
- {
- if (issue_error)
- msg (SE, _("Character `%c' (in %s) may not appear in "
- "a variable name."),
- name[i], name);
- return false;
- }
- }
-
- return true;
+ free (v->name);
+ v->name = xstrdup (name);
+ ds_destroy (&v->name_and_label);
+ ds_init_empty (&v->name_and_label);
}
-/* Returns true if NAME is an plausible name for a variable,
- false otherwise. If ISSUE_ERROR is true, issues an
- explanatory error message on failure.
- This function makes no use of LC_CTYPE.
-*/
-bool
-var_is_plausible_name (const char *name, bool issue_error)
+/* 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)
{
- size_t length;
-
- /* Note that strlen returns number of BYTES, not the number of
- CHARACTERS */
- length = strlen (name);
- if (length < 1)
- {
- if (issue_error)
- msg (SE, _("Variable name cannot be empty string."));
- return false;
- }
- else if (length > VAR_NAME_LEN)
- {
- if (issue_error)
- msg (SE, _("Variable name %s exceeds %d-character limit."),
- name, (int) VAR_NAME_LEN);
- return false;
- }
-
- if (lex_id_to_token (ss_cstr (name)) != T_ID)
- {
- if (issue_error)
- msg (SE, _("`%s' may not be used as a variable name because it "
- "is a reserved word."), name);
- return false;
- }
-
- return true;
+ 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. */
@@ -278,7 +182,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. */
@@ -287,7 +191,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
@@ -299,7 +203,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
@@ -323,7 +227,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. */
@@ -340,22 +244,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)
@@ -367,16 +274,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)
@@ -403,8 +343,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)
{
@@ -415,8 +355,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. */
@@ -481,8 +431,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;
@@ -492,10 +442,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
@@ -505,9 +468,11 @@ alloc_value_labels (struct variable *v)
v->val_labs = val_labs_create (v->width);
}
-/* Attempts to add a value label with the given VALUE and LABEL
- to V. Returns true if successful, false otherwise (probably
- due to an existing label). */
+/* Attempts to add a value label with the given VALUE and UTF-8 encoded LABEL
+ to V. Returns true if successful, false otherwise (probably due to an
+ existing label).
+
+ In LABEL, the two-byte sequence "\\n" is interpreted as a new-line. */
bool
var_add_value_label (struct variable *v,
const union value *value, const char *label)
@@ -516,9 +481,10 @@ var_add_value_label (struct variable *v,
return val_labs_add (v->val_labs, value, label);
}
-/* Adds or replaces a value label with the given VALUE and LABEL
+/* Adds or replaces a value label with the given VALUE and UTF-8 encoded LABEL
to V.
-*/
+
+ In LABEL, the two-byte sequence "\\n" is interpreted as a new-line. */
void
var_replace_value_label (struct variable *v,
const union value *value, const char *label)
@@ -534,14 +500,27 @@ var_clear_value_labels (struct variable *v)
var_set_value_labels (v, NULL);
}
-/* Returns the label associated with VALUE for variable V,
- or a null pointer if none. */
+/* Returns the label associated with VALUE for variable V, as a UTF-8 string in
+ a format suitable for output, or a null pointer if none. */
const char *
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.
@@ -551,15 +530,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. */
@@ -571,6 +568,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
@@ -578,9 +589,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. */
@@ -590,6 +601,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
@@ -597,11 +622,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
@@ -609,8 +635,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
@@ -624,14 +652,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. */
@@ -641,33 +706,82 @@ var_get_label (const struct variable *v)
return v->label;
}
-/* Sets V's variable label to LABEL, stripping off leading and
- trailing white space and truncating to 255 characters.
- 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. */
-void
-var_set_label (struct variable *v, const char *label)
+/* 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. */
+static bool
+var_set_label_quiet (struct variable *v, const char *label, bool issue_warning)
{
+ bool truncated = false;
+
free (v->label);
v->label = NULL;
- if (label != NULL)
+ if (label != NULL && label[strspn (label, CC_SPACES)])
{
+ const char *dict_encoding = var_get_encoding (v);
struct substring s = ss_cstr (label);
- ss_trim (&s, ss_cstr (CC_SPACES));
- ss_truncate (&s, 255);
- if (!ss_is_empty (s))
+ size_t trunc_len;
+
+ if (dict_encoding != NULL)
+ {
+ enum { MAX_LABEL_LEN = 255 };
+
+ trunc_len = utf8_encoding_trunc_len (label, dict_encoding,
+ MAX_LABEL_LEN);
+ if (ss_length (s) > trunc_len)
+ {
+ if (issue_warning)
+ msg (SW, _("Truncating variable label for variable `%s' to %d "
+ "bytes."), var_get_name (v), MAX_LABEL_LEN);
+ ss_truncate (&s, trunc_len);
+ truncated = true;
+ }
+ }
+
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)
{
- var_set_label (v, NULL);
+ var_set_label (v, NULL, false);
}
/* Returns true if V has a variable V,
@@ -686,6 +800,26 @@ measure_is_valid (enum measure m)
return m == MEASURE_NOMINAL || m == MEASURE_ORDINAL || m == MEASURE_SCALE;
}
+/* Returns a string version of measurement level M, for display to a user. */
+const char *
+measure_to_string (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)
@@ -694,14 +828,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
@@ -720,19 +864,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. */
@@ -750,6 +899,26 @@ alignment_is_valid (enum alignment a)
return a == ALIGN_LEFT || a == ALIGN_RIGHT || a == ALIGN_CENTRE;
}
+/* Returns a string version of alignment A, for display to a user. */
+const char *
+alignment_to_string (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)
@@ -758,14 +927,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. */
@@ -787,14 +965,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
@@ -829,14 +1017,18 @@ var_get_short_name (const struct variable *var, size_t idx)
return idx < var->short_name_cnt ? var->short_names[idx] : NULL;
}
-/* Sets VAR's short name with the given IDX to SHORT_NAME,
- truncating it to SHORT_NAME_LEN characters and converting it
- to uppercase in the process. Specifying a null pointer for
- SHORT_NAME clears the specified short name. */
+/* Sets VAR's short name with the given IDX to the UTF-8 string SHORT_NAME.
+ The caller must already have checked that, in the dictionary encoding,
+ SHORT_NAME is no more than SHORT_NAME_LEN bytes long. The new short name
+ will be converted to uppercase.
+
+ Specifying a null pointer for SHORT_NAME clears the specified short name. */
void
var_set_short_name (struct variable *var, size_t idx, const char *short_name)
{
- assert (short_name == NULL || var_is_plausible_name (short_name, false));
+ struct variable *ov = var_clone (var);
+
+ assert (short_name == NULL || id_is_plausible (short_name, false));
/* Clear old short name numbered IDX, if any. */
if (idx < var->short_name_cnt)
@@ -858,11 +1050,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] = xstrndup (short_name, MAX_SHORT_STRING);
- 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. */
@@ -901,63 +1092,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
@@ -969,13 +1103,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)
@@ -983,6 +1127,39 @@ 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_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. */