X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fdictionary.c;h=67af049b24fee7a72e3dd6b6561a6784f87a70b7;hb=5c3291dc396b795696e94f47780308fd7ace6fc4;hp=d29939aca55a8043cec67cf12d3bf676c91f4b02;hpb=ecd26ec19e9f8a58079a1c5fa06b39484787ab7e;p=pspp-builds.git

diff --git a/src/data/dictionary.c b/src/data/dictionary.c
index d29939ac..67af049b 100644
--- a/src/data/dictionary.c
+++ b/src/data/dictionary.c
@@ -1,20 +1,18 @@
-/* PSPP - computes sample statistics.
-   Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
+/* PSPP - a program for statistical analysis.
+   Copyright (C) 1997-9, 2000, 2006, 2007, 2009 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 the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   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
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
 
-   This program is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-   02110-1301, USA. */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>. */
 
 #include <config.h>
 
@@ -23,16 +21,17 @@
 #include <stdlib.h>
 #include <ctype.h>
 
-#include "case.h"
-#include "cat-routines.h"
-#include "category.h"
-#include "settings.h"
-#include "value-labels.h"
-#include "vardict.h"
-#include "variable.h"
-#include "vector.h"
-#include <libpspp/alloc.h>
+#include <data/attributes.h>
+#include <data/case.h>
+#include <data/category.h>
+#include <data/identifier.h>
+#include <data/settings.h>
+#include <data/value-labels.h>
+#include <data/vardict.h>
+#include <data/variable.h>
+#include <data/vector.h>
 #include <libpspp/array.h>
+#include <libpspp/assertion.h>
 #include <libpspp/compiler.h>
 #include <libpspp/hash.h>
 #include <libpspp/message.h>
@@ -40,7 +39,9 @@
 #include <libpspp/pool.h>
 #include <libpspp/str.h>
 
+#include "intprops.h"
 #include "minmax.h"
+#include "xalloc.h"
 
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
@@ -50,23 +51,82 @@ struct dictionary
   {
     struct variable **var;	/* Variables. */
     size_t var_cnt, var_cap;    /* Number of variables, capacity. */
+    struct caseproto *proto;    /* Prototype for dictionary cases
+                                   (updated lazily). */
     struct hsh_table *name_tab;	/* Variable index by name. */
     int next_value_idx;         /* Index of next `union value' to allocate. */
-    struct variable **split;    /* SPLIT FILE vars. */
+    const struct variable **split;    /* SPLIT FILE vars. */
     size_t split_cnt;           /* SPLIT FILE count. */
     struct variable *weight;    /* WEIGHT variable. */
     struct variable *filter;    /* FILTER variable. */
-    size_t case_limit;          /* Current case limit (N command). */
+    casenumber case_limit;      /* Current case limit (N command). */
     char *label;		/* File label. */
-    char *documents;		/* Documents, as a string. */
+    struct string documents;    /* Documents, as a string. */
     struct vector **vector;     /* Vectors of variables. */
     size_t vector_cnt;          /* Number of vectors. */
+    struct attrset attributes;  /* Custom attributes. */
+
+    char *encoding;             /* Character encoding of string data */
+
     const struct dict_callbacks *callbacks; /* Callbacks on dictionary
 					       modification */
     void *cb_data ;                  /* Data passed to callbacks */
+
+    void (*changed) (struct dictionary *, void *); /* Generic change callback */
+    void *changed_data;
   };
 
 
+void
+dict_set_encoding (struct dictionary *d, const char *enc)
+{
+  if (enc)
+    d->encoding = xstrdup (enc);
+}
+
+const char *
+dict_get_encoding (const struct dictionary *d)
+{
+  return d->encoding ;
+}
+
+
+void
+dict_set_change_callback (struct dictionary *d,
+			  void (*changed) (struct dictionary *, void*),
+			  void *data)
+{
+  d->changed = changed;
+  d->changed_data = data;
+}
+
+/* Discards dictionary D's caseproto.  (It will be regenerated
+   lazily, on demand.) */
+static void
+invalidate_proto (struct dictionary *d)
+{
+  caseproto_unref (d->proto);
+  d->proto = NULL;
+}
+
+/* Print a representation of dictionary D to stdout, for
+   debugging purposes. */
+void
+dict_dump (const struct dictionary *d)
+{
+  int i;
+  for (i = 0 ; i < d->var_cnt ; ++i )
+    {
+      const struct variable *v =
+	d->var[i];
+      printf ("Name: %s;\tdict_idx: %d; case_idx: %d\n",
+	      var_get_name (v),
+	      var_get_dict_index (v),
+	      var_get_case_index (v));
+
+    }
+}
+
 /* Associate CALLBACKS with DICT.  Callbacks will be invoked whenever
    the dictionary or any of the variables it contains are modified.
    Each callback will get passed CALLBACK_DATA.
@@ -81,7 +141,6 @@ dict_set_callbacks (struct dictionary *dict,
   dict->cb_data = callback_data;
 }
 
-
 /* Shallow copy the callbacks from SRC to DEST */
 void
 dict_copy_callbacks (struct dictionary *dest,
@@ -97,26 +156,20 @@ dict_create (void)
 {
   struct dictionary *d = xzalloc (sizeof *d);
 
-  d->var = NULL;
-  d->var_cnt = d->var_cap = 0;
   d->name_tab = hsh_create (8, compare_vars_by_name, hash_var_by_name,
                             NULL, NULL);
-  d->next_value_idx = 0;
-  d->split = NULL;
-  d->split_cnt = 0;
-  d->weight = NULL;
-  d->filter = NULL;
-  d->case_limit = 0;
-  d->label = NULL;
-  d->documents = NULL;
-  d->vector = NULL;
-  d->vector_cnt = 0;
-
+  attrset_init (&d->attributes);
   return d;
 }
 
 /* Creates and returns a (deep) copy of an existing
-   dictionary. */
+   dictionary.
+
+   The new dictionary's case indexes are copied from the old
+   dictionary.  If the new dictionary won't be used to access
+   cases produced with the old dictionary, then the new
+   dictionary's case indexes should be compacted with
+   dict_compact_values to save space. */
 struct dictionary *
 dict_clone (const struct dictionary *s)
 {
@@ -129,9 +182,19 @@ dict_clone (const struct dictionary *s)
 
   for (i = 0; i < s->var_cnt; i++)
     {
+      const struct vardict_info *svdi;
+      struct vardict_info dvdi;
       struct variable *sv = s->var[i];
       struct variable *dv = dict_clone_var_assert (d, sv, var_get_name (sv));
-      var_set_short_name (dv, var_get_short_name (sv));
+      size_t i;
+
+      for (i = 0; i < var_get_short_name_cnt (sv); i++)
+        var_set_short_name (dv, i, var_get_short_name (sv, i));
+
+      svdi = var_get_vardict (sv);
+      dvdi = *svdi;
+      dvdi.dict = d;
+      var_set_vardict (dv, &dvdi);
     }
 
   d->next_value_idx = s->next_value_idx;
@@ -145,10 +208,10 @@ dict_clone (const struct dictionary *s)
     }
 
   if (s->weight != NULL)
-    d->weight = dict_lookup_var_assert (d, var_get_name (s->weight));
+    dict_set_weight (d, dict_lookup_var_assert (d, var_get_name (s->weight)));
 
   if (s->filter != NULL)
-    d->filter = dict_lookup_var_assert (d, var_get_name (s->filter));
+    dict_set_filter (d, dict_lookup_var_assert (d, var_get_name (s->filter)));
 
   d->case_limit = s->case_limit;
   dict_set_label (d, dict_get_label (s));
@@ -159,6 +222,11 @@ dict_clone (const struct dictionary *s)
   for (i = 0; i < s->vector_cnt; i++)
     d->vector[i] = vector_clone (s->vector[i], s, d);
 
+  if ( s->encoding)
+    d->encoding = xstrdup (s->encoding);
+
+  dict_set_attributes (d, dict_get_attributes (s));
+
   return d;
 }
 
