X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fdictionary.c;h=467f347efd9f5a5e290435265cbd1077032bfb0b;hb=d8fdf0b4fa919e48397b438e9453d6b82215ff51;hp=02c6aa76bc5c991a2bc077ed9bc91a3e60972eea;hpb=38c2638eed90f33225870563c4be183097e4155a;p=pspp-builds.git

diff --git a/src/data/dictionary.c b/src/data/dictionary.c
index 02c6aa76..467f347e 100644
--- a/src/data/dictionary.c
+++ b/src/data/dictionary.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 1997-9, 2000, 2006, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1997-9, 2000, 2006, 2007, 2009, 2010, 2011 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
@@ -16,32 +16,34 @@
 
 #include <config.h>
 
-#include "dictionary.h"
+#include "data/dictionary.h"
 
+#include <stdint.h>
 #include <stdlib.h>
 #include <ctype.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>
-#include <libpspp/misc.h>
-#include <libpspp/pool.h>
-#include <libpspp/str.h>
-
-#include "intprops.h"
-#include "minmax.h"
-#include "xalloc.h"
+#include "data/attributes.h"
+#include "data/case.h"
+#include "data/identifier.h"
+#include "data/mrset.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-functions.h"
+#include "libpspp/hmap.h"
+#include "libpspp/message.h"
+#include "libpspp/misc.h"
+#include "libpspp/pool.h"
+#include "libpspp/str.h"
+
+#include "gl/intprops.h"
+#include "gl/minmax.h"
+#include "gl/xalloc.h"
 
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
@@ -49,9 +51,11 @@
 /* A dictionary. */
 struct dictionary
   {
-    struct variable **var;	/* Variables. */
+    struct vardict_info *var;	/* Variables. */
     size_t var_cnt, var_cap;    /* Number of variables, capacity. */
-    struct hsh_table *name_tab;	/* Variable index by name. */
+    struct caseproto *proto;    /* Prototype for dictionary cases
+                                   (updated lazily). */
+    struct hmap name_map;	/* Variable index by name. */
     int next_value_idx;         /* Index of next `union value' to allocate. */
     const struct variable **split;    /* SPLIT FILE vars. */
     size_t split_cnt;           /* SPLIT FILE count. */
@@ -63,11 +67,57 @@ struct dictionary
     struct vector **vector;     /* Vectors of variables. */
     size_t vector_cnt;          /* Number of vectors. */
     struct attrset attributes;  /* Custom attributes. */
+    struct mrset **mrsets;      /* Multiple response sets. */
+    size_t n_mrsets;            /* Number of multiple response sets. */
+
+    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;
   };
 
+static void dict_unset_split_var (struct dictionary *, struct variable *);
+static void dict_unset_mrset_var (struct dictionary *, struct variable *);
+
+void
+dict_set_encoding (struct dictionary *d, const char *enc)
+{
+  if (enc)
+    {
+      free (d->encoding);
+      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
@@ -76,9 +126,8 @@ 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",
+      const struct variable *v = d->var[i].var;
+      printf ("Name: %s;\tdict_idx: %zu; case_idx: %zu\n",
 	      var_get_name (v),
 	      var_get_dict_index (v),
 	      var_get_case_index (v));
@@ -115,8 +164,7 @@ dict_create (void)
 {
   struct dictionary *d = xzalloc (sizeof *d);
 
-  d->name_tab = hsh_create (8, compare_vars_by_name, hash_var_by_name,
-                            NULL, NULL);
+  hmap_init (&d->name_map);
   attrset_init (&d->attributes);
   return d;
 }
@@ -135,25 +183,18 @@ dict_clone (const struct dictionary *s)
   struct dictionary *d;
   size_t i;
 
-  assert (s != NULL);
-
   d = dict_create ();
 
   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));
+      struct variable *sv = s->var[i].var;
+      struct variable *dv = dict_clone_var_assert (d, 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);
+      var_get_vardict (dv)->case_index = var_get_vardict (sv)->case_index;
     }
 
   d->next_value_idx = s->next_value_idx;
@@ -181,8 +222,25 @@ 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));
 
+  for (i = 0; i < s->n_mrsets; i++)
+    {
+      const struct mrset *old = s->mrsets[i];
+      struct mrset *new;
+      size_t j;
+
+      /* Clone old mrset, then replace vars from D by vars from S. */
+      new = mrset_clone (old);
+      for (j = 0; j < new->n_vars; j++)
+        new->vars[j] = dict_lookup_var_assert (d, var_get_name (new->vars[j]));
+
+      dict_add_mrset (d, new);
+    }
+
   return d;
 }
 
