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

diff --git a/src/data/variable.c b/src/data/variable.c
index f4da2c4da0..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, 2010, 2011, 2012 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
@@ -42,10 +43,48 @@
 
 #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;                 /* Variable name.  Mixed case. */
     int width;			/* 0 for numeric, otherwise string width. */
@@ -58,6 +97,7 @@ struct variable
 
     /* 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 +110,16 @@ struct variable
     /* Used only for system and portable file input and output.
        See short-names.h. */
     char **short_names;
-    size_t short_name_cnt;
+    size_t n_short_names;
 
     /* Custom attributes. */
     struct attrset attributes;
   };
 
 
-static bool var_set_label_quiet (struct variable *v, const char *label, bool issue_warning);
+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
@@ -87,46 +129,61 @@ static void var_set_name_quiet (struct variable *v, const char *name);
 struct variable *
 var_create (const char *name, int width)
 {
-  struct variable *v;
   enum val_type type;
 
   assert (width >= 0 && width <= MAX_STRING);
 
-  v = xzalloc (sizeof *v);
+  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);
   attrset_init (&v->attributes);
   ds_init_empty (&v->name_and_label);
 
+  v->ref_cnt = 1;
+
   return v;
 }
 
 /* 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)
+{
+  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);
+}
+
+struct variable *
+var_ref (struct variable *v)
+{
+  v->ref_cnt++;
+  return v;
+}
+
 void
-var_destroy (struct variable *v)
+var_unref (struct variable *v)
 {
-  if (v != NULL)
-    {
-      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, false);
-      attrset_destroy (var_get_attributes (v));
-      free (v->name);
-      ds_destroy (&v->name_and_label);
-      free (v);
-    }
+  if (--v->ref_cnt == 0)
+    var_destroy__ (v);
 }
+
+
 
 /* Variable names. */
 
@@ -146,7 +203,6 @@ 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);
@@ -160,8 +216,9 @@ var_set_name_quiet (struct variable *v, const char *name)
 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);
+  dict_var_changed (v, VAR_TRAIT_NAME, ov);
 }
 
 /* Returns VAR's dictionary class. */
@@ -241,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);
@@ -258,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)
     {
@@ -268,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;
+    }
+
+  if (fmt_resize (&v->print, new_width))
+    traits |= VAR_TRAIT_PRINT_FORMAT;
+
+  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;
     }
 
-  fmt_resize (&v->print, new_width);
-  fmt_resize (&v->write, new_width);
+  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;
 
-  v->width = new_width;
-  dict_var_resized (v, old_width);
-  dict_var_changed (v);
+  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 +420,9 @@ var_set_missing_values_quiet (struct variable *v, const struct missing_values *m
 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);
+  dict_var_changed (v, VAR_TRAIT_MISSING_VALUES, ov);
 }
 
 /* Sets variable V to have no user-missing values. */
@@ -344,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,
@@ -413,8 +505,9 @@ var_set_value_labels_quiet (struct variable *v, const struct val_labs *vls)
 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);  
+  dict_var_changed (v, VAR_TRAIT_LABEL, ov);
 }
 
 
@@ -475,47 +568,52 @@ 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);
+  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);
 }
 
-/* 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.
-   STR must be a pointer to an initialised struct string.
-*/
 void