@@ -169,34 +237,28 @@ dict_clear (struct dictionary *d)
 {
   /* FIXME?  Should we really clear case_limit, label, documents?
      Others are necessarily cleared by deleting all the variables.*/
-  int i;
-
   assert (d != NULL);
 
-  for (i = 0; i < d->var_cnt; i++)
+  while (d->var_cnt > 0 )
     {
-      if (d->callbacks && d->callbacks->var_deleted )
-	d->callbacks->var_deleted (d, i, d->cb_data);
-
-      var_clear_vardict (d->var[i]);
-      var_destroy (d->var[i]);
+      dict_delete_var (d, d->var[d->var_cnt - 1]);
     }
+
   free (d->var);
   d->var = NULL;
   d->var_cnt = d->var_cap = 0;
+  invalidate_proto (d);
   hsh_clear (d->name_tab);
   d->next_value_idx = 0;
-  free (d->split);
-  d->split = NULL;
-  d->split_cnt = 0;
-  d->weight = NULL;
-  d->filter = NULL;
+  dict_set_split_vars (d, NULL, 0);
+  dict_set_weight (d, NULL);
+  dict_set_filter (d, NULL);
   d->case_limit = 0;
   free (d->label);
   d->label = NULL;
-  free (d->documents);
-  d->documents = NULL;
+  ds_destroy (&d->documents);
   dict_clear_vectors (d);
+  attrset_clear (&d->attributes);
 }
 
 /* Destroys the aux data for every variable in D, by calling
@@ -218,8 +280,13 @@ dict_destroy (struct dictionary *d)
 {
   if (d != NULL)
     {
+      /* In general, we don't want callbacks occuring, if the dictionary
+	 is being destroyed */
+      d->callbacks  = NULL ;
+
       dict_clear (d);
       hsh_destroy (d->name_tab);
+      attrset_destroy (&d->attributes);
       free (d);
     }
 }
@@ -247,12 +314,24 @@ dict_get_var (const struct dictionary *d, size_t idx)
 
 /* Sets *VARS to an array of pointers to variables in D and *CNT
    to the number of variables in *D.  All variables are returned
-   if EXCLUDE_CLASSES is 0, or it may contain one or more of (1u
-   << DC_ORDINARY), (1u << DC_SYSTEM), or (1u << DC_SCRATCH) to
-   exclude the corresponding type of variable. */
+   except for those, if any, in the classes indicated by EXCLUDE.
+   (There is no point in putting DC_SYSTEM in EXCLUDE as
+   dictionaries never include system variables.) */
 void