@@ -193,17 +251,16 @@ dict_clear (struct dictionary *d)
 {
   /* FIXME?  Should we really clear case_limit, label, documents?
      Others are necessarily cleared by deleting all the variables.*/
-  assert (d != NULL);
-
   while (d->var_cnt > 0 )
     {
-      dict_delete_var (d, d->var[d->var_cnt - 1]);
+      dict_delete_var (d, d->var[d->var_cnt - 1].var);
     }
 
   free (d->var);
   d->var = NULL;
   d->var_cnt = d->var_cap = 0;
-  hsh_clear (d->name_tab);
+  invalidate_proto (d);
+  hmap_clear (&d->name_map);
   d->next_value_idx = 0;
   dict_set_split_vars (d, NULL, 0);
   dict_set_weight (d, NULL);
@@ -223,10 +280,8 @@ dict_clear_aux (struct dictionary *d)
 {
   int i;
 
-  assert (d != NULL);
-
   for (i = 0; i < d->var_cnt; i++)
-    var_clear_aux (d->var[i]);
+    var_clear_aux (d->var[i].var);
 }
 
 /* Clears a dictionary and destroys it. */
@@ -240,8 +295,10 @@ dict_destroy (struct dictionary *d)
       d->callbacks  = NULL ;
 
       dict_clear (d);
-      hsh_destroy (d->name_tab);
+      hmap_destroy (&d->name_map);
       attrset_destroy (&d->attributes);
+      dict_clear_mrsets (d);
+      free (d->encoding);
       free (d);
     }
 }
@@ -250,8 +307,6 @@ dict_destroy (struct dictionary *d)
 size_t
 dict_get_var_cnt (const struct dictionary *d)
 {
-  assert (d != NULL);
-
   return d->var_cnt;
 }
 
@@ -261,10 +316,9 @@ dict_get_var_cnt (const struct dictionary *d)
 struct variable *
 dict_get_var (const struct dictionary *d, size_t idx)
 {
-  assert (d != NULL);
   assert (idx < d->var_cnt);
 
-  return d->var[idx];
+  return d->var[idx].var;
 }
 
 /* Sets *VARS to an array of pointers to variables in D and *CNT
@@ -291,15 +345,12 @@ dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars,
   size_t count;
   size_t i;
 
-  assert (d != NULL);
-  assert (vars != NULL);
-  assert (cnt != NULL);
   assert (exclude == (exclude & DC_ALL));
 
   count = 0;
   for (i = 0; i < d->var_cnt; i++)
     {
-      enum dict_class class = var_get_dict_class (d->var[i]);
+      enum dict_class class = var_get_dict_class (d->var[i].var);
       if (!(class & exclude))
         count++;
     }
@@ -308,9 +359,9 @@ dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars,
   *cnt = 0;
   for (i = 0; i < d->var_cnt; i++)
     {
-      enum dict_class class = var_get_dict_class (d->var[i]);
+      enum dict_class class = var_get_dict_class (d->var[i].var);
       if (!(class & exclude))
-        (*vars)[(*cnt)++] = d->var[i];
+        (*vars)[(*cnt)++] = d->var[i].var;
     }
   assert (*cnt == count);
 }
@@ -318,26 +369,37 @@ dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars,
 static struct variable *
 add_var (struct dictionary *d, struct variable *v)
 {
-  /* Add dictionary info to variable. */
-  struct vardict_info vdi;
-  vdi.case_index = d->next_value_idx;
-  vdi.dict_index = d->var_cnt;
-  vdi.dict = d;
-  var_set_vardict (v, &vdi);
+  struct vardict_info *vardict;
 
   /* Update dictionary. */
   if (d->var_cnt >= d->var_cap)
     {
-      d->var_cap = 8 + 2 * d->var_cap;
-      d->var = xnrealloc (d->var, d->var_cap, sizeof *d->var);
+      size_t i;
+
+      d->var = x2nrealloc (d->var, &d->var_cap, sizeof *d->var);
+      hmap_clear (&d->name_map);
+      for (i = 0; i < d->var_cnt; i++)
+        {
+          var_set_vardict (d->var[i].var, &d->var[i]);
+          hmap_insert_fast (&d->name_map, &d->var[i].name_node,
+                            d->var[i].name_node.hash);
+        }
     }
-  d->var[d->var_cnt++] = v;
-  hsh_force_insert (d->name_tab, v);
 
+  vardict = &d->var[d->var_cnt++];
+  vardict->dict = d;
+  vardict->var = v;
+  hmap_insert (&d->name_map, &vardict->name_node,
+               hash_case_string (var_get_name (v), 0));
+  vardict->case_index = d->next_value_idx;
+  var_set_vardict (v, vardict);
+
+  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;
 }
@@ -363,27 +425,46 @@ dict_create_var_assert (struct dictionary *d, const char *name, int width)
   return add_var (d, var_create (name, width));
 }
 
-/* Creates and returns a new variable in D with name NAME, as a
-   copy of existing variable OLD_VAR, which need not be in D or
-   in any dictionary.  Returns a null pointer if the given NAME
-   would duplicate that of an existing variable in the
+/* Creates and returns a new variable in D, as a copy of existing variable
+   OLD_VAR, which need not be in D or in any dictionary.  Returns a null
+   pointer if OLD_VAR's name would duplicate that of an existing variable in
+   the dictionary. */
+struct variable *
+dict_clone_var (struct dictionary *d, const struct variable *old_var)
+{
+  return dict_clone_var_as (d, old_var, var_get_name (old_var));
+}
+
+/* Creates and returns a new variable in D, as a copy of existing variable
+   OLD_VAR, which need not be in D or in any dictionary.  Assert-fails if
+   OLD_VAR's name would duplicate that of an existing variable in the
    dictionary. */
 struct variable *
