X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fvariable.c;h=2e584fe86fa5dd7e9867c27d257186e3ecd4a528;hb=899ca177810116bc0ff1c4bcce9368d79cd71d42;hp=d1e308640d05268df79f8639848cef04c618ba23;hpb=b5c82cc9aabe7e641011130240ae1b2e84348e23;p=pspp

diff --git a/src/data/variable.c b/src/data/variable.c
index d1e308640d..2e584fe86f 100644
--- a/src/data/variable.c
+++ b/src/data/variable.c
@@ -1,5 +1,6 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 1997-9, 2000, 2006, 2009 Free Software Foundation, Inc.
+   Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2012, 2013,
+   2014, 2016, 2020 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,47 +16,88 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
 
 #include <config.h>
-#include "variable.h"
+
+#include "data/variable.h"
 
 #include <stdlib.h>
 
-#include <data/attributes.h>
-#include <data/category.h>
-#include <data/data-out.h>
-#include <data/format.h>
-#include <data/dictionary.h>
-#include <data/identifier.h>
-#include <data/missing-values.h>
-#include <data/value-labels.h>
-#include <data/vardict.h>
-
-#include <libpspp/misc.h>
-#include <libpspp/assertion.h>
-#include <libpspp/compiler.h>
-#include <libpspp/hash.h>
-#include <libpspp/message.h>
-#include <libpspp/str.h>
-
-#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)
+#define N_(msgid) (msgid)
+
+/* This should follow the definition in Gtk */
+typedef struct
+{
+  int value;
+  const char *name;
+  const char *label;
+} GEnumValue;
+
+const GEnumValue align[] =
+  {
+    {ALIGN_LEFT,   "left", N_("Left")},
+    {ALIGN_RIGHT,  "right", N_("Right")},
+    {ALIGN_CENTRE, "center", N_("Center")},
+    {0,0,0}
+  };
+
+const GEnumValue measure[] =
+  {
+    {MEASURE_UNKNOWN, "unknown", N_("Unknown")},
+    {MEASURE_NOMINAL, "nominal", N_("Nominal")},
+    {MEASURE_ORDINAL, "ordinal", N_("Ordinal")},
+    {MEASURE_SCALE,   "scale", N_("Scale")},
+    {0,0,0}
+  };
+
+const GEnumValue role[] =
+  {
+    {ROLE_INPUT,  "input",    N_("Input")},
+    {ROLE_TARGET, "output",   N_("Output")},
+    {ROLE_BOTH,   "both",     N_("Both")},
+    {ROLE_NONE,   "none",     N_("None")},
+    {ROLE_PARTITION, "partition", N_("Partition")},
+    {ROLE_SPLIT,  "split",    N_("Split")},
+    {0,0,0}
+  };
 
 /* A variable. */
 struct variable
   {
+    int ref_cnt;
     /* 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. */
+    enum var_role role;         /* Intended use. */
     int display_width;          /* Width of data editor column. */
     enum alignment alignment;   /* Alignment of data in GUI. */
 
@@ -63,26 +105,23 @@ struct variable
     bool leave;                 /* Leave value from case to case? */
 
     /* Data for use by containing dictionary. */
-    struct vardict_info vardict;
+    struct vardict_info *vardict;
 
     /* Used only for system and portable file input and output.
        See short-names.h. */
     char **short_names;
-    size_t short_name_cnt;
-
-    /* Each command may use these fields as needed. */
-    void *aux;
-    void (*aux_dtor) (struct variable *);
-
-    /* Values of a categorical variable.  Procedures need
-       vectors with binary entries, so any variable of type ALPHA will
-       have its values stored here. */
-    struct cat_vals *obs_vals;
+    size_t n_short_names;
 
     /* 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 void var_set_label_quiet (struct variable *v, const char *label);
+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,215 +129,96 @@ struct variable
 struct variable *
 var_create (const char *name, int width)
 {
-  struct variable *v;
   enum val_type type;
 
   assert (width >= 0 && width <= MAX_STRING);
 
-  v = xmalloc (sizeof *v);
-  v->vardict.dict_index = v->vardict.case_index = -1;
-  var_set_name (v, name);
+  struct variable *v = XZALLOC (struct variable);
+  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->measure = var_default_measure_for_type (type);
+  v->role = ROLE_INPUT;
   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;
-  v->obs_vals = NULL;
   attrset_init (&v->attributes);
+  ds_init_empty (&v->name_and_label);
+
+  v->ref_cnt = 1;
 
   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.
-
-    - Auxiliary data and obs_vals are not copied. */
-struct variable *
-var_clone (const struct variable *old_var)
+/* Destroys variable V.
+   V must not belong to a dictionary.  If it does, use
+   dict_delete_var instead. */
+static void
+var_destroy__ (struct variable *v)
 {
-  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;
+  assert (!var_has_vardict (v));
+  mv_destroy (&v->miss);
+  var_clear_short_names (v);
+  val_labs_destroy (v->val_labs);
+  var_set_label_quiet (v, NULL);
+  attrset_destroy (var_get_attributes (v));
+  free (v->name);
+  ds_destroy (&v->name_and_label);
+  free (v);
 }
 
-/* Create a variable of the specified WIDTH to be used for
-   internal calculations only.  The variable is assigned a unique
-   dictionary index and a case index of CASE_IDX. */
 struct variable *
-var_create_internal (int case_idx, int width)
+var_ref (struct variable *v)
 {
-  struct variable *v = var_create ("$internal", width);
-  struct vardict_info vdi;
-  static int counter = INT_MAX / 2;
-
-  vdi.dict = NULL;
-  vdi.case_index = case_idx;
-  vdi.dict_index = counter++;
-  if (counter == INT_MAX)
-    counter = INT_MAX / 2;
-
-  var_set_vardict (v, &vdi);
-
+  v->ref_cnt++;
   return v;
 }
 
-/* Destroys variable V.
-   V must not belong to a dictionary.  If it does, use
-   dict_delete_var instead. */
 void
-var_destroy (struct variable *v)
+var_unref (struct variable *v)
 {
-  if (v != NULL)
-    {
-      if (var_has_vardict (v))
-	{
-	  const struct vardict_info *vdi = var_get_vardict (v);
-	  assert (vdi->dict == NULL);
-	}
-      mv_destroy (&v->miss);
-      cat_stored_values_destroy (v->obs_vals);
-      var_clear_short_names (v);
-      var_clear_aux (v);
-      val_labs_destroy (v->val_labs);
-      var_clear_label (v);
-      free (v);
-    }
+  if (--v->ref_cnt == 0)
+    var_destroy__ (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.
-   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)
-{
-  assert (v->vardict.dict_index == -1);
-  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)
+/* 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. */
+static void
+var_set_name_quiet (struct variable *v, const char *name)
 {
-  bool plausible;
-  size_t length, i;
-
-  assert (name != NULL);
-
-  /* Note that strlen returns number of BYTES, not the number of
-     CHARACTERS */
-  length = strlen (name);
+  assert (!var_has_vardict (v));
 
-  plausible = var_is_plausible_name(name, issue_error);
-
-  if ( ! plausible )
-    return 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;
-
-  assert (name != NULL);
-
-  /* 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. */
@@ -316,7 +236,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. */
@@ -325,7 +245,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
@@ -337,7 +257,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
@@ -361,7 +281,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. */
@@ -378,15 +298,14 @@ 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);
@@ -395,6 +314,8 @@ var_set_width (struct variable *v, int new_width)
       mv_destroy (&v->miss);
       mv_init (&v->miss, new_width);
     }
+  if (new_width != var_get_width (v))
+    traits |= VAR_TRAIT_MISSING_VALUES;
 
   if (v->val_labs != NULL)
     {
@@ -405,16 +326,53 @@ 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;
 
-  v->width = new_width;
-  dict_var_resized (v, old_width);
-  dict_var_changed (v);
+  if (fmt_resize (&v->write, new_width))
+    traits |= VAR_TRAIT_WRITE_FORMAT;
+
+  if (v->width != new_width)
+    {
+      v->width = new_width;
+      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;
+    }
+
+  if (traits != 0)
+    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)
@@ -441,8 +399,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)
     {
@@ -453,8 +411,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. */
@@ -472,32 +440,28 @@ var_has_missing_values (const struct variable *v)
   return !mv_is_empty (&v->miss);
 }
 
