X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fvariable.c;h=6affaec6e84da2594b756209df5d626f95af3dd5;hb=9daf6d834acd26a9f3e47906773ea57777bf5399;hp=fe4645ee41e1b7d7fad9042e5dc5014076ace03c;hpb=8539c057c6889ff335da0e00117cc0f5fb9bf72d;p=pspp

diff --git a/src/data/variable.c b/src/data/variable.c
index fe4645ee41..6affaec6e8 100644
--- a/src/data/variable.c
+++ b/src/data/variable.c
@@ -72,14 +72,14 @@ 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 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
@@ -93,7 +93,7 @@ var_create (const char *name, int width)
   assert (width >= 0 && width <= MAX_STRING);
 
   v = xzalloc (sizeof *v);
-  var_set_name (v, name);
+  var_set_name_quiet (v, name);
   v->width = width;
   mv_init (&v->miss, width);
   v->leave = var_must_leave (v);
@@ -108,36 +108,6 @@ var_create (const char *name, int width)
   return v;
 }
 
-/* Creates and returns a clone of OLD_VAR.  Most properties of
-   the new variable are copied from OLD_VAR, except:
-
-    - The variable's short name is not copied, because there is
-      no reason to give a new variable with potentially a new
-      name the same short name.
-
-    - The new variable is not added to OLD_VAR's dictionary by
-      default.  Use dict_clone_var, instead, to do that.
-*/
-struct variable *
-var_clone (const struct variable *old_var)
-{
-  struct variable *new_var = var_create (var_get_name (old_var),
-                                         var_get_width (old_var));
-
-  var_set_missing_values (new_var, var_get_missing_values (old_var));
-  var_set_print_format (new_var, var_get_print_format (old_var));
-  var_set_write_format (new_var, var_get_write_format (old_var));
-  var_set_value_labels (new_var, var_get_value_labels (old_var));
-  var_set_label (new_var, var_get_label (old_var), false);
-  var_set_measure (new_var, var_get_measure (old_var));
-  var_set_display_width (new_var, var_get_display_width (old_var));
-  var_set_alignment (new_var, var_get_alignment (old_var));
-  var_set_leave (new_var, var_get_leave (old_var));
-  var_set_attributes (new_var, var_get_attributes (old_var));
-
-  return new_var;
-}
-
 /* Destroys variable V.
    V must not belong to a dictionary.  If it does, use
    dict_delete_var instead. */
@@ -149,9 +119,8 @@ 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);
@@ -173,8 +142,8 @@ var_get_name (const struct variable *v)
 /* Sets V's name to NAME, a UTF-8 encoded string.
    Do not use this function for a variable in a dictionary.  Use
    dict_rename_var instead. */
-void
-var_set_name (struct variable *v, const char *name)
+static void
+var_set_name_quiet (struct variable *v, const char *name)
 {
   assert (!var_has_vardict (v));
   assert (id_is_plausible (name, false));
@@ -183,7 +152,17 @@ var_set_name (struct variable *v, const char *name)
   v->name = xstrdup (name);
   ds_destroy (&v->name_and_label);
   ds_init_empty (&v->name_and_label);
-  dict_var_changed (v);
+}
+
+/* Sets V's name to NAME, a UTF-8 encoded string.
+   Do not use this function for a variable in a dictionary.  Use
+   dict_rename_var instead. */
+void
+var_set_name (struct variable *v, const char *name)
+{
+  struct variable *ov = var_clone (v);
+  var_set_name_quiet (v, name);
+  dict_var_changed (v, VAR_TRAIT_NAME, ov);
 }
 
 /* Returns VAR's dictionary class. */
@@ -268,11 +247,14 @@ var_get_width (const struct variable *v)
 void
 var_set_width (struct variable *v, int new_width)
 {
+  struct variable *ov;
   const int old_width = v->width;
 
   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
@@ -297,7 +279,7 @@ var_set_width (struct variable *v, int new_width)
 
   v->width = new_width;
   dict_var_resized (v, old_width);
-  dict_var_changed (v);
+  dict_var_changed (v, VAR_TRAIT_WIDTH, ov);
 }
 
 /* Returns true if variable V is numeric, false otherwise. */
@@ -326,8 +308,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)
     {
@@ -338,8 +320,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. */
@@ -404,8 +396,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;
@@ -415,10 +407,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
@@ -532,17 +537,28 @@ var_get_print_format (const struct variable *v)
    valid format specification for a variable of V's width
    (ordinarily an output format, but input formats are not
    rejected). */
-void
-var_set_print_format (struct variable *v, const struct fmt_spec *print)
+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;
-      dict_var_changed (v);
     }
 }
 
+/* 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). */
+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, VAR_TRAIT_FORMAT, ov);
+}
+
 /* Returns V's write format specification. */
 const struct fmt_spec *
 var_get_write_format (const struct variable *v)
@@ -554,17 +570,29 @@ var_get_write_format (const struct variable *v)
    valid format specification for a variable of V's width
    (ordinarily an output format, but input formats are not
    rejected). */
-void
-var_set_write_format (struct variable *v, const struct fmt_spec *write)
+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;
-      dict_var_changed (v);
     }
 }
 
+/* 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). */
+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, VAR_TRAIT_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
@@ -572,8 +600,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_FORMAT, ov);
 }
 
 /* Returns the default print and write format for a variable of
@@ -650,8 +680,8 @@ var_get_label (const struct variable *v)
    var_get_encoding()).  If LABEL fits within this limit, this function returns
    true.  Otherwise, the variable label is set to a truncated value, this
    function returns false and, if ISSUE_WARNING is true, issues a warning.  */
-bool
-var_set_label (struct variable *v, const char *label, bool issue_warning)
+static bool
+var_set_label_quiet (struct variable *v, const char *label, bool issue_warning)
 {
   bool truncated = false;
 
@@ -686,11 +716,32 @@ var_set_label (struct variable *v, const char *label, bool issue_warning)
   ds_destroy (&v->name_and_label);
   ds_init_empty (&v->name_and_label);
 
-  dict_var_changed (v);
+  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)
@@ -742,14 +793,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
@@ -768,17 +829,25 @@ var_get_display_width (const struct variable *v)
 }
 
 /* Sets V's display width to DISPLAY_WIDTH. */
-void
-var_set_display_width (struct variable *v, int new_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;
       dict_var_display_width_changed (v);
-      dict_var_changed (v);
     }
 }
 
+void
+var_set_display_width (struct variable *v, int 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. */
@@ -824,14 +893,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. */
@@ -853,14 +931,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
@@ -904,6 +992,8 @@ var_get_short_name (const struct variable *var, size_t idx)
 void
 var_set_short_name (struct variable *var, size_t idx, const char *short_name)
 {
+  struct variable *ov = var_clone (var);
+
   assert (short_name == NULL || id_is_plausible (short_name, false));
 
   /* Clear old short name numbered IDX, if any. */
@@ -929,7 +1019,7 @@ var_set_short_name (struct variable *var, size_t idx, const char *short_name)
       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. */
@@ -968,63 +1058,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
@@ -1036,13 +1069,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)
@@ -1050,6 +1093,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.  */