-dict_clone_var (struct dictionary *d, const struct variable *old_var,
-                const char *name)
+dict_clone_var_assert (struct dictionary *d, const struct variable *old_var)
+{
+  return dict_clone_var_as_assert (d, old_var, var_get_name (old_var));
+}
+
+/* Creates and returns a new variable in D with name NAME, as a copy of
+   existing variable OLD_VAR, which need not be in D or in any dictionary.
+   Returns a null pointer if the given NAME would duplicate that of an existing
+   variable in the dictionary. */
+struct variable *
+dict_clone_var_as (struct dictionary *d, const struct variable *old_var,
+                   const char *name)
 {
   return (dict_lookup_var (d, name) == NULL
-          ? dict_clone_var_assert (d, old_var, name)
+          ? dict_clone_var_as_assert (d, old_var, name)
           : NULL);
 }
 
-/* Creates and returns a new variable in D with name NAME, as a
-   copy of existing variable OLD_VAR, which need not be in D or
-   in any dictionary.  Assert-fails if the given NAME would
-   duplicate that of an existing variable in the dictionary. */
+/* Creates and returns a new variable in D with name NAME, as a copy of
+   existing variable OLD_VAR, which need not be in D or in any dictionary.
+   Assert-fails if the given NAME would duplicate that of an existing variable
+   in the dictionary. */
 struct variable *
-dict_clone_var_assert (struct dictionary *d, const struct variable *old_var,
-                       const char *name)
+dict_clone_var_as_assert (struct dictionary *d, const struct variable *old_var,
+                          const char *name)
 {
   struct variable *new_var = var_clone (old_var);
   assert (dict_lookup_var (d, name) == NULL);
@@ -396,23 +477,17 @@ 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 ;
-  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);
+  struct vardict_info *vardict;
 
-  if ( result && var_has_vardict (result)) 
-  {
-      const struct vardict_info *vdi = var_get_vardict (result);
-      assert (vdi->dict == d);
-  }
+  HMAP_FOR_EACH_WITH_HASH (vardict, struct vardict_info, name_node,
+                           hash_case_string (name, 0), &d->name_map)
+    {
+      struct variable *var = vardict->var;
+      if (!strcasecmp (var_get_name (var), name))
+        return var;
+    }
 
-  return result;
+  return NULL;
 }
 
 /* Returns the variable named NAME in D.  Assert-fails if no
@@ -430,15 +505,8 @@ dict_lookup_var_assert (const struct dictionary *d, const char *name)
 bool
 dict_contains_var (const struct dictionary *d, const struct variable *v)
 {
-  if (var_has_vardict (v))
-    {
-      const struct vardict_info *vdi = var_get_vardict (v);
-      return (vdi->dict_index >= 0
-              && vdi->dict_index < d->var_cnt
-              && d->var[vdi->dict_index] == v);
-    }
-  else
-    return false;
+  return (var_has_vardict (v)
+          && vardict_get_dictionary (var_get_vardict (v)) == d);
 }
 
 /* Compares two double pointers to variables, which should point
@@ -452,26 +520,45 @@ compare_var_ptrs (const void *a_, const void *b_, const void *aux UNUSED)
   return *a < *b ? -1 : *a > *b;
 }
 
-/* Sets the dict_index in V's vardict to DICT_INDEX. */
 static void
-set_var_dict_index (struct variable *v, int dict_index)
+unindex_var (struct dictionary *d, struct vardict_info *vardict)
 {
-  struct vardict_info vdi = *var_get_vardict (v);
-  struct dictionary *d = vdi.dict;
-  vdi.dict_index = dict_index;
-  var_set_vardict (v, &vdi);
+  hmap_delete (&d->name_map, &vardict->name_node);
+}
 
+/* This function assumes that vardict->name_node.hash is valid, that is, that
+   its name has not changed since it was hashed (rename_var() updates this
+   hash along with the name itself). */
+static void
+reindex_var (struct dictionary *d, struct vardict_info *vardict)
+{
+  struct variable *var = vardict->var;
+
+  var_set_vardict (var, vardict);
+  hmap_insert_fast (&d->name_map, &vardict->name_node,
+                    vardict->name_node.hash);
+
+  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);
+    d->callbacks->var_changed (d, var_get_dict_index (var), d->cb_data);
 }
 
 /* Sets the case_index in V's vardict to CASE_INDEX. */
 static void
 set_var_case_index (struct variable *v, int case_index)
 {
-  struct vardict_info vdi = *var_get_vardict (v);
-  vdi.case_index = case_index;
-  var_set_vardict (v, &vdi);
+  var_get_vardict (v)->case_index = case_index;
+}
+
+/* Removes the dictionary variables with indexes from FROM to TO (exclusive)
+   from name_map. */
+static void
+unindex_vars (struct dictionary *d, size_t from, size_t to)
+{
+  size_t i;
+
+  for (i = from; i < to; i++)
+    unindex_var (d, &d->var[i]);
 }
 
 /* Re-sets the dict_index in the dictionary variables with
@@ -482,7 +569,7 @@ reindex_vars (struct dictionary *d, size_t from, size_t to)
   size_t i;
 
   for (i = from; i < to; i++)
-    set_var_dict_index (d->var[i], i);
+    reindex_var (d, &d->var[i]);
 }
 
 /* Deletes variable V from dictionary D and frees V.
@@ -503,7 +590,7 @@ 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 val_cnt = var_get_value_cnt (v);
+  const int width = var_get_width (v);
 
   assert (dict_contains_var (d, v));
 
@@ -511,6 +598,7 @@ dict_delete_var (struct dictionary *d, struct variable *v)
   var_clear_aux (v);
 
   dict_unset_split_var (d, v);
+  dict_unset_mrset_var (d, v);
 
   if (d->weight == v)
     dict_set_weight (d, NULL);
@@ -521,23 +609,22 @@ dict_delete_var (struct dictionary *d, struct variable *v)
   dict_clear_vectors (d);
 
   /* Remove V from var array. */