-/* Returns true if VALUE is in the given CLASS of missing values
-   in V, false otherwise. */
-bool
-var_is_value_missing (const struct variable *v, const union value *value,
-                      enum mv_class class)
+/* Returns MV_SYSTEM if VALUE is system-missing, MV_USER if VALUE is
+   user-missing for V, and otherwise 0. */
+enum mv_class
+var_is_value_missing (const struct variable *v, const union value *value)
 {
-  return mv_is_value_missing (&v->miss, value, class);
+  return mv_is_value_missing (&v->miss, value);
 }
 
-/* Returns true if D is in the given CLASS of missing values in
-   V, false otherwise.
-   V must be a numeric variable. */
-bool
-var_is_num_missing (const struct variable *v, double d, enum mv_class class)
+/* Returns MV_SYSTEM if VALUE is system-missing, MV_USER if VALUE is
+   user-missing for V, and otherwise 0.  V must be a numeric variable. */
+enum mv_class
+var_is_num_missing (const struct variable *v, double d)
 {
-  return mv_is_num_missing (&v->miss, d, class);
+  return mv_is_num_missing (&v->miss, d);
 }
 
-/* Returns true if S[] is a missing value for V, false otherwise.
-   S[] must contain exactly as many characters as V's width.
-   V must be a string variable. */
-bool
-var_is_str_missing (const struct variable *v, const uint8_t s[],
-                    enum mv_class class)
+/* Returns MV_USER if VALUE is user-missing for V and otherwise 0.  V must be
+   a string variable. */
+enum mv_class
+var_is_str_missing (const struct variable *v, const uint8_t s[])
 {
-  return mv_is_str_missing (&v->miss, s, class);
+  return mv_is_str_missing (&v->miss, s);
 }
 
 /* Returns variable V's value labels,
@@ -519,8 +483,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;
@@ -530,10 +494,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
@@ -543,9 +520,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 if VALUE has an
-   existing label or if V is a long string variable. */
+/* 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)
@@ -554,9 +533,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.
-   Has no effect if V is a long string variable. */
+
+   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)
@@ -572,14 +552,58 @@ 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,
+                      settings_get_fmt_settings ());
+  struct substring ss = ss_cstr (s);
+  ss_rtrim (&ss, ss_cstr (" "));
+  ds_put_substring (str, ss);
+  free (s);
+}
+
+void
+var_append_value_name__ (const struct variable *v, const union value *value,
+                         enum settings_value_show show, struct string *str)
+{
+  const char *label = var_lookup_value_label (v, value);
+
+  switch (show)
+    {
+    case SETTINGS_VALUE_SHOW_VALUE:
+      append_value (v, value, str);
+      break;
+
+    default:
+    case SETTINGS_VALUE_SHOW_LABEL:
+      if (label)
+	ds_put_cstr (str, label);
+      else
+	append_value (v, value, str);
+      break;
+
+    case SETTINGS_VALUE_SHOW_BOTH:
+      append_value (v, value, str);
+      if (label != NULL)
+        ds_put_format (str, " %s", label);
+      break;
+    }
+}
+
 /* 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.
@@ -589,16 +613,7 @@ void
 var_append_value_name (const struct variable *v, const union value *value,
 		       struct string *str)
 {
-  const char *name = var_lookup_value_label (v, value);
-  const struct dictionary *dict = var_get_vardict (v)->dict;
-  if (name == NULL)
-    {
-      char *s = data_out (value, dict_get_encoding (dict), &v->print);
-      ds_put_cstr (str, s);
-      free (s);
-    }
-  else
-    ds_put_cstr (str, name);
+  var_append_value_name__ (v, value, settings_get_show_values (), str);
 }
 
 /* Print and write formats. */