-var_append_value_name (const struct variable *v, const union value *value,
-		       struct string *str)
+var_append_value_name__ (const struct variable *v, const union value *value,
+                         enum settings_value_show show, struct string *str)
 {
-  enum settings_value_style style = settings_get_value_style ();
-  const char *name = var_lookup_value_label (v, value);
+  const char *label = var_lookup_value_label (v, value);
 
-  switch (style)
+  switch (show)
     {
-    case SETTINGS_VAL_STYLE_VALUES:
+    case SETTINGS_VALUE_SHOW_VALUE:
       append_value (v, value, str);
       break;
-      
-    case SETTINGS_VAL_STYLE_LABELS:
-      if (name == NULL)
-	append_value (v, value, str);
+
+    default:
+    case SETTINGS_VALUE_SHOW_LABEL:
+      if (label)
+	ds_put_cstr (str, label);
       else
-	ds_put_cstr (str, name);
+	append_value (v, value, str);
       break;
 
-    case SETTINGS_VAL_STYLE_BOTH:
-    default:
+    case SETTINGS_VALUE_SHOW_BOTH:
       append_value (v, value, str);
-      if (name != NULL)
-	{
-	  ds_put_cstr (str, " (");
-	  ds_put_cstr (str, name);
-	  ds_put_cstr (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.
+   STR must be a pointer to an initialised struct string.
+*/
+void
+var_append_value_name (const struct variable *v, const union value *value,
+		       struct string *str)
+{
+  var_append_value_name__ (v, value, settings_get_show_values (), str);
 }
 
 /* Print and write formats. */
@@ -548,8 +646,9 @@ var_set_print_format_quiet (struct variable *v, const struct fmt_spec *print)
 void
 var_set_print_format (struct variable *v, const struct fmt_spec *print)
 {
+  struct variable *ov = var_clone (v);
   var_set_print_format_quiet (v, print);
-  dict_var_changed (v);
+  dict_var_changed (v, VAR_TRAIT_PRINT_FORMAT, ov);
 }
 
 /* Returns V's write format specification. */
@@ -580,8 +679,9 @@ var_set_write_format_quiet (struct variable *v, const struct fmt_spec *write)
 void
 var_set_write_format (struct variable *v, const struct fmt_spec *write)
 {
+  struct variable *ov = var_clone (v);
   var_set_write_format_quiet (v, write);
-  dict_var_changed (v);
+  dict_var_changed (v, VAR_TRAIT_WRITE_FORMAT, ov);
 }
 
 
@@ -592,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
@@ -634,24 +736,19 @@ update_vl_string (const struct variable *v)
 const char *
 var_to_string (const struct variable *v)
 {
-  enum settings_var_style style = settings_get_var_style ();
-
-  switch (style)
-  {
-    case SETTINGS_VAR_STYLE_NAMES:
+  switch (settings_get_show_variables ())
+    {
+    case SETTINGS_VALUE_SHOW_VALUE:
       return v->name;
-      break;
-    case SETTINGS_VAR_STYLE_LABELS:
+
+    case SETTINGS_VALUE_SHOW_LABEL:
+    default:
       return v->label != NULL ? v->label : v->name;
-      break;
-    case SETTINGS_VAR_STYLE_BOTH:
+
+    case SETTINGS_VALUE_SHOW_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. */
@@ -664,49 +761,18 @@ var_get_label (const struct variable *v)
 /* 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)
+   is removed. */
+static void
+var_set_label_quiet (struct variable *v, const char *label)
 {
-  bool truncated = false;
-
   free (v->label);
   v->label = NULL;
 
   if (label != NULL && label[strspn (label, CC_SPACES)])
-    {
-      const char *dict_encoding = var_get_encoding (v);
-      struct substring s = ss_cstr (label);
-      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);
-    }
+    v->label = xstrdup (label);
 
   ds_destroy (&v->name_and_label);
   ds_init_empty (&v->name_and_label);
-
-  return truncated;
 }
 
 
@@ -714,20 +780,13 @@ var_set_label_quiet (struct variable *v, const char *label, bool issue_warning)
 /* 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)
+   is removed. */
+void
+var_set_label (struct variable *v, const char *label)
 {
-  bool truncated = var_set_label_quiet (v, label, issue_warning);
-
-  dict_var_changed (v);
-
-  return truncated;
+  struct variable *ov = var_clone (v);
+  var_set_label_quiet (v, label);
+  dict_var_changed (v, VAR_TRAIT_LABEL, ov);
 }
 
 
@@ -735,7 +794,7 @@ var_set_label (struct variable *v, const char *label, bool issue_warning)
 void
 var_clear_label (struct variable *v)
 {
-  var_set_label (v, NULL, false);
+  var_set_label (v, NULL);
 }
 
 /* Returns true if V has a variable V,
@@ -751,23 +810,34 @@ 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. */
+/* 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");
+      return "NOMINAL";
 
     case MEASURE_ORDINAL:
-      return _("Ordinal");
+      return "ORDINAL";
 
     case MEASURE_SCALE:
-      return _("Scale");
+      return "SCALE";
 
     default:
       return "Invalid";
@@ -794,8 +864,9 @@ var_set_measure_quiet (struct variable *v, enum measure 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);
+  dict_var_changed (v, VAR_TRAIT_MEASURE, ov);
 }
 
 
@@ -804,9 +875,121 @@ var_set_measure (struct variable *v, enum measure measure)
    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_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)
 {
-  return type == VAL_NUMERIC ? MEASURE_SCALE : MEASURE_NOMINAL;
+  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. */
@@ -823,18 +1006,20 @@ var_set_display_width_quiet (struct variable *v, int new_width)
   if (v->display_width != new_width)
     {
       v->display_width = new_width;
-      dict_var_display_width_changed (v);
     }
 }
 
 void
 var_set_display_width (struct variable *v, int new_width)
 {
-  var_set_display_width_quiet (v, new_width);
-  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
    WIDTH, as set by var_create.  The return value can be used to
    reset a variable's display width to the default. */
@@ -852,20 +1037,29 @@ 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. */
+/* 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");
+      return "LEFT";
 
     case ALIGN_RIGHT:
-      return _("Right");
+      return "RIGHT";
 
     case ALIGN_CENTRE:
-      return _("Center");
+      return "CENTER";
 
     default:
       return "Invalid";
@@ -891,8 +1085,9 @@ var_set_alignment_quiet (struct variable *v, enum alignment 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);
+  dict_var_changed (v, VAR_TRAIT_ALIGNMENT, ov);
 }
 
 
@@ -929,8 +1124,9 @@ var_set_leave_quiet (struct variable *v, bool 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);
+  dict_var_changed (v, VAR_TRAIT_LEAVE, ov);
 }
 
 
@@ -953,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
@@ -965,7 +1161,7 @@ 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 the UTF-8 string SHORT_NAME.
@@ -977,32 +1173,32 @@ 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)
 {
-  assert (short_name == NULL || id_is_plausible (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] = utf8_to_upper (short_name);
     }
 
-  dict_var_changed (var);
+  dict_var_changed (var, VAR_TRAIT_NAME, ov);
 }
 
 /* Clears V's short names. */
@@ -1011,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. */
@@ -1046,14 +1242,14 @@ var_get_case_index (const struct variable *v)
    V, or calling var_set_attributes() on V, will also destroy its
    attribute set. */
 struct attrset *
-var_get_attributes (const struct variable *v) 
+var_get_attributes (const struct variable *v)
 {
   return CONST_CAST (struct attrset *, &v->attributes);
 }
 
 /* Replaces variable V's attributes set by a copy of ATTRS. */
 static void
-var_set_attributes_quiet (struct variable *v, const struct attrset *attrs) 
+var_set_attributes_quiet (struct variable *v, const struct attrset *attrs)
 {
   attrset_destroy (&v->attributes);
   attrset_clone (&v->attributes, attrs);
@@ -1061,10 +1257,11 @@ var_set_attributes_quiet (struct variable *v, const struct attrset *attrs)
 
 /* Replaces variable V's attributes set by a copy of ATTRS. */
 void
-var_set_attributes (struct variable *v, const struct attrset *attrs) 
+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);
+  dict_var_changed (v, VAR_TRAIT_ATTRIBUTES, ov);
 }
 
 
@@ -1096,8 +1293,9 @@ var_clone (const struct variable *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_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));
@@ -1146,3 +1344,29 @@ var_clear_vardict (struct variable *v)
 {
   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;
+}