+  unindex_vars (d, dict_index, d->var_cnt);
   remove_element (d->var, d->var_cnt, sizeof *d->var, dict_index);
   d->var_cnt--;
 
   /* Update dict_index for each affected variable. */
   reindex_vars (d, dict_index, d->var_cnt);
 
-  /* Update name hash. */
-  hsh_force_delete (d->name_tab, v);
-
-
   /* Free memory. */
   var_clear_vardict (v);
   var_destroy (v);
 
+  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, val_cnt, d->cb_data);
+    d->callbacks->var_deleted (d, dict_index, case_index, width, d->cb_data);
 }
 
 /* Deletes the COUNT variables listed in VARS from D.  This is
@@ -548,7 +635,6 @@ dict_delete_vars (struct dictionary *d,
 {
   /* FIXME: this can be done in O(count) time, but this algorithm
      is O(count**2). */
-  assert (d != NULL);
   assert (count == 0 || vars != NULL);
 
   while (count-- > 0)
@@ -566,7 +652,7 @@ dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count)
   assert (idx + count <= d->var_cnt);
 
   while (count-- > 0)
-    dict_delete_var (d, d->var[idx]);
+    dict_delete_var (d, d->var[idx].var);
 }
 
 /* Deletes scratch variables from dictionary D. */
@@ -577,11 +663,9 @@ dict_delete_scratch_vars (struct dictionary *d)
 
   /* FIXME: this can be done in O(count) time, but this algorithm
      is O(count**2). */
-  assert (d != NULL);
-
   for (i = 0; i < d->var_cnt; )
-    if (var_get_dict_class (d->var[i]) == DC_SCRATCH)
-      dict_delete_var (d, d->var[i]);
+    if (var_get_dict_class (d->var[i].var) == DC_SCRATCH)
+      dict_delete_var (d, d->var[i].var);
     else
       i++;
 }
@@ -595,6 +679,8 @@ dict_reorder_var (struct dictionary *d, struct variable *v, size_t new_index)
   size_t old_index = var_get_dict_index (v);
 
   assert (new_index < d->var_cnt);
+
+  unindex_vars (d, MIN (old_index, new_index), MAX (old_index, new_index) + 1);
   move_element (d->var, d->var_cnt, sizeof *d->var, old_index, new_index);
   reindex_vars (d, MIN (old_index, new_index), MAX (old_index, new_index) + 1);
 }
@@ -607,46 +693,50 @@ void
 dict_reorder_vars (struct dictionary *d,
                    struct variable *const *order, size_t count)
 {
-  struct variable **new_var;
+  struct vardict_info *new_var;
   size_t i;
 
-  assert (d != NULL);
   assert (count == 0 || order != NULL);
   assert (count <= d->var_cnt);
 
-  new_var = xnmalloc (d->var_cnt, sizeof *new_var);
-  memcpy (new_var, order, count * sizeof *new_var);
+  new_var = xnmalloc (d->var_cap, sizeof *new_var);
+
+  /* Add variables in ORDER to new_var. */
   for (i = 0; i < count; i++)
     {
-      size_t index = var_get_dict_index (order[i]);
-      assert (d->var[index] == order[i]);
-      d->var[index] = NULL;
-      set_var_dict_index (order[i], i);
+      struct vardict_info *old_var;
+
+      assert (dict_contains_var (d, order[i]));
+
+      old_var = var_get_vardict (order[i]);
+      new_var[i] = *old_var;
+      old_var->dict = NULL;
     }
+
+  /* Add remaining variables to new_var. */
   for (i = 0; i < d->var_cnt; i++)
-    if (d->var[i] != NULL)
-      {
-        assert (count < d->var_cnt);
-        new_var[count] = d->var[i];
-        set_var_dict_index (new_var[count], count);
-        count++;
-      }
+    if (d->var[i].dict != NULL)
+      new_var[count++] = d->var[i];
+  assert (count == d->var_cnt);
+
+  /* Replace old vardicts by new ones. */
   free (d->var);
   d->var = new_var;
+
+  hmap_clear (&d->name_map);
+  reindex_vars (d, 0, d->var_cnt);
 }
 
-/* Changes the name of variable V in dictionary D to NEW_NAME. */
+/* Changes the name of variable V that is currently in a dictionary to
+   NEW_NAME. */
 static void