-dict_get_vars (const struct dictionary *d, struct variable ***vars,
-               size_t *cnt, unsigned exclude_classes)
+dict_get_vars (const struct dictionary *d, const struct variable ***vars,
+               size_t *cnt, enum dict_class exclude)
+{
+  dict_get_vars_mutable (d, (struct variable ***) vars, cnt, exclude);
+}
+
+/* Sets *VARS to an array of pointers to variables in D and *CNT
+   to the number of variables in *D.  All variables are returned
+   except for those, if any, in the classes indicated by EXCLUDE.
+   (There is no point in putting DC_SYSTEM in EXCLUDE as
+   dictionaries never include system variables.) */
+void
+dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars,
+                       size_t *cnt, enum dict_class exclude)
 {
   size_t count;
   size_t i;
@@ -260,15 +339,13 @@ dict_get_vars (const struct dictionary *d, struct variable ***vars,
   assert (d != NULL);
   assert (vars != NULL);
   assert (cnt != NULL);
-  assert ((exclude_classes & ~((1u << DC_ORDINARY)
-                               | (1u << DC_SYSTEM)
-                               | (1u << DC_SCRATCH))) == 0);
+  assert (exclude == (exclude & DC_ALL));
 
   count = 0;
   for (i = 0; i < d->var_cnt; i++)
     {
-      enum dict_class class = dict_class_from_id (var_get_name (d->var[i]));
-      if (!(exclude_classes & (1u << class)))
+      enum dict_class class = var_get_dict_class (d->var[i]);
+      if (!(class & exclude))
         count++;
     }
 
@@ -276,8 +353,8 @@ dict_get_vars (const struct dictionary *d, struct variable ***vars,
   *cnt = 0;
   for (i = 0; i < d->var_cnt; i++)
     {
-      enum dict_class class = dict_class_from_id (var_get_name (d->var[i]));
-      if (!(exclude_classes & (1u << class)))
+      enum dict_class class = var_get_dict_class (d->var[i]);
+      if (!(class & exclude))
         (*vars)[(*cnt)++] = d->var[i];
     }
   assert (*cnt == count);
@@ -302,10 +379,12 @@ add_var (struct dictionary *d, struct variable *v)
   d->var[d->var_cnt++] = v;
   hsh_force_insert (d->name_tab, v);
 
-  if ( d->callbacks && d->callbacks->var_added )
-    d->callbacks->var_added (d, d->next_value_idx, d->cb_data);
+  if ( d->changed ) d->changed (d, d->changed_data);
+  if ( d->callbacks &&  d->callbacks->var_added )
+    d->callbacks->var_added (d, var_get_dict_index (v), d->cb_data);
 
-  d->next_value_idx += var_get_value_cnt (v);
+  d->next_value_idx++;
+  invalidate_proto (d);
 
   return v;
 }
@@ -364,9 +443,22 @@ dict_clone_var_assert (struct dictionary *d, const struct variable *old_var,
 struct variable *
 dict_lookup_var (const struct dictionary *d, const char *name)
 {
-  struct variable *target = var_create (name, 0);
-  struct variable *result = hsh_find (d->name_tab, target);
+  struct variable *target ;
+  struct variable *result ;
+
+  if ( ! var_is_plausible_name (name, false))
+    return NULL;
+
+  target = var_create (name, 0);
+  result = hsh_find (d->name_tab, target);
   var_destroy (target);
+
+  if ( result && var_has_vardict (result)) 
+  {
+      const struct vardict_info *vdi = var_get_vardict (result);
+      assert (vdi->dict == d);
+  }
+
   return result;
 }
 
@@ -399,7 +491,7 @@ dict_contains_var (const struct dictionary *d, const struct variable *v)
 /* Compares two double pointers to variables, which should point
    to elements of a struct dictionary's `var' member array. */
 static int
-compare_var_ptrs (const void *a_, const void *b_, const void *aux UNUSED) 
+compare_var_ptrs (const void *a_, const void *b_, const void *aux UNUSED)
 {
   struct variable *const *a = a_;
   struct variable *const *b = b_;
@@ -416,11 +508,12 @@ set_var_dict_index (struct variable *v, int dict_index)
   vdi.dict_index = dict_index;
   var_set_vardict (v, &vdi);
 
-  if ( d->callbacks && d->callbacks->var_changed )
+  if ( d->changed ) d->changed (d, d->changed_data);
+  if ( d->callbacks &&  d->callbacks->var_changed )
     d->callbacks->var_changed (d, dict_index, d->cb_data);
 }
 
-/* Sets the case_index in V's vardict to DICT_INDEX. */
+/* Sets the case_index in V's vardict to CASE_INDEX. */
 static void
 set_var_case_index (struct variable *v, int case_index)
 {
@@ -443,32 +536,36 @@ reindex_vars (struct dictionary *d, size_t from, size_t to)
 /* Deletes variable V from dictionary D and frees V.
 
    This is a very bad idea if there might be any pointers to V
-   from outside D.  In general, no variable in should be deleted when 
-   any transformations are active on the dictionary's dataset, because
-   those transformations might reference the deleted variable.
-   The safest time to delete a variable is just after a procedure
-   has been executed, as done by MODIFY VARS.
+   from outside D.  In general, no variable in the active file's
+   dictionary should be deleted when any transformations are
+   active on the dictionary's dataset, because those
+   transformations might reference the deleted variable.  The
+   safest time to delete a variable is just after a procedure has
+   been executed, as done by DELETE VARIABLES.
 
    Pointers to V within D are not a problem, because
    dict_delete_var() knows to remove V from split variables,
    weights, filters, etc. */
 void
-dict_delete_var (struct dictionary *d, struct variable *v) 
+dict_delete_var (struct dictionary *d, struct variable *v)
 {
   int dict_index = var_get_dict_index (v);
+  const int case_index = var_get_case_index (v);
+  const int width = var_get_width (v);
 
   assert (dict_contains_var (d, v));
 
   /* Delete aux data. */
   var_clear_aux (v);
 
-  /* Remove V from splits, weight, filter variables. */
-  d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split,
-                               &v, compare_var_ptrs, NULL);
+  dict_unset_split_var (d, v);
+
   if (d->weight == v)
-    d->weight = NULL;
+    dict_set_weight (d, NULL);
+
   if (d->filter == v)
-    d->filter = NULL;
+    dict_set_filter (d, NULL);
+
   dict_clear_vectors (d);
 
   /* Remove V from var array. */
@@ -486,15 +583,18 @@ dict_delete_var (struct dictionary *d, struct variable *v)
   var_clear_vardict (v);
   var_destroy (v);
 
-  if (d->callbacks && d->callbacks->var_deleted )
-    d->callbacks->var_deleted (d, dict_index, d->cb_data);
+  if ( d->changed ) d->changed (d, d->changed_data);
+
+  invalidate_proto (d);
+  if (d->callbacks &&  d->callbacks->var_deleted )
+    d->callbacks->var_deleted (d, dict_index, case_index, width, d->cb_data);
 }
 
 /* Deletes the COUNT variables listed in VARS from D.  This is
    unsafe; see the comment on dict_delete_var() for details. */
-void 
+void
 dict_delete_vars (struct dictionary *d,
-                  struct variable *const *vars, size_t count) 
+                  struct variable *const *vars, size_t count)
 {
   /* FIXME: this can be done in O(count) time, but this algorithm
      is O(count**2). */
@@ -509,12 +609,12 @@ dict_delete_vars (struct dictionary *d,
    is unsafe; see the comment on dict_delete_var() for
    details. */
 void
-dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count) 
+dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count)
 {
   /* FIXME: this can be done in O(count) time, but this algorithm
      is O(count**2). */
   assert (idx + count <= d->var_cnt);
-  
+
   while (count-- > 0)
     dict_delete_var (d, d->var[idx]);
 }
@@ -530,7 +630,7 @@ dict_delete_scratch_vars (struct dictionary *d)
   assert (d != NULL);
 
   for (i = 0; i < d->var_cnt; )
-    if (dict_class_from_id (var_get_name (d->var[i])) == DC_SCRATCH)
+    if (var_get_dict_class (d->var[i]) == DC_SCRATCH)
       dict_delete_var (d, d->var[i]);
     else
       i++;
@@ -540,7 +640,7 @@ dict_delete_scratch_vars (struct dictionary *d)
    if any, retain their relative positions.  Runs in time linear
    in the distance moved. */
 void
-dict_reorder_var (struct dictionary *d, struct variable *v, size_t new_index) 
+dict_reorder_var (struct dictionary *d, struct variable *v, size_t new_index)
 {
   size_t old_index = var_get_dict_index (v);
 
@@ -587,7 +687,7 @@ dict_reorder_vars (struct dictionary *d,
 
 /* Changes the name of variable V in dictionary D to NEW_NAME. */
 static void
-rename_var (struct dictionary *d, struct variable *v, const char *new_name) 
+rename_var (struct dictionary *d, struct variable *v, const char *new_name)
 {
   struct vardict_info vdi;
 
@@ -613,10 +713,11 @@ dict_rename_var (struct dictionary *d, struct variable *v,
   rename_var (d, v, new_name);
   hsh_force_insert (d->name_tab, v);
 
-  if (get_algorithm () == ENHANCED)
-    var_clear_short_name (v);
+  if (settings_get_algorithm () == ENHANCED)
+    var_clear_short_names (v);
 
-  if ( d->callbacks && d->callbacks->var_changed )
+  if ( d->changed ) d->changed (d, d->changed_data);
+  if ( d->callbacks &&  d->callbacks->var_changed )
     d->callbacks->var_changed (d, var_get_dict_index (v), d->cb_data);
 }
 
@@ -629,7 +730,7 @@ dict_rename_var (struct dictionary *d, struct variable *v,
 bool
 dict_rename_vars (struct dictionary *d,
                   struct variable **vars, char **new_names, size_t count,
-                  char **err_name) 
+                  char **err_name)
 {
   struct pool *pool;
   char **old_names;
@@ -641,12 +742,12 @@ dict_rename_vars (struct dictionary *d,
   /* Save the names of the variables to be renamed. */
   pool = pool_create ();
   old_names = pool_nalloc (pool, count, sizeof *old_names);
-  for (i = 0; i < count; i++) 
+  for (i = 0; i < count; i++)
     old_names[i] = pool_strdup (pool, var_get_name (vars[i]));
-  
+
   /* Remove the variables to be renamed from the name hash,
      and rename them. */
-  for (i = 0; i < count; i++) 
+  for (i = 0; i < count; i++)
     {
       hsh_force_delete (d->name_tab, vars[i]);
       rename_var (d, vars[i], new_names[i]);
@@ -661,12 +762,12 @@ dict_rename_vars (struct dictionary *d,
            Back out all the name changes that have already
            taken place, and indicate failure. */
         size_t fail_idx = i;
-        if (err_name != NULL) 
+        if (err_name != NULL)
           *err_name = new_names[i];
 
         for (i = 0; i < fail_idx; i++)
           hsh_force_delete (d->name_tab, vars[i]);
-          
+
         for (i = 0; i < count; i++)
           {
             rename_var (d, vars[i], old_names[i]);
@@ -678,32 +779,150 @@ dict_rename_vars (struct dictionary *d,
       }
 
   /* Clear short names. */
-  if (get_algorithm () == ENHANCED)
+  if (settings_get_algorithm () == ENHANCED)
     for (i = 0; i < count; i++)
-      var_clear_short_name (vars[i]);
+      var_clear_short_names (vars[i]);
 
   pool_destroy (pool);
   return true;
 }
 
+/* Returns true if a variable named NAME may be inserted in DICT;
+   that is, if there is not already a variable with that name in
+   DICT and if NAME is not a reserved word.  (The caller's checks
+   have already verified that NAME is otherwise acceptable as a
+   variable name.) */
+static bool
+var_name_is_insertable (const struct dictionary *dict, const char *name)
+{
+  return (dict_lookup_var (dict, name) == NULL
+          && lex_id_to_token (ss_cstr (name)) == T_ID);
+}
+
+static bool
+make_hinted_name (const struct dictionary *dict, const char *hint,
+                  char name[VAR_NAME_LEN + 1])
+{
+  bool dropped = false;
+  char *cp;
+
+  for (cp = name; *hint && cp < name + VAR_NAME_LEN; hint++)
+    {
+      if (cp == name
+          ? lex_is_id1 (*hint) && *hint != '$'
+          : lex_is_idn (*hint))
+        {
+          if (dropped)
+            {
+              *cp++ = '_';
+              dropped = false;
+            }
+          if (cp < name + VAR_NAME_LEN)
+            *cp++ = *hint;
+        }
+      else if (cp > name)
+        dropped = true;
+    }
+  *cp = '\0';
+
+  if (name[0] != '\0')
+    {
+      size_t len = strlen (name);
+      unsigned long int i;
+
+      if (var_name_is_insertable (dict, name))
+        return true;
+
+      for (i = 0; i < ULONG_MAX; i++)
+        {
+          char suffix[INT_BUFSIZE_BOUND (i) + 1];
+          int ofs;
+
+          suffix[0] = '_';
+          if (!str_format_26adic (i + 1, &suffix[1], sizeof suffix - 1))
+            NOT_REACHED ();
+
+          ofs = MIN (VAR_NAME_LEN - strlen (suffix), len);
+          strcpy (&name[ofs], suffix);
+
+          if (var_name_is_insertable (dict, name))
+            return true;
+        }
+    }
+
+  return false;
+}
+
+static bool
+make_numeric_name (const struct dictionary *dict, unsigned long int *num_start,
+                   char name[VAR_NAME_LEN + 1])
+{
+  unsigned long int number;
+
+  for (number = num_start != NULL ? MAX (*num_start, 1) : 1;
+       number < ULONG_MAX;
+       number++)
+    {
+      sprintf (name, "VAR%03lu", number);
+      if (dict_lookup_var (dict, name) == NULL)
+        {
+          if (num_start != NULL)
+            *num_start = number + 1;
+          return true;
+        }
+    }
+
+  if (num_start != NULL)
+    *num_start = ULONG_MAX;
+  return false;
+}
+
+
+/* Attempts to devise a variable name unique within DICT.
+   Returns true if successful, in which case the new variable
+   name is stored into NAME.  Returns false if all names that can
+   be generated have already been taken.  (Returning false is
+   quite unlikely: at least ULONG_MAX unique names can be
+   generated.)
+
+   HINT, if it is non-null, is used as a suggestion that will be
+   modified for suitability as a variable name and for
+   uniqueness.
+
+   If HINT is null or entirely unsuitable, a name in the form
+   "VAR%03d" will be generated, where the smallest unused integer
+   value is used.  If NUM_START is non-null, then its value is
+   used as the minimum numeric value to check, and it is updated
+   to the next value to be checked.
+   */
+bool
+dict_make_unique_var_name (const struct dictionary *dict, const char *hint,
+                           unsigned long int *num_start,
+                           char name[VAR_NAME_LEN + 1])
+{
+  return ((hint != NULL && make_hinted_name (dict, hint, name))
+          || make_numeric_name (dict, num_start, name));
+}
+
 /* Returns the weighting variable in dictionary D, or a null
    pointer if the dictionary is unweighted. */
 struct variable *
-dict_get_weight (const struct dictionary *d) 
+dict_get_weight (const struct dictionary *d)
 {
   assert (d != NULL);
   assert (d->weight == NULL || dict_contains_var (d, d->weight));
-  
+
   return d->weight;
 }
 
-/* Returns the value of D's weighting variable in case C, except that a
-   negative weight is returned as 0.  Returns 1 if the dictionary is
-   unweighted. Will warn about missing, negative, or zero values if
-   warn_on_invalid is true. The function will set warn_on_invalid to false
-   if an invalid weight is found. */
+/* Returns the value of D's weighting variable in case C, except
+   that a negative weight is returned as 0.  Returns 1 if the
+   dictionary is unweighted.  Will warn about missing, negative,
+   or zero values if *WARN_ON_INVALID is true.  The function will
+   set *WARN_ON_INVALID to false if an invalid weight is
+   found. */
 double
-dict_get_case_weight (const struct dictionary *d, const struct ccase *c, 
+dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
 		      bool *warn_on_invalid)
 {
   assert (d != NULL);
@@ -711,12 +930,12 @@ dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
 
   if (d->weight == NULL)
     return 1.0;
-  else 
+  else
     {
       double w = case_num (c, d->weight);
       if (w < 0.0 || var_is_num_missing (d->weight, w, MV_ANY))
         w = 0.0;
-      if ( w == 0.0 && *warn_on_invalid ) {
+      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 "
@@ -729,23 +948,29 @@ dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
 /* Sets the weighting variable of D to V, or turning off
    weighting if V is a null pointer. */
 void
-dict_set_weight (struct dictionary *d, struct variable *v) 
+dict_set_weight (struct dictionary *d, struct variable *v)
 {
   assert (d != NULL);
   assert (v == NULL || dict_contains_var (d, v));
   assert (v == NULL || var_is_numeric (v));
 
   d->weight = v;
+
+  if (d->changed) d->changed (d, d->changed_data);
+  if ( d->callbacks &&  d->callbacks->weight_changed )
+    d->callbacks->weight_changed (d,
+				  v ? var_get_dict_index (v) : -1,
+				  d->cb_data);
 }
 
 /* Returns the filter variable in dictionary D (see cmd_filter())
    or a null pointer if the dictionary is unfiltered. */
 struct variable *
-dict_get_filter (const struct dictionary *d) 
+dict_get_filter (const struct dictionary *d)
 {
   assert (d != NULL);
   assert (d->filter == NULL || dict_contains_var (d, d->filter));
-  
+
   return d->filter;
 }
 
@@ -756,14 +981,21 @@ dict_set_filter (struct dictionary *d, struct variable *v)
 {
   assert (d != NULL);
   assert (v == NULL || dict_contains_var (d, v));
+  assert (v == NULL || var_is_numeric (v));
 
   d->filter = v;
+
+  if (d->changed) d->changed (d, d->changed_data);
+  if ( d->callbacks && d->callbacks->filter_changed )
+    d->callbacks->filter_changed (d,
+				  v ? var_get_dict_index (v) : -1,
+				  d->cb_data);
 }
 
 /* Returns the case limit for dictionary D, or zero if the number
    of cases is unlimited. */
-size_t
-dict_get_case_limit (const struct dictionary *d) 
+casenumber
+dict_get_case_limit (const struct dictionary *d)
 {
   assert (d != NULL);
 
@@ -773,18 +1005,37 @@ dict_get_case_limit (const struct dictionary *d)
 /* Sets CASE_LIMIT as the case limit for dictionary D.  Use
    0 for CASE_LIMIT to indicate no limit. */
 void
-dict_set_case_limit (struct dictionary *d, size_t case_limit) 
+dict_set_case_limit (struct dictionary *d, casenumber case_limit)
 {
   assert (d != NULL);
 
   d->case_limit = case_limit;
 }
 
+/* Returns the prototype used for cases created by dictionary D. */
+const struct caseproto *
+dict_get_proto (const struct dictionary *d_)
+{
+  struct dictionary *d = (struct dictionary *) d_;
+  if (d->proto == NULL)
+    {
+      size_t i;
+
+      d->proto = caseproto_create ();
+      d->proto = caseproto_reserve (d->proto, d->var_cnt);
+      for (i = 0; i < d->var_cnt; i++)
+        d->proto = caseproto_set_width (d->proto,
+                                        var_get_case_index (d->var[i]),
+                                        var_get_width (d->var[i]));
+    }
+  return d->proto;
+}
+
 /* Returns the case index of the next value to be added to D.
    This value is the number of `union value's that need to be
    allocated to store a case for dictionary D. */
 int
-dict_get_next_value_idx (const struct dictionary *d) 
+dict_get_next_value_idx (const struct dictionary *d)
 {
   assert (d != NULL);
 
@@ -794,232 +1045,130 @@ dict_get_next_value_idx (const struct dictionary *d)
 /* Returns the number of bytes needed to store a case for
    dictionary D. */
 size_t
-dict_get_case_size (const struct dictionary *d) 
+dict_get_case_size (const struct dictionary *d)
 {
   assert (d != NULL);
 
   return sizeof (union value) * dict_get_next_value_idx (d);
 }
 
-/* Deletes scratch variables in dictionary D and reassigns values
-   so that fragmentation is eliminated. */
+/* Reassigns values in dictionary D so that fragmentation is
+   eliminated. */
 void
-dict_compact_values (struct dictionary *d) 
+dict_compact_values (struct dictionary *d)
 {
   size_t i;
 
   d->next_value_idx = 0;
-  for (i = 0; i < d->var_cnt; )
+  for (i = 0; i < d->var_cnt; i++)
     {
       struct variable *v = d->var[i];
-
-      if (dict_class_from_id (var_get_name (v)) != DC_SCRATCH) 
-        {
-          set_var_case_index (v, d->next_value_idx);
-          d->next_value_idx += var_get_value_cnt (v);
-          i++;
-        }
-      else
-        dict_delete_var (d, v);
+      set_var_case_index (v, d->next_value_idx++);
     }
+  invalidate_proto (d);
 }
 
-/* Returns the number of values that would be used by a case if
-   dict_compact_values() were called. */
+/* Returns the number of values occupied by the variables in
+   dictionary D.  All variables are considered if EXCLUDE_CLASSES
+   is 0, or it may contain one or more of (1u << DC_ORDINARY),
+   (1u << DC_SYSTEM), or (1u << DC_SCRATCH) to exclude the
+   corresponding type of variable.
+
+   The return value may be less than the number of values in one
+   of dictionary D's cases (as returned by
+   dict_get_next_value_idx) even if E is 0, because there may be
+   gaps in D's cases due to deleted variables. */
 size_t
-dict_get_compacted_value_cnt (const struct dictionary *d) 
+dict_count_values (const struct dictionary *d, unsigned int exclude_classes)
 {
   size_t i;
   size_t cnt;
 
-  cnt = 0;
-  for (i = 0; i < d->var_cnt; i++)
-    if (dict_class_from_id (var_get_name (d->var[i])) != DC_SCRATCH) 
-      cnt += var_get_value_cnt (d->var[i]);
-  return cnt;
-}
+  assert ((exclude_classes & ~((1u << DC_ORDINARY)
+                               | (1u << DC_SYSTEM)
+                               | (1u << DC_SCRATCH))) == 0);
 
-/* Creates and returns an array mapping from a dictionary index
-   to the case index that the corresponding variable will have
-   after calling dict_compact_values().  Scratch variables
-   receive -1 for case index because dict_compact_values() will
-   delete them. */
-int *
-dict_get_compacted_dict_index_to_case_index (const struct dictionary *d) 
-{
-  size_t i;
-  size_t next_value_idx;
-  int *map;
-  
-  map = xnmalloc (d->var_cnt, sizeof *map);
-  next_value_idx = 0;
+  cnt = 0;
   for (i = 0; i < d->var_cnt; i++)
     {
-      struct variable *v = d->var[i];
-
-      if (dict_class_from_id (var_get_name (v)) != DC_SCRATCH) 
-        {
-          map[i] = next_value_idx;
-          next_value_idx += var_get_value_cnt (v);
-        }
-      else 
-        map[i] = -1;
-    }
-  return map;
-}
-
-/* Returns true if a case for dictionary D would be smaller after
-   compacting, false otherwise.  Compacting a case eliminates
-   "holes" between values and after the last value.  Holes are
-   created by deleting variables (or by scratch variables).
-
-   The return value may differ from whether compacting a case
-   from dictionary D would *change* the case: compacting could
-   rearrange values even if it didn't reduce space
-   requirements. */
-bool
-dict_compacting_would_shrink (const struct dictionary *d) 
-{
-  return dict_get_compacted_value_cnt (d) < dict_get_next_value_idx (d);
-}
-
-/* Returns true if a case for dictionary D would change after
-   compacting, false otherwise.  Compacting a case eliminates
-   "holes" between values and after the last value.  Holes are
-   created by deleting variables (or by scratch variables).
-
-   The return value may differ from whether compacting a case
-   from dictionary D would *shrink* the case: compacting could
-   rearrange values without reducing space requirements. */
-bool
-dict_compacting_would_change (const struct dictionary *d) 
-{
-  size_t case_idx;
-  size_t i;
-
-  case_idx = 0;
-  for (i = 0; i < dict_get_var_cnt (d); i++) 
-    {
-      struct variable *v = dict_get_var (d, i);
-      if (var_get_case_index (v) != case_idx)
-        return true;
-      case_idx += var_get_value_cnt (v);
+      enum dict_class class = var_get_dict_class (d->var[i]);
+      if (!(exclude_classes & (1u << class)))
+        cnt++;
     }
-  return false;
+  return cnt;
 }
-
-/* How to copy a contiguous range of values between cases. */
-struct copy_map
-  {
-    size_t src_idx;             /* Starting value index in source case. */
-    size_t dst_idx;             /* Starting value index in target case. */
-    size_t cnt;                 /* Number of values. */
-  };
-
-/* How to compact a case. */
-struct dict_compactor 
-  {
-    struct copy_map *maps;      /* Array of mappings. */
-    size_t map_cnt;             /* Number of mappings. */
-  };
 
-/* Creates and returns a dict_compactor that can be used to
-   compact cases for dictionary D.
+/* Returns the case prototype that would result after deleting
+   all variables from D that are not in one of the
+   EXCLUDE_CLASSES and compacting the dictionary with
+   dict_compact().
 
-   Compacting a case eliminates "holes" between values and after
-   the last value.  Holes are created by deleting variables (or
-   by scratch variables). */
-struct dict_compactor *
-dict_make_compactor (const struct dictionary *d)
+   The caller must unref the returned caseproto when it is no
+   longer needed. */
+struct caseproto *
+dict_get_compacted_proto (const struct dictionary *d,
+                          unsigned int exclude_classes)
 {
-  struct dict_compactor *compactor;
-  struct copy_map *map;
-  size_t map_allocated;
-  size_t value_idx;
+  struct caseproto *proto;
   size_t i;
 
-  compactor = xmalloc (sizeof *compactor);
-  compactor->maps = NULL;
-  compactor->map_cnt = 0;
-  map_allocated = 0;
+  assert ((exclude_classes & ~((1u << DC_ORDINARY)
+                               | (1u << DC_SYSTEM)
+                               | (1u << DC_SCRATCH))) == 0);
 
-  value_idx = 0;
-  map = NULL;
-  for (i = 0; i < d->var_cnt; i++) 
+  proto = caseproto_create ();
+  for (i = 0; i < d->var_cnt; i++)
     {
       struct variable *v = d->var[i];
-
-      if (dict_class_from_id (var_get_name (v)) == DC_SCRATCH)
-        continue;
-      if (map != NULL && map->src_idx + map->cnt == var_get_case_index (v)) 
-        map->cnt += var_get_value_cnt (v);
-      else 
-        {
-          if (compactor->map_cnt == map_allocated)
-            compactor->maps = x2nrealloc (compactor->maps, &map_allocated,
-                                          sizeof *compactor->maps);
-          map = &compactor->maps[compactor->map_cnt++];
-          map->src_idx = var_get_case_index (v);
-          map->dst_idx = value_idx;
-          map->cnt = var_get_value_cnt (v);
-        }
-      value_idx += var_get_value_cnt (v);
-    }
-
-  return compactor;
-}
-
-/* Compacts SRC by copying it to DST according to the scheme in
-   COMPACTOR.
-
-   Compacting a case eliminates "holes" between values and after
-   the last value.  Holes are created by deleting variables (or
-   by scratch variables). */
-void
-dict_compactor_compact (const struct dict_compactor *compactor,
-                        struct ccase *dst, const struct ccase *src) 
-{
-  size_t i;
-
-  for (i = 0; i < compactor->map_cnt; i++) 
-    {
-      const struct copy_map *map = &compactor->maps[i];
-      case_copy (dst, map->dst_idx, src, map->src_idx, map->cnt);
+      if (!(exclude_classes & (1u << var_get_dict_class (v))))
+        proto = caseproto_add_width (proto, var_get_width (v));
     }
+  return proto;
 }
-
-/* Destroys COMPACTOR. */
-void
-dict_compactor_destroy (struct dict_compactor *compactor) 
-{
-  if (compactor != NULL) 
-    {
-      free (compactor->maps);
-      free (compactor);
-    }
-}
-
+
 /* Returns the SPLIT FILE vars (see cmd_split_file()).  Call
    dict_get_split_cnt() to determine how many SPLIT FILE vars
    there are.  Returns a null pointer if and only if there are no
    SPLIT FILE vars. */
-struct variable *const *
-dict_get_split_vars (const struct dictionary *d) 
+const struct variable *const *
+dict_get_split_vars (const struct dictionary *d)
 {
   assert (d != NULL);
-  
+
   return d->split;
 }
 
 /* Returns the number of SPLIT FILE vars. */
 size_t
-dict_get_split_cnt (const struct dictionary *d) 
+dict_get_split_cnt (const struct dictionary *d)
 {
   assert (d != NULL);
 
   return d->split_cnt;
 }
 
+/* Removes variable V, which must be in D, from D's set of split
+   variables. */
+void
+dict_unset_split_var (struct dictionary *d, struct variable *v)
+{
+  int orig_count;
+
+  assert (dict_contains_var (d, v));
+
+  orig_count = d->split_cnt;
+  d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split,
+                               &v, compare_var_ptrs, NULL);
+  if (orig_count != d->split_cnt)
+    {
+      if (d->changed) d->changed (d, d->changed_data);
+      /* We changed the set of split variables so invoke the
+         callback. */
+      if (d->callbacks &&  d->callbacks->split_changed)
+        d->callbacks->split_changed (d, d->cb_data);
+    }
+}
+
 /* Sets CNT split vars SPLIT in dictionary D. */
 void
 dict_set_split_vars (struct dictionary *d,
@@ -1029,14 +1178,26 @@ dict_set_split_vars (struct dictionary *d,
   assert (cnt == 0 || split != NULL);
 
   d->split_cnt = cnt;
-  d->split = xnrealloc (d->split, cnt, sizeof *d->split);
-  memcpy (d->split, split, cnt * sizeof *d->split);
+  if ( cnt > 0 )
+   {
+    d->split = xnrealloc (d->split, cnt, sizeof *d->split) ;
+    memcpy (d->split, split, cnt * sizeof *d->split);
+   }
+  else
+   {
+    free (d->split);
+    d->split = NULL;
+   }
+
+  if (d->changed) d->changed (d, d->changed_data);
+  if ( d->callbacks &&  d->callbacks->split_changed )
+    d->callbacks->split_changed (d, d->cb_data);
 }
 
 /* Returns the file label for D, or a null pointer if D is
    unlabeled (see cmd_file_label()). */
 const char *
-dict_get_label (const struct dictionary *d) 
+dict_get_label (const struct dictionary *d)
 {
   assert (d != NULL);
 
@@ -1046,45 +1207,82 @@ dict_get_label (const struct dictionary *d)
 /* Sets D's file label to LABEL, truncating it to a maximum of 60
    characters. */
 void
-dict_set_label (struct dictionary *d, const char *label) 
+dict_set_label (struct dictionary *d, const char *label)
 {
   assert (d != NULL);
 
   free (d->label);
-  if (label == NULL)
-    d->label = NULL;
-  else if (strlen (label) < 60)
-    d->label = xstrdup (label);
-  else 
-    {
-      d->label = xmalloc (61);
-      memcpy (d->label, label, 60);
-      d->label[60] = '\0';
-    }
+  d->label = label != NULL ? xstrndup (label, 60) : NULL;
 }
 
 /* Returns the documents for D, or a null pointer if D has no
-   documents (see cmd_document()).. */
+   documents.  If the return value is nonnull, then the string
+   will be an exact multiple of DOC_LINE_LENGTH bytes in length,
+   with each segment corresponding to one line. */
 const char *
-dict_get_documents (const struct dictionary *d) 
+dict_get_documents (const struct dictionary *d)
 {
-  assert (d != NULL);
-
-  return d->documents;
+  return ds_is_empty (&d->documents) ? NULL : ds_cstr (&d->documents);
 }
 
 /* Sets the documents for D to DOCUMENTS, or removes D's
-   documents if DOCUMENT is a null pointer. */
+   documents if DOCUMENT is a null pointer.  If DOCUMENTS is
+   nonnull, then it should be an exact multiple of
+   DOC_LINE_LENGTH bytes in length, with each segment
+   corresponding to one line. */
 void
 dict_set_documents (struct dictionary *d, const char *documents)
 {
-  assert (d != NULL);
+  size_t remainder;
 
-  free (d->documents);
-  if (documents == NULL)
-    d->documents = NULL;
-  else
-    d->documents = xstrdup (documents);
+  ds_assign_cstr (&d->documents, documents != NULL ? documents : "");
+
+  /* In case the caller didn't get it quite right, pad out the
+     final line with spaces. */
+  remainder = ds_length (&d->documents) % DOC_LINE_LENGTH;
+  if (remainder != 0)
+    ds_put_char_multiple (&d->documents, ' ', DOC_LINE_LENGTH - remainder);
+}
+
+/* Drops the documents from dictionary D. */
+void
+dict_clear_documents (struct dictionary *d)
+{
+  ds_clear (&d->documents);
+}
+
+/* Appends LINE to the documents in D.  LINE will be truncated or
+   padded on the right with spaces to make it exactly
+   DOC_LINE_LENGTH bytes long. */
+void
+dict_add_document_line (struct dictionary *d, const char *line)
+{
+  if (strlen (line) > DOC_LINE_LENGTH)
+    {
+      /* Note to translators: "bytes" is correct, not characters */
+      msg (SW, _("Truncating document line to %d bytes."), DOC_LINE_LENGTH);
+    }
+  buf_copy_str_rpad (ds_put_uninit (&d->documents, DOC_LINE_LENGTH),
+                     DOC_LINE_LENGTH, line, ' ');
+}
+
+/* Returns the number of document lines in dictionary D. */
+size_t
+dict_get_document_line_cnt (const struct dictionary *d)
+{
+  return ds_length (&d->documents) / DOC_LINE_LENGTH;
+}
+
+/* Copies document line number IDX from dictionary D into
+   LINE, trimming off any trailing white space. */
+void
+dict_get_document_line (const struct dictionary *d,
+                        size_t idx, struct string *line)
+{
+  assert (idx < dict_get_document_line_cnt (d));
+  ds_assign_substring (line, ds_substr (&d->documents, idx * DOC_LINE_LENGTH,
+                                        DOC_LINE_LENGTH));
+  ds_rtrim (line, ss_cstr (CC_SPACES));
 }
 
 /* Creates in D a vector named NAME that contains the CNT
@@ -1093,7 +1291,7 @@ dict_set_documents (struct dictionary *d, const char *documents)
 bool
 dict_create_vector (struct dictionary *d,
                     const char *name,
-                    struct variable **var, size_t cnt) 
+                    struct variable **var, size_t cnt)
 {
   size_t i;
 
@@ -1101,21 +1299,33 @@ dict_create_vector (struct dictionary *d,
   assert (cnt > 0);
   for (i = 0; i < cnt; i++)
     assert (dict_contains_var (d, var[i]));
-  
+
   if (dict_lookup_vector (d, name) == NULL)
     {
       d->vector = xnrealloc (d->vector, d->vector_cnt + 1, sizeof *d->vector);
       d->vector[d->vector_cnt++] = vector_create (name, var, cnt);
-      return true; 
+      return true;
     }
   else
     return false;
 }
 
+/* Creates in D a vector named NAME that contains the CNT
+   variables in VAR.  A vector named NAME must not already exist
+   in D. */
+void
+dict_create_vector_assert (struct dictionary *d,
+                           const char *name,
+                           struct variable **var, size_t cnt)
+{
+  assert (dict_lookup_vector (d, name) == NULL);
+  dict_create_vector (d, name, var, cnt);
+}
+
 /* Returns the vector in D with index IDX, which must be less
    than dict_get_vector_cnt (D). */
 const struct vector *
-dict_get_vector (const struct dictionary *d, size_t idx) 
+dict_get_vector (const struct dictionary *d, size_t idx)
 {
   assert (d != NULL);
   assert (idx < d->vector_cnt);
@@ -1125,7 +1335,7 @@ dict_get_vector (const struct dictionary *d, size_t idx)
 
 /* Returns the number of vectors in D. */
 size_t
-dict_get_vector_cnt (const struct dictionary *d) 
+dict_get_vector_cnt (const struct dictionary *d)
 {
   assert (d != NULL);
 
@@ -1135,7 +1345,7 @@ dict_get_vector_cnt (const struct dictionary *d)
 /* Looks up and returns the vector within D with the given
    NAME. */
 const struct vector *
-dict_lookup_vector (const struct dictionary *d, const char *name) 
+dict_lookup_vector (const struct dictionary *d, const char *name)
 {
   size_t i;
   for (i = 0; i < d->vector_cnt; i++)
@@ -1146,10 +1356,10 @@ dict_lookup_vector (const struct dictionary *d, const char *name)
 
 /* Deletes all vectors from D. */
 void
-dict_clear_vectors (struct dictionary *d) 
+dict_clear_vectors (struct dictionary *d)
 {
   size_t i;
-  
+
   for (i = 0; i < d->vector_cnt; i++)
     vector_destroy (d->vector[i]);
   free (d->vector);
@@ -1158,137 +1368,77 @@ dict_clear_vectors (struct dictionary *d)
   d->vector_cnt = 0;
 }
 
-/* Compares two strings. */
-static int
-compare_strings (const void *a, const void *b, const void *aux UNUSED) 
+/* Returns D's attribute set.  The caller may examine or modify
+   the attribute set, but must not destroy it.  Destroying D or
+   calling dict_set_attributes for D will also destroy D's
+   attribute set. */
+struct attrset *
+dict_get_attributes (const struct dictionary *d) 
 {
-  return strcmp (a, b);
+  return (struct attrset *) &d->attributes;
 }
 
-/* Hashes a string. */
-static unsigned
-hash_string (const void *s, const void *aux UNUSED) 
+/* Replaces D's attributes set by a copy of ATTRS. */
+void
+dict_set_attributes (struct dictionary *d, const struct attrset *attrs)
 {
-  return hsh_hash_string (s);
+  attrset_destroy (&d->attributes);
+  attrset_clone (&d->attributes, attrs);
 }
 
-
-/* Sets V's short name to BASE, followed by a suffix of the form
-   _A, _B, _C, ..., _AA, _AB, etc. according to the value of
-   SUFFIX_NUMBER.  Truncates BASE as necessary to fit. */
-static void
-set_var_short_name_suffix (struct variable *v, const char *base,
-                           int suffix_number)
+/* Returns true if D has at least one attribute in its attribute
+   set, false if D's attribute set is empty. */
+bool
+dict_has_attributes (const struct dictionary *d) 
 {
-  char suffix[SHORT_NAME_LEN + 1];
-  char short_name[SHORT_NAME_LEN + 1];
-  char *start, *end;
-  int len, ofs;
+  return attrset_count (&d->attributes) > 0;
+}
 
-  assert (v != NULL);
-  assert (suffix_number >= 0);
+/* Called from variable.c to notify the dictionary that some property of
+   the variable has changed */
+void
+dict_var_changed (const struct variable *v)
+{
+  if ( var_has_vardict (v))
+    {
+      const struct vardict_info *vdi = var_get_vardict (v);
+      struct dictionary *d = vdi->dict;
 
-  /* Set base name. */
-  var_set_short_name (v, base);
+      if ( NULL == d)
+	return;
 
-  /* Compose suffix. */
-  start = end = suffix + sizeof suffix - 1;
-  *end = '\0';
-  do 
-    {
-      *--start = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[suffix_number % 26];
-      if (start <= suffix + 1)
-        msg (SE, _("Variable suffix too large."));
-      suffix_number /= 26;
+      if (d->changed ) d->changed (d, d->changed_data);
+      if ( d->callbacks && d->callbacks->var_changed )
+	d->callbacks->var_changed (d, var_get_dict_index (v), d->cb_data);
     }
-  while (suffix_number > 0);
-  *--start = '_';
-
-  /* Append suffix to V's short name. */
-  str_copy_trunc (short_name, sizeof short_name, base);
-  len = end - start;
-  if (len + strlen (short_name) > SHORT_NAME_LEN)
-    ofs = SHORT_NAME_LEN - len;
-  else
-    ofs = strlen (short_name);
-  strcpy (short_name + ofs, start);
-
-  /* Set name. */
-  var_set_short_name (v, short_name);
 }
 
-/* Assigns a valid, unique short_name[] to each variable in D.
-   Each variable whose actual name is short has highest priority
-   for that short name.  Otherwise, variables with an existing
-   short_name[] have the next highest priority for a given short
-   name; if it is already taken, then the variable is treated as
-   if short_name[] had been empty.  Otherwise, long names are
-   truncated to form short names.  If that causes conflicts,
-   variables are renamed as PREFIX_A, PREFIX_B, and so on. */
+
+/* Called from variable.c to notify the dictionary that the variable's width
+   has changed */
 void
-dict_assign_short_names (struct dictionary *d) 
+dict_var_resized (const struct variable *v, int old_width)
 {
-  struct hsh_table *short_names;
-  size_t i;
-
-  /* Give variables whose names are short the corresponding short
-     names, and clear short_names[] that conflict with a variable
-     name. */
-  for (i = 0; i < d->var_cnt; i++)
+  if ( var_has_vardict (v))
     {
-      struct variable *v = d->var[i];
-      const char *short_name = var_get_short_name (v);
-      if (strlen (var_get_name (v)) <= SHORT_NAME_LEN)
-        var_set_short_name (v, var_get_name (v));
-      else if (short_name != NULL && dict_lookup_var (d, short_name) != NULL)
-        var_clear_short_name (v);
-    }
+      const struct vardict_info *vdi = var_get_vardict (v);
+      struct dictionary *d;
 
-  /* Each variable with an assigned short_name[] now gets it
-     unless there is a conflict. */
-  short_names = hsh_create (d->var_cnt, compare_strings, hash_string,
-                            NULL, NULL);
-  for (i = 0; i < d->var_cnt; i++)
-    {
-      struct variable *v = d->var[i];
-      const char *name = var_get_short_name (v);
-      if (name != NULL && hsh_insert (short_names, (char *) name) != NULL)
-        var_clear_short_name (v);
-    }
-  
-  /* Now assign short names to remaining variables. */
-  for (i = 0; i < d->var_cnt; i++)
-    {
-      struct variable *v = d->var[i];
-      const char *name = var_get_short_name (v);
-      if (name == NULL) 
-        {
-          /* Form initial short_name from the variable name, then
-             try _A, _B, ... _AA, _AB, etc., if needed.*/
-          int trial = 0;
-          do
-            {
-              if (trial == 0)
-                var_set_short_name (v, var_get_name (v));
-              else
-                set_var_short_name_suffix (v, var_get_name (v), trial - 1);
+      d = vdi->dict;
 
-              trial++;
-            }
-          while (hsh_insert (short_names, (char *) var_get_short_name (v))
-                 != NULL);
-        } 
-    }
+      if (d->changed) d->changed (d, d->changed_data);
 
-  /* Get rid of hash table. */
-  hsh_destroy (short_names);
+      invalidate_proto (d);
+      if ( d->callbacks && d->callbacks->var_resized )
+	d->callbacks->var_resized (d, var_get_dict_index (v), old_width,
+                                   d->cb_data);
+    }
 }
 
-
-/* Called from variable.c to notify the dictionary that some property of 
-   the variable has changed */
+/* Called from variable.c to notify the dictionary that the variable's display width
+   has changed */
 void
-dict_var_changed (const struct variable *v)
+dict_var_display_width_changed (const struct variable *v)
 {
   if ( var_has_vardict (v))
     {
@@ -1297,7 +1447,9 @@ dict_var_changed (const struct variable *v)
 
       d = vdi->dict;
 
-      if ( d->callbacks && d->callbacks->var_changed )
-	d->callbacks->var_changed (d, var_get_dict_index (v), d->cb_data);
+      if (d->changed) d->changed (d, d->changed_data);
+      if ( d->callbacks && d->callbacks->var_display_width_changed )
+	d->callbacks->var_display_width_changed (d, var_get_dict_index (v), d->cb_data);
     }
 }
+