@@ -610,6 +625,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
@@ -617,9 +646,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. */
@@ -629,6 +658,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
@@ -636,11 +679,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
@@ -648,8 +692,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
@@ -663,14 +709,46 @@ 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;
+  switch (settings_get_show_variables ())
+    {
+    case SETTINGS_VALUE_SHOW_VALUE:
+      return v->name;
+
+    case SETTINGS_VALUE_SHOW_LABEL:
+    default:
+      return v->label != NULL ? v->label : v->name;
+
+    case SETTINGS_VALUE_SHOW_BOTH:
+      update_vl_string (v);
+      return ds_cstr (&v->name_and_label);
+    }
 }
 
 /* Returns V's variable label, or a null pointer if it has none. */
@@ -680,28 +758,38 @@ 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. */
+static void
+var_set_label_quiet (struct variable *v, const char *label)
 {
   free (v->label);
   v->label = NULL;
 
-  if (label != NULL)
-    {
-      struct substring s = ss_cstr (label);
-      ss_trim (&s, ss_cstr (CC_SPACES));
-      ss_truncate (&s, 255);
-      if (!ss_is_empty (s))
-        v->label = ss_xstrdup (s);
-    }
-  dict_var_changed (v);
+  if (label != NULL && label[strspn (label, CC_SPACES)])
+    v->label = xstrdup (label);
+
+  ds_destroy (&v->name_and_label);
+  ds_init_empty (&v->name_and_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. */
+void
+var_set_label (struct variable *v, const char *label)
+{
+  struct variable *ov = var_clone (v);
+  var_set_label_quiet (v, label);
+  dict_var_changed (v, VAR_TRAIT_LABEL, ov);
 }
 
+
 /* Removes any variable label from V. */
 void
 var_clear_label (struct variable *v)
@@ -722,7 +810,38 @@ var_has_label (const struct variable *v)
 bool
 measure_is_valid (enum measure m)
 {
-  return m == MEASURE_NOMINAL || m == MEASURE_ORDINAL || m == MEASURE_SCALE;
+  return (m == MEASURE_UNKNOWN || m == MEASURE_NOMINAL
+          || m == MEASURE_ORDINAL || m == MEASURE_SCALE);
+}
+
+/* Returns a string version of measurement level M, for display to a user.
+   The caller may translate the string by passing it to gettext(). */
+const char *
+measure_to_string (enum measure m)
+{
+  assert (m == measure[m].value);
+  return measure[m].label;
+}
+
+/* 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. */
@@ -733,22 +852,144 @@ 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
    default. */
 enum measure
-var_default_measure (enum val_type type)
+var_default_measure_for_type (enum val_type type)
 {
-  return type == VAL_NUMERIC ? MEASURE_SCALE : MEASURE_NOMINAL;
+  return type == VAL_NUMERIC ? MEASURE_UNKNOWN : MEASURE_NOMINAL;
+}
+
+/* Returns the default measurement level for a variable with the given
+   FORMAT, or MEASURE_UNKNOWN if there is no good default. */
+enum measure
+var_default_measure_for_format (enum fmt_type format)
+{
+  if (format == FMT_DOLLAR)
+    return MEASURE_SCALE;
+
+  switch (fmt_get_category (format))
+    {
+    case FMT_CAT_BASIC:
+    case FMT_CAT_LEGACY:
+    case FMT_CAT_BINARY:
+    case FMT_CAT_HEXADECIMAL:
+      return MEASURE_UNKNOWN;
+
+    case FMT_CAT_CUSTOM:
+    case FMT_CAT_DATE:
+    case FMT_CAT_TIME:
+      return MEASURE_SCALE;
+
+    case FMT_CAT_DATE_COMPONENT:
+    case FMT_CAT_STRING:
+      return MEASURE_NOMINAL;
+    }
+
+  NOT_REACHED ();
+}
+
+/* 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_TARGET:
+    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.
+   The caller may translate the string by passing it to gettext(). */
+const char *
+var_role_to_string (enum var_role r)
+{
+  assert (r == role[r].value);
+  return role[r].label;
+}
+
+/* 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_INPUT:
+      return "INPUT";
+
+    case ROLE_TARGET:
+      return "TARGET";
+
+    case ROLE_BOTH:
+      return "BOTH";
+
+    case ROLE_NONE:
+      return "NONE";
+
+    case ROLE_PARTITION:
+      return "PARTITION";
+
+    case ROLE_SPLIT:
+      return "SPLIT";
+
+    default:
+      return "<invalid>";
+    }
+}
+
+/* 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. */
@@ -759,17 +1000,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);
+  if (v->display_width != new_width)
+    {
+      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
@@ -789,6 +1037,35 @@ 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.
+   The caller may translate the string by passing it to gettext(). */
+const char *
+alignment_to_string (enum alignment a)
+{
+  assert (a == align[a].value);
+  return align[a].label;
+}
+
+/* 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)
@@ -797,14 +1074,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. */
@@ -826,14 +1112,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
@@ -853,9 +1149,9 @@ var_must_leave (const struct variable *v)
    all if it hasn't been saved to or read from a system or
    portable file. */
 size_t
-var_get_short_name_cnt (const struct variable *var) 
+var_get_n_short_names (const struct variable *var)
 {
-  return var->short_name_cnt;
+  return var->n_short_names;
 }
 
 /* Returns VAR's short name with the given IDX, if it has one
@@ -865,44 +1161,44 @@ var_get_short_name_cnt (const struct variable *var)
 const char *
 var_get_short_name (const struct variable *var, size_t idx)
 {
-  return idx < var->short_name_cnt ? var->short_names[idx] : NULL;
+  return idx < var->n_short_names ? 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 (var != NULL);
-  assert (short_name == NULL || var_is_plausible_name (short_name, false));
+  struct variable *ov = var_clone (var);
 
   /* Clear old short name numbered IDX, if any. */
-  if (idx < var->short_name_cnt) 
+  if (idx < var->n_short_names)
     {
       free (var->short_names[idx]);
-      var->short_names[idx] = NULL; 
+      var->short_names[idx] = NULL;
     }
 
   /* Install new short name for IDX. */
-  if (short_name != NULL) 
+  if (short_name != NULL)
     {
-      if (idx >= var->short_name_cnt)
+      if (idx >= var->n_short_names)
         {
-          size_t old_cnt = var->short_name_cnt;
+          size_t n_old = var->n_short_names;
           size_t i;
-          var->short_name_cnt = MAX (idx * 2, 1);
-          var->short_names = xnrealloc (var->short_names, var->short_name_cnt,
+          var->n_short_names = MAX (idx * 2, 1);
+          var->short_names = xnrealloc (var->short_names, var->n_short_names,
                                         sizeof *var->short_names);
-          for (i = old_cnt; i < var->short_name_cnt; i++)
+          for (i = n_old; i < var->n_short_names; 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. */
@@ -911,11 +1207,11 @@ var_clear_short_names (struct variable *v)
 {
   size_t i;
 
-  for (i = 0; i < v->short_name_cnt; i++)
+  for (i = 0; i < v->n_short_names; i++)
     free (v->short_names[i]);
   free (v->short_names);
   v->short_names = NULL;
-  v->short_name_cnt = 0;
+  v->n_short_names = 0;
 }
 
 /* Relationship with dictionary. */
@@ -926,8 +1222,8 @@ var_clear_short_names (struct variable *v)
 size_t
 var_get_dict_index (const struct variable *v)
 {
-  assert (v->vardict.dict_index != -1);
-  return v->vardict.dict_index;
+  assert (var_has_vardict (v));
+  return vardict_get_dict_index (v->vardict);
 }
 
 /* Returns V's index within the case represented by its
@@ -937,149 +1233,140 @@ var_get_dict_index (const struct variable *v)
 size_t
 var_get_case_index (const struct variable *v)
 {
-  assert (v->vardict.case_index != -1);
-  return v->vardict.case_index;
+  assert (var_has_vardict (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 *))
+/* 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
+   attribute set. */
+struct attrset *
+var_get_attributes (const struct variable *v)
 {
-  struct variable *v = (struct variable *) v_ ; /* cast away const  */
-  assert (v->aux == NULL);
-  assert (aux != NULL);
-  v->aux = aux;
-  v->aux_dtor = aux_dtor;
-  return aux;
+  return CONST_CAST (struct attrset *, &v->attributes);
 }
 
-/* Remove auxiliary data, if any, from V, and return it, without
-   calling any associated destructor. */
-void *
-var_detach_aux (struct variable *v)
+/* Replaces variable V's attributes set by a copy of ATTRS. */
+static void
+var_set_attributes_quiet (struct variable *v, const struct attrset *attrs)
 {
-  void *aux = v->aux;
-  assert (aux != NULL);
-  v->aux = NULL;
-  return aux;
+  attrset_destroy (&v->attributes);
+  attrset_clone (&v->attributes, attrs);
 }
 
-/* Clears auxiliary data, if any, from V, and calls any
-   associated destructor. */
+/* Replaces variable V's attributes set by a copy of ATTRS. */
 void
-var_clear_aux (struct variable *v)
+var_set_attributes (struct variable *v, const struct attrset *attrs)
 {
-  assert (v != NULL);
-  if (v->aux != NULL)
-    {
-      if (v->aux_dtor != NULL)
-        v->aux_dtor (v);
-      v->aux = NULL;
-    }
+  struct variable *ov = var_clone (v);
+  var_set_attributes_quiet (v, attrs);
+  dict_var_changed (v, VAR_TRAIT_ATTRIBUTES, ov);
 }
 
-/* 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)
+
+/* Returns true if V has any custom attributes, false if it has none. */
+bool
+var_has_attributes (const struct variable *v)
 {
-  free (v->aux);
+  return attrset_count (&v->attributes) > 0;
 }
 
-/* Observed categorical values. */
 
-/* Returns V's observed categorical values,
-   which V must have. */
-struct cat_vals *
-var_get_obs_vals (const struct variable *v)
-{
-  assert (v->obs_vals != NULL);
-  return v->obs_vals;
-}
+/* Creates and returns a clone of OLD_VAR.  Most properties of
+   the new variable are copied from OLD_VAR, except:
 
-/* Sets V's observed categorical values to CAT_VALS.
-   V becomes the owner of CAT_VALS. */
-void
-var_set_obs_vals (const struct variable *v_, struct cat_vals *cat_vals)
-{
-  struct variable *v = (struct variable *) v_ ; /* cast away const */
-  cat_stored_values_destroy (v->obs_vals);
-  v->obs_vals = cat_vals;
-}
+    - 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.
 
-/* Returns true if V has observed categorical values,
-   false otherwise. */
-bool
-var_has_obs_vals (const struct variable *v)
-{
-  return v->obs_vals != NULL;
-}
-
-/* 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
-   attribute set. */
-struct attrset *
-var_get_attributes (const struct variable *v) 
+    - 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)
 {
-  return (struct attrset *) &v->attributes;
-}
+  struct variable *new_var = var_create (var_get_name (old_var),
+                                         var_get_width (old_var));
 
-/* Replaces variable V's attributes set by a copy of ATTRS. */
-void
-var_set_attributes (struct variable *v, const struct attrset *attrs) 
-{
-  attrset_destroy (&v->attributes);
-  attrset_clone (&v->attributes, attrs);
+  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));
+  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 true if V has any custom attributes, false if it has none. */
-bool
-var_has_attributes (const struct variable *v)
+
+
+/* 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.  */
+const char *
+var_get_encoding (const struct variable *var)
 {
-  return attrset_count (&v->attributes) > 0;
+  return (var_has_vardict (var)
+          ? dict_get_encoding (vardict_get_dictionary (var->vardict))
+          : NULL);
 }
 
 /* Returns V's vardict structure. */
-const struct vardict_info *
+struct vardict_info *
 var_get_vardict (const struct variable *v)
 {
-  assert (var_has_vardict (v));
-  return &v->vardict;
+  return CONST_CAST (struct vardict_info *, v->vardict);
 }
 
 /* Sets V's vardict data to VARDICT. */
 void
-var_set_vardict (struct variable *v, const struct vardict_info *vardict)
+var_set_vardict (struct variable *v, struct vardict_info *vardict)
 {
-  assert (vardict->dict_index >= 0);
-  assert (vardict->case_index >= 0);
-  v->vardict = *vardict;
+  v->vardict = vardict;
 }
 
 /* Returns true if V has vardict data. */
 bool
 var_has_vardict (const struct variable *v)
 {
-  return v->vardict.dict_index != -1;
+  return v->vardict != NULL;
 }
 
 /* Clears V's vardict data. */
 void
 var_clear_vardict (struct variable *v)
 {
-  v->vardict.dict_index = v->vardict.case_index = -1;
+  v->vardict = NULL;
+}
+
+
+/*
+  Returns zero, if W is a missing value for WV or if it is less than zero.
+  Typically used to force a numerical value into a valid weight.
+
+  As a side effect, this function will emit a warning if the value
+  WARN_ON_INVALID points to a bool which is TRUE.  That bool will be then
+  set to FALSE.
+ */
+double
+var_force_valid_weight (const struct variable *wv, double w, bool *warn_on_invalid)
+{
+  if (w < 0.0 || (wv && var_is_num_missing (wv, w)))
+    w = 0.0;
+
+  if (w == 0.0 && warn_on_invalid != NULL && *warn_on_invalid)
+    {
+      *warn_on_invalid = false;
+      msg (SW, _("At least one case in the data file had a weight value "
+		 "that was user-missing, system-missing, zero, or "
+		 "negative.  These case(s) were ignored."));
+    }
+
+  return w;
 }