-rename_var (struct dictionary *d, struct variable *v, const char *new_name)
+rename_var (struct variable *v, const char *new_name)
 {
-  struct vardict_info vdi;
-
-  assert (dict_contains_var (d, v));
-
-  vdi = *var_get_vardict (v);
+  struct vardict_info *vardict = var_get_vardict (v);
   var_clear_vardict (v);
   var_set_name (v, new_name);
-  var_set_vardict (v, &vdi);
+  vardict->name_node.hash = hash_case_string (new_name, 0);
+  var_set_vardict (v, vardict);
 }
 
 /* Changes the name of V in D to name NEW_NAME.  Assert-fails if
@@ -659,13 +749,14 @@ dict_rename_var (struct dictionary *d, struct variable *v,
   assert (!strcasecmp (var_get_name (v), new_name)
           || dict_lookup_var (d, new_name) == NULL);
 
-  hsh_force_delete (d->name_tab, v);
-  rename_var (d, v, new_name);
-  hsh_force_insert (d->name_tab, v);
+  unindex_var (d, var_get_vardict (v));
+  rename_var (v, new_name);
+  reindex_var (d, var_get_vardict (v));
 
   if (settings_get_algorithm () == ENHANCED)
     var_clear_short_names (v);
 
+  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);
 }
@@ -698,34 +789,37 @@ dict_rename_vars (struct dictionary *d,
      and rename them. */
   for (i = 0; i < count; i++)
     {
-      hsh_force_delete (d->name_tab, vars[i]);
-      rename_var (d, vars[i], new_names[i]);
+      unindex_var (d, var_get_vardict (vars[i]));
+      rename_var (vars[i], new_names[i]);
     }
 
   /* Add the renamed variables back into the name hash,
      checking for conflicts. */
   for (i = 0; i < count; i++)
-    if (hsh_insert (d->name_tab, vars[i]) != NULL)
-      {
-        /* There is a name conflict.
-           Back out all the name changes that have already
-           taken place, and indicate failure. */
-        size_t fail_idx = i;
-        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]);
-            hsh_force_insert (d->name_tab, vars[i]);
-          }
-
-        pool_destroy (pool);
-        return false;
-      }
+    {
+      if (dict_lookup_var (d, var_get_name (vars[i])) != NULL)
+        {
+          /* There is a name conflict.
+             Back out all the name changes that have already
+             taken place, and indicate failure. */
+          size_t fail_idx = i;
+          if (err_name != NULL)
+            *err_name = new_names[i];
+
+          for (i = 0; i < fail_idx; i++)
+            unindex_var (d, var_get_vardict (vars[i]));
+
+          for (i = 0; i < count; i++)
+            {
+              rename_var (vars[i], old_names[i]);
+              reindex_var (d, var_get_vardict (vars[i]));
+            }
+
+          pool_destroy (pool);
+          return false;
+        }
+      reindex_var (d, var_get_vardict (vars[i]));
+    }
 
   /* Clear short names. */
   if (settings_get_algorithm () == ENHANCED)
@@ -748,10 +842,10 @@ var_name_is_insertable (const struct dictionary *dict, const char *name)
           && 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])
+static char *
+make_hinted_name (const struct dictionary *dict, const char *hint)
 {
+  char name[VAR_NAME_LEN + 1];
   bool dropped = false;
   char *cp;
 
@@ -780,7 +874,7 @@ make_hinted_name (const struct dictionary *dict, const char *hint,
       unsigned long int i;
 
       if (var_name_is_insertable (dict, name))
-        return true;
+        return xstrdup (name);
 
       for (i = 0; i < ULONG_MAX; i++)
         {
@@ -795,16 +889,15 @@ make_hinted_name (const struct dictionary *dict, const char *hint,
           strcpy (&name[ofs], suffix);
 
           if (var_name_is_insertable (dict, name))
-            return true;
+            return xstrdup (name);
         }
     }
 
-  return false;
+  return NULL;
 }
 
-static bool
-make_numeric_name (const struct dictionary *dict, unsigned long int *num_start,
-                   char name[VAR_NAME_LEN + 1])
+static char *
+make_numeric_name (const struct dictionary *dict, unsigned long int *num_start)
 {
   unsigned long int number;
 
@@ -812,27 +905,24 @@ make_numeric_name (const struct dictionary *dict, unsigned long int *num_start,
        number < ULONG_MAX;
        number++)
     {
+      char name[3 + INT_STRLEN_BOUND (number) + 1];
+
       sprintf (name, "VAR%03lu", number);
       if (dict_lookup_var (dict, name) == NULL)
         {
           if (num_start != NULL)
             *num_start = number + 1;
-          return true;
+          return xstrdup (name);
         }
     }
 
-  if (num_start != NULL)
-    *num_start = ULONG_MAX;
-  return false;
+  NOT_REACHED ();
 }
 
 
-/* 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.)
+/* Devises and returns a variable name unique within DICT.  The variable name
+   is owned by the caller, which must free it with free() when it is no longer
+   needed.
 
    HINT, if it is non-null, is used as a suggestion that will be
    modified for suitability as a variable name and for
@@ -843,14 +933,18 @@ make_numeric_name (const struct dictionary *dict, unsigned long int *num_start,
    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
+*/
+char *
 dict_make_unique_var_name (const struct dictionary *dict, const char *hint,
-                           unsigned long int *num_start,
-                           char name[VAR_NAME_LEN + 1])
+                           unsigned long int *num_start)
 {
-  return ((hint != NULL && make_hinted_name (dict, hint, name))
-          || make_numeric_name (dict, num_start, name));
+  if (hint != NULL)
+    {
+      char *hinted_name = make_hinted_name (dict, hint);
+      if (hinted_name != NULL)
+        return hinted_name;
+    }
+  return make_numeric_name (dict, num_start);
 }
 
 /* Returns the weighting variable in dictionary D, or a null
@@ -858,7 +952,6 @@ dict_make_unique_var_name (const struct dictionary *dict, const char *hint,
 struct variable *
 dict_get_weight (const struct dictionary *d)
 {
-  assert (d != NULL);
   assert (d->weight == NULL || dict_contains_var (d, d->weight));
 
   return d->weight;
@@ -874,7 +967,6 @@ double
 dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
 		      bool *warn_on_invalid)
 {
-  assert (d != NULL);
   assert (c != NULL);
 
   if (d->weight == NULL)
@@ -899,12 +991,12 @@ dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
 void
 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,
@@ -916,7 +1008,6 @@ dict_set_weight (struct dictionary *d, struct variable *v)
 struct variable *
 dict_get_filter (const struct dictionary *d)
 {
-  assert (d != NULL);
   assert (d->filter == NULL || dict_contains_var (d, d->filter));
 
   return d->filter;
@@ -927,12 +1018,12 @@ dict_get_filter (const struct dictionary *d)
 void
 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,
@@ -944,8 +1035,6 @@ dict_set_filter (struct dictionary *d, struct variable *v)
 casenumber
 dict_get_case_limit (const struct dictionary *d)
 {
-  assert (d != NULL);
-
   return d->case_limit;
 }
 
@@ -954,19 +1043,34 @@ dict_get_case_limit (const struct dictionary *d)
 void
 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 = CONST_CAST (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),
+                                        var_get_width (d->var[i].var));
+    }
+  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)
 {
-  assert (d != NULL);
-
   return d->next_value_idx;
 }
 
@@ -975,8 +1079,6 @@ dict_get_next_value_idx (const struct dictionary *d)
 size_t
 dict_get_case_size (const struct dictionary *d)
 {
-  assert (d != NULL);
-
   return sizeof (union value) * dict_get_next_value_idx (d);
 }
 
@@ -990,38 +1092,12 @@ dict_compact_values (struct dictionary *d)
   d->next_value_idx = 0;
   for (i = 0; i < d->var_cnt; i++)
     {
-      struct variable *v = d->var[i];
-      set_var_case_index (v, d->next_value_idx);
-      d->next_value_idx += var_get_value_cnt (v);
-    }
-}
-
-/*
-   Reassigns case indices for D, increasing each index above START by
-   the value PADDING.
-*/
-static void
-dict_pad_values (struct dictionary *d, int start, int padding)
-{
-  size_t i;
-
-  if ( padding <= 0 ) 
-	return;
-
-  for (i = 0; i < d->var_cnt; ++i)
-    {
-      struct variable *v = d->var[i];
-
-      int index = var_get_case_index (v);
-
-      if ( index >= start)
-	set_var_case_index (v, index + padding);
+      struct variable *v = d->var[i].var;
+      set_var_case_index (v, d->next_value_idx++);
     }
-
-  d->next_value_idx += padding;
+  invalidate_proto (d);
 }
 
-
 /* 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),
@@ -1045,12 +1121,40 @@ dict_count_values (const struct dictionary *d, unsigned int exclude_classes)
   cnt = 0;
   for (i = 0; i < d->var_cnt; i++)
     {
-      enum dict_class class = var_get_dict_class (d->var[i]);
+      enum dict_class class = var_get_dict_class (d->var[i].var);
       if (!(exclude_classes & (1u << class)))
-        cnt += var_get_value_cnt (d->var[i]);
+        cnt++;
     }
   return cnt;
 }
+
+/* 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().
+
+   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 caseproto *proto;
+  size_t i;
+
+  assert ((exclude_classes & ~((1u << DC_ORDINARY)
+                               | (1u << DC_SYSTEM)
+                               | (1u << DC_SCRATCH))) == 0);
+
+  proto = caseproto_create ();
+  for (i = 0; i < d->var_cnt; i++)
+    {
+      struct variable *v = d->var[i].var;
+      if (!(exclude_classes & (1u << var_get_dict_class (v))))
+        proto = caseproto_add_width (proto, var_get_width (v));
+    }
+  return proto;
+}
 
 /* Returns the SPLIT FILE vars (see cmd_split_file()).  Call
    dict_get_split_cnt() to determine how many SPLIT FILE vars
@@ -1059,8 +1163,6 @@ dict_count_values (const struct dictionary *d, unsigned int exclude_classes)
 const struct variable *const *
 dict_get_split_vars (const struct dictionary *d)
 {
-  assert (d != NULL);
-
   return d->split;
 }
 
@@ -1068,14 +1170,12 @@ dict_get_split_vars (const struct dictionary *d)
 size_t
 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
+static void
 dict_unset_split_var (struct dictionary *d, struct variable *v)
 {
   int orig_count;
@@ -1087,6 +1187,7 @@ dict_unset_split_var (struct dictionary *d, struct variable *v)
                                &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)
@@ -1099,7 +1200,6 @@ void
 dict_set_split_vars (struct dictionary *d,
                      struct variable *const *split, size_t cnt)
 {
-  assert (d != NULL);
   assert (cnt == 0 || split != NULL);
 
   d->split_cnt = cnt;
@@ -1114,6 +1214,7 @@ dict_set_split_vars (struct dictionary *d,
     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);
 }
@@ -1123,20 +1224,18 @@ dict_set_split_vars (struct dictionary *d,
 const char *
 dict_get_label (const struct dictionary *d)
 {
-  assert (d != NULL);
-
   return d->label;
 }
 
 /* Sets D's file label to LABEL, truncating it to a maximum of 60
-   characters. */
+   characters.
+
+   Removes D's label if LABEL is null or the empty string. */
 void
 dict_set_label (struct dictionary *d, const char *label)
 {
-  assert (d != NULL);
-
   free (d->label);
-  d->label = label != NULL ? xstrndup (label, 60) : NULL;
+  d->label = label != NULL && label[0] != '\0' ? xstrndup (label, 60) : NULL;
 }
 
 /* Returns the documents for D, or a null pointer if D has no
@@ -1165,7 +1264,7 @@ dict_set_documents (struct dictionary *d, const char *documents)
      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);
+    ds_put_byte_multiple (&d->documents, ' ', DOC_LINE_LENGTH - remainder);
 }
 
 /* Drops the documents from dictionary D. */
@@ -1187,7 +1286,7 @@ dict_add_document_line (struct dictionary *d, const char *line)
       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);
+                     DOC_LINE_LENGTH, line, ' ');
 }
 
 /* Returns the number of document lines in dictionary D. */
@@ -1219,7 +1318,6 @@ dict_create_vector (struct dictionary *d,
 {
   size_t i;
 
-  assert (var != NULL);
   assert (cnt > 0);
   for (i = 0; i < cnt; i++)
     assert (dict_contains_var (d, var[i]));
@@ -1251,7 +1349,6 @@ dict_create_vector_assert (struct dictionary *d,
 const struct vector *
 dict_get_vector (const struct dictionary *d, size_t idx)
 {
-  assert (d != NULL);
   assert (idx < d->vector_cnt);
 
   return d->vector[idx];
@@ -1261,8 +1358,6 @@ dict_get_vector (const struct dictionary *d, size_t idx)
 size_t
 dict_get_vector_cnt (const struct dictionary *d)
 {
-  assert (d != NULL);
-
   return d->vector_cnt;
 }
 
@@ -1291,7 +1386,138 @@ dict_clear_vectors (struct dictionary *d)
   d->vector = NULL;
   d->vector_cnt = 0;
 }
+
+/* Multiple response sets. */
+
+/* Returns the multiple response set in DICT with index IDX, which must be
+   between 0 and the count returned by dict_get_n_mrsets(), exclusive. */
+const struct mrset *
+dict_get_mrset (const struct dictionary *dict, size_t idx)
+{
+  assert (idx < dict->n_mrsets);
+  return dict->mrsets[idx];
+}
 
+/* Returns the number of multiple response sets in DICT. */
+size_t
+dict_get_n_mrsets (const struct dictionary *dict)
+{
+  return dict->n_mrsets;
+}
+
+/* Looks for a multiple response set named NAME in DICT.  If it finds one,
+   returns its index; otherwise, returns SIZE_MAX. */
+static size_t
+dict_lookup_mrset_idx (const struct dictionary *dict, const char *name)
+{
+  size_t i;
+
+  for (i = 0; i < dict->n_mrsets; i++)
+    if (!strcasecmp (name, dict->mrsets[i]->name))
+      return i;
+
+  return SIZE_MAX;
+}
+
+/* Looks for a multiple response set named NAME in DICT.  If it finds one,
+   returns it; otherwise, returns NULL. */
+const struct mrset *
+dict_lookup_mrset (const struct dictionary *dict, const char *name)
+{
+  size_t idx = dict_lookup_mrset_idx (dict, name);
+  return idx != SIZE_MAX ? dict->mrsets[idx] : NULL;
+}
+
+/* Adds MRSET to DICT, replacing any existing set with the same name.  Returns
+   true if a set was replaced, false if none existed with the specified name.
+
+   Ownership of MRSET is transferred to DICT. */
+bool
+dict_add_mrset (struct dictionary *dict, struct mrset *mrset)
+{
+  size_t idx;
+
+  assert (mrset_ok (mrset, dict));
+
+  idx = dict_lookup_mrset_idx (dict, mrset->name);
+  if (idx == SIZE_MAX)
+    {
+      dict->mrsets = xrealloc (dict->mrsets,
+                               (dict->n_mrsets + 1) * sizeof *dict->mrsets);
+      dict->mrsets[dict->n_mrsets++] = mrset;
+      return true;
+    }
+  else
+    {
+      mrset_destroy (dict->mrsets[idx]);
+      dict->mrsets[idx] = mrset;
+      return false;
+    }
+}
+
+/* Looks for a multiple response set in DICT named NAME.  If found, removes it
+   from DICT and returns true.  If none is found, returns false without
+   modifying DICT.
+
+   Deleting one multiple response set causes the indexes of other sets within
+   DICT to change. */
+bool
+dict_delete_mrset (struct dictionary *dict, const char *name)
+{
+  size_t idx = dict_lookup_mrset_idx (dict, name);
+  if (idx != SIZE_MAX)
+    {
+      mrset_destroy (dict->mrsets[idx]);
+      dict->mrsets[idx] = dict->mrsets[--dict->n_mrsets];
+      return true;
+    }
+  else
+    return false;
+}
+
+/* Deletes all multiple response sets from DICT. */
+void
+dict_clear_mrsets (struct dictionary *dict)
+{
+  size_t i;
+
+  for (i = 0; i < dict->n_mrsets; i++)
+    mrset_destroy (dict->mrsets[i]);
+  free (dict->mrsets);
+  dict->mrsets = NULL;
+  dict->n_mrsets = 0;
+}
+
+/* Removes VAR, which must be in DICT, from DICT's multiple response sets. */
+static void
+dict_unset_mrset_var (struct dictionary *dict, struct variable *var)
+{
+  size_t i;
+
+  assert (dict_contains_var (dict, var));
+
+  for (i = 0; i < dict->n_mrsets; )
+    {
+      struct mrset *mrset = dict->mrsets[i];
+      size_t j;
+
+      for (j = 0; j < mrset->n_vars; )
+        if (mrset->vars[j] == var)
+          remove_element (mrset->vars, mrset->n_vars--,
+                          sizeof *mrset->vars, j);
+        else
+          j++;
+
+      if (mrset->n_vars < 2)
+        {
+          mrset_destroy (mrset);
+          dict->mrsets[i] = dict->mrsets[--dict->n_mrsets];
+        }
+      else
+        i++;
+    }
+}
+
 /* 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
@@ -1299,7 +1525,7 @@ dict_clear_vectors (struct dictionary *d)
 struct attrset *
 dict_get_attributes (const struct dictionary *d) 
 {
-  return (struct attrset *) &d->attributes;
+  return CONST_CAST (struct attrset *, &d->attributes);
 }
 
 /* Replaces D's attributes set by a copy of ATTRS. */
@@ -1325,9 +1551,13 @@ 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;
+      const struct vardict_info *vardict = var_get_vardict (v);
+      struct dictionary *d = vardict->dict;
+
+      if ( NULL == d)
+	return;
 
+      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);
     }
@@ -1337,19 +1567,21 @@ dict_var_changed (const struct variable *v)
 /* Called from variable.c to notify the dictionary that the variable's width
    has changed */
 void
-dict_var_resized (const struct variable *v, int delta)
+dict_var_resized (const struct variable *v, int old_width)
 {
   if ( var_has_vardict (v))
     {
-      const struct vardict_info *vdi = var_get_vardict (v);
+      const struct vardict_info *vardict = var_get_vardict (v);
       struct dictionary *d;
 
-      d = vdi->dict;
+      d = vardict->dict;
 
-      dict_pad_values (d, var_get_case_index(v) + 1, delta);
+      if (d->changed) d->changed (d, d->changed_data);
 
+      invalidate_proto (d);
       if ( d->callbacks && d->callbacks->var_resized )
-	d->callbacks->var_resized (d, var_get_dict_index (v), delta, d->cb_data);
+	d->callbacks->var_resized (d, var_get_dict_index (v), old_width,
+                                   d->cb_data);
     }
 }
 
@@ -1360,13 +1592,68 @@ dict_var_display_width_changed (const struct variable *v)
 {
   if ( var_has_vardict (v))
     {
-      const struct vardict_info *vdi = var_get_vardict (v);
+      const struct vardict_info *vardict = var_get_vardict (v);
       struct dictionary *d;
 
-      d = vdi->dict;
+      d = vardict->dict;
 
+      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);
     }
 }
+
+/* Dictionary used to contain "internal variables". */
+static struct dictionary *internal_dict;
 
+/* Create a variable of the specified WIDTH to be used for internal
+   calculations only.  The variable is assigned case index CASE_IDX. */
+struct variable *
+dict_create_internal_var (int case_idx, int width)
+{
+  if (internal_dict == NULL)
+    internal_dict = dict_create ();
+
+  for (;;)
+    {
+      static int counter = INT_MAX / 2;
+      struct variable *var;
+      char name[64];
+
+      if (++counter == INT_MAX)
+        counter = INT_MAX / 2;
+
+      sprintf (name, "$internal%d", counter);
+      var = dict_create_var (internal_dict, name, width);
+      if (var != NULL)
+        {
+          set_var_case_index (var, case_idx);
+          return var;
+        }
+    }
+}
+
+/* Destroys VAR, which must have been created with
+   dict_create_internal_var(). */
+void
+dict_destroy_internal_var (struct variable *var)
+{
+  if (var != NULL)
+    {
+      dict_delete_var (internal_dict, var);
+
+      /* Destroy internal_dict if it has no variables left, just so that
+         valgrind --leak-check --show-reachable won't show internal_dict. */
+      if (dict_get_var_cnt (internal_dict) == 0)
+        {
+          dict_destroy (internal_dict);
+          internal_dict = NULL;
+        }
+    }
+}
+
+int
+vardict_get_dict_index (const struct vardict_info *vardict)
+{
+  return vardict - vardict->dict->var;
+}