src/data/dictionary.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2006, 2007, 2009 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include "dictionary.h"
  20
  21 #include <stdlib.h>
  22 #include <ctype.h>
  23
  24 #include <data/attributes.h>
  25 #include <data/case.h>
  26 #include <data/category.h>
  27 #include <data/identifier.h>
  28 #include <data/settings.h>
  29 #include <data/value-labels.h>
  30 #include <data/vardict.h>
  31 #include <data/variable.h>
  32 #include <data/vector.h>
  33 #include <libpspp/array.h>
  34 #include <libpspp/assertion.h>
  35 #include <libpspp/compiler.h>
  36 #include <libpspp/hash.h>
  37 #include <libpspp/message.h>
  38 #include <libpspp/misc.h>
  39 #include <libpspp/pool.h>
  40 #include <libpspp/str.h>
  41
  42 #include "intprops.h"
  43 #include "minmax.h"
  44 #include "xalloc.h"
  45
  46 #include "gettext.h"
  47 #define _(msgid) gettext (msgid)
  48
  49 /* A dictionary. */
  50 struct dictionary
  51   {
  52     struct variable **var;      /* Variables. */
  53     size_t var_cnt, var_cap;    /* Number of variables, capacity. */
  54     struct caseproto *proto;    /* Prototype for dictionary cases
  55                                    (updated lazily). */
  56     struct hsh_table *name_tab; /* Variable index by name. */
  57     int next_value_idx;         /* Index of next `union value' to allocate. */
  58     const struct variable **split;    /* SPLIT FILE vars. */
  59     size_t split_cnt;           /* SPLIT FILE count. */
  60     struct variable *weight;    /* WEIGHT variable. */
  61     struct variable *filter;    /* FILTER variable. */
  62     casenumber case_limit;      /* Current case limit (N command). */
  63     char *label;                /* File label. */
  64     struct string documents;    /* Documents, as a string. */
  65     struct vector **vector;     /* Vectors of variables. */
  66     size_t vector_cnt;          /* Number of vectors. */
  67     struct attrset attributes;  /* Custom attributes. */
  68
  69     char *encoding;             /* Character encoding of string data */
  70
  71     const struct dict_callbacks *callbacks; /* Callbacks on dictionary
  72                                                modification */
  73     void *cb_data ;                  /* Data passed to callbacks */
  74
  75     void (*changed) (struct dictionary *, void *); /* Generic change callback */
  76     void *changed_data;
  77   };
  78
  79
  80 void
  81 dict_set_encoding (struct dictionary *d, const char *enc)
  82 {
  83   if (enc)
  84     d->encoding = xstrdup (enc);
  85 }
  86
  87 const char *
  88 dict_get_encoding (const struct dictionary *d)
  89 {
  90   return d->encoding ;
  91 }
  92
  93
  94 void
  95 dict_set_change_callback (struct dictionary *d,
  96                           void (*changed) (struct dictionary *, void*),
  97                           void *data)
  98 {
  99   d->changed = changed;
 100   d->changed_data = data;
 101 }
 102
 103 /* Discards dictionary D's caseproto.  (It will be regenerated
 104    lazily, on demand.) */
 105 static void
 106 invalidate_proto (struct dictionary *d)
 107 {
 108   caseproto_unref (d->proto);
 109   d->proto = NULL;
 110 }
 111
 112 /* Print a representation of dictionary D to stdout, for
 113    debugging purposes. */
 114 void
 115 dict_dump (const struct dictionary *d)
 116 {
 117   int i;
 118   for (i = 0 ; i < d->var_cnt ; ++i )
 119     {
 120       const struct variable *v =
 121         d->var[i];
 122       printf ("Name: %s;\tdict_idx: %d; case_idx: %d\n",
 123               var_get_name (v),
 124               var_get_dict_index (v),
 125               var_get_case_index (v));
 126
 127     }
 128 }
 129
 130 /* Associate CALLBACKS with DICT.  Callbacks will be invoked whenever
 131    the dictionary or any of the variables it contains are modified.
 132    Each callback will get passed CALLBACK_DATA.
 133    Any callback may be NULL, in which case it'll be ignored.
 134 */
 135 void
 136 dict_set_callbacks (struct dictionary *dict,
 137                     const struct dict_callbacks *callbacks,
 138                     void *callback_data)
 139 {
 140   dict->callbacks = callbacks;
 141   dict->cb_data = callback_data;
 142 }
 143
 144 /* Shallow copy the callbacks from SRC to DEST */
 145 void
 146 dict_copy_callbacks (struct dictionary *dest,
 147                      const struct dictionary *src)
 148 {
 149   dest->callbacks = src->callbacks;
 150   dest->cb_data = src->cb_data;
 151 }
 152
 153 /* Creates and returns a new dictionary. */
 154 struct dictionary *
 155 dict_create (void)
 156 {
 157   struct dictionary *d = xzalloc (sizeof *d);
 158
 159   d->name_tab = hsh_create (8, compare_vars_by_name, hash_var_by_name,
 160                             NULL, NULL);
 161   attrset_init (&d->attributes);
 162   return d;
 163 }
 164
 165 /* Creates and returns a (deep) copy of an existing
 166    dictionary.
 167
 168    The new dictionary's case indexes are copied from the old
 169    dictionary.  If the new dictionary won't be used to access
 170    cases produced with the old dictionary, then the new
 171    dictionary's case indexes should be compacted with
 172    dict_compact_values to save space. */
 173 struct dictionary *
 174 dict_clone (const struct dictionary *s)
 175 {
 176   struct dictionary *d;
 177   size_t i;
 178
 179   assert (s != NULL);
 180
 181   d = dict_create ();
 182
 183   for (i = 0; i < s->var_cnt; i++)
 184     {
 185       const struct vardict_info *svdi;
 186       struct vardict_info dvdi;
 187       struct variable *sv = s->var[i];
 188       struct variable *dv = dict_clone_var_assert (d, sv, var_get_name (sv));
 189       size_t i;
 190
 191       for (i = 0; i < var_get_short_name_cnt (sv); i++)
 192         var_set_short_name (dv, i, var_get_short_name (sv, i));
 193
 194       svdi = var_get_vardict (sv);
 195       dvdi = *svdi;
 196       dvdi.dict = d;
 197       var_set_vardict (dv, &dvdi);
 198     }
 199
 200   d->next_value_idx = s->next_value_idx;
 201
 202   d->split_cnt = s->split_cnt;
 203   if (d->split_cnt > 0)
 204     {
 205       d->split = xnmalloc (d->split_cnt, sizeof *d->split);
 206       for (i = 0; i < d->split_cnt; i++)
 207         d->split[i] = dict_lookup_var_assert (d, var_get_name (s->split[i]));
 208     }
 209
 210   if (s->weight != NULL)
 211     dict_set_weight (d, dict_lookup_var_assert (d, var_get_name (s->weight)));
 212
 213   if (s->filter != NULL)
 214     dict_set_filter (d, dict_lookup_var_assert (d, var_get_name (s->filter)));
 215
 216   d->case_limit = s->case_limit;
 217   dict_set_label (d, dict_get_label (s));
 218   dict_set_documents (d, dict_get_documents (s));
 219
 220   d->vector_cnt = s->vector_cnt;
 221   d->vector = xnmalloc (d->vector_cnt, sizeof *d->vector);
 222   for (i = 0; i < s->vector_cnt; i++)
 223     d->vector[i] = vector_clone (s->vector[i], s, d);
 224
 225   if ( s->encoding)
 226     d->encoding = xstrdup (s->encoding);
 227
 228   dict_set_attributes (d, dict_get_attributes (s));
 229
 230   return d;
 231 }
 232
 233 /* Clears the contents from a dictionary without destroying the
 234    dictionary itself. */
 235 void
 236 dict_clear (struct dictionary *d)
 237 {
 238   /* FIXME?  Should we really clear case_limit, label, documents?
 239      Others are necessarily cleared by deleting all the variables.*/
 240   assert (d != NULL);
 241
 242   while (d->var_cnt > 0 )
 243     {
 244       dict_delete_var (d, d->var[d->var_cnt - 1]);
 245     }
 246
 247   free (d->var);
 248   d->var = NULL;
 249   d->var_cnt = d->var_cap = 0;
 250   invalidate_proto (d);
 251   hsh_clear (d->name_tab);
 252   d->next_value_idx = 0;
 253   dict_set_split_vars (d, NULL, 0);
 254   dict_set_weight (d, NULL);
 255   dict_set_filter (d, NULL);
 256   d->case_limit = 0;
 257   free (d->label);
 258   d->label = NULL;
 259   ds_destroy (&d->documents);
 260   dict_clear_vectors (d);
 261   attrset_clear (&d->attributes);
 262 }
 263
 264 /* Destroys the aux data for every variable in D, by calling
 265    var_clear_aux() for each variable. */
 266 void
 267 dict_clear_aux (struct dictionary *d)
 268 {
 269   int i;
 270
 271   assert (d != NULL);
 272
 273   for (i = 0; i < d->var_cnt; i++)
 274     var_clear_aux (d->var[i]);
 275 }
 276
 277 /* Clears a dictionary and destroys it. */
 278 void
 279 dict_destroy (struct dictionary *d)
 280 {
 281   if (d != NULL)
 282     {
 283       /* In general, we don't want callbacks occuring, if the dictionary
 284          is being destroyed */
 285       d->callbacks  = NULL ;
 286
 287       dict_clear (d);
 288       hsh_destroy (d->name_tab);
 289       attrset_destroy (&d->attributes);
 290       free (d);
 291     }
 292 }
 293
 294 /* Returns the number of variables in D. */
 295 size_t
 296 dict_get_var_cnt (const struct dictionary *d)
 297 {
 298   assert (d != NULL);
 299
 300   return d->var_cnt;
 301 }
 302
 303 /* Returns the variable in D with dictionary index IDX, which
 304    must be between 0 and the count returned by
 305    dict_get_var_cnt(), exclusive. */
 306 struct variable *
 307 dict_get_var (const struct dictionary *d, size_t idx)
 308 {
 309   assert (d != NULL);
 310   assert (idx < d->var_cnt);
 311
 312   return d->var[idx];
 313 }
 314
 315 /* Sets *VARS to an array of pointers to variables in D and *CNT
 316    to the number of variables in *D.  All variables are returned
 317    except for those, if any, in the classes indicated by EXCLUDE.
 318    (There is no point in putting DC_SYSTEM in EXCLUDE as
 319    dictionaries never include system variables.) */
 320 void
 321 dict_get_vars (const struct dictionary *d, const struct variable ***vars,
 322                size_t *cnt, enum dict_class exclude)
 323 {
 324   dict_get_vars_mutable (d, (struct variable ***) vars, cnt, exclude);
 325 }
 326
 327 /* Sets *VARS to an array of pointers to variables in D and *CNT
 328    to the number of variables in *D.  All variables are returned
 329    except for those, if any, in the classes indicated by EXCLUDE.
 330    (There is no point in putting DC_SYSTEM in EXCLUDE as
 331    dictionaries never include system variables.) */
 332 void
 333 dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars,
 334                        size_t *cnt, enum dict_class exclude)
 335 {
 336   size_t count;
 337   size_t i;
 338
 339   assert (d != NULL);
 340   assert (vars != NULL);
 341   assert (cnt != NULL);
 342   assert (exclude == (exclude & DC_ALL));
 343
 344   count = 0;
 345   for (i = 0; i < d->var_cnt; i++)
 346     {
 347       enum dict_class class = var_get_dict_class (d->var[i]);
 348       if (!(class & exclude))
 349         count++;
 350     }
 351
 352   *vars = xnmalloc (count, sizeof **vars);
 353   *cnt = 0;
 354   for (i = 0; i < d->var_cnt; i++)
 355     {
 356       enum dict_class class = var_get_dict_class (d->var[i]);
 357       if (!(class & exclude))
 358         (*vars)[(*cnt)++] = d->var[i];
 359     }
 360   assert (*cnt == count);
 361 }
 362
 363 static struct variable *
 364 add_var (struct dictionary *d, struct variable *v)
 365 {
 366   /* Add dictionary info to variable. */
 367   struct vardict_info vdi;
 368   vdi.case_index = d->next_value_idx;
 369   vdi.dict_index = d->var_cnt;
 370   vdi.dict = d;
 371   var_set_vardict (v, &vdi);
 372
 373   /* Update dictionary. */
 374   if (d->var_cnt >= d->var_cap)
 375     {
 376       d->var_cap = 8 + 2 * d->var_cap;
 377       d->var = xnrealloc (d->var, d->var_cap, sizeof *d->var);
 378     }
 379   d->var[d->var_cnt++] = v;
 380   hsh_force_insert (d->name_tab, v);
 381
 382   if ( d->changed ) d->changed (d, d->changed_data);
 383   if ( d->callbacks &&  d->callbacks->var_added )
 384     d->callbacks->var_added (d, var_get_dict_index (v), d->cb_data);
 385
 386   d->next_value_idx++;
 387   invalidate_proto (d);
 388
 389   return v;
 390 }
 391
 392 /* Creates and returns a new variable in D with the given NAME
 393    and WIDTH.  Returns a null pointer if the given NAME would
 394    duplicate that of an existing variable in the dictionary. */
 395 struct variable *
 396 dict_create_var (struct dictionary *d, const char *name, int width)
 397 {
 398   return (dict_lookup_var (d, name) == NULL
 399           ? dict_create_var_assert (d, name, width)
 400           : NULL);
 401 }
 402
 403 /* Creates and returns a new variable in D with the given NAME
 404    and WIDTH.  Assert-fails if the given NAME would duplicate
 405    that of an existing variable in the dictionary. */
 406 struct variable *
 407 dict_create_var_assert (struct dictionary *d, const char *name, int width)
 408 {
 409   assert (dict_lookup_var (d, name) == NULL);
 410   return add_var (d, var_create (name, width));
 411 }
 412
 413 /* Creates and returns a new variable in D with name NAME, as a
 414    copy of existing variable OLD_VAR, which need not be in D or
 415    in any dictionary.  Returns a null pointer if the given NAME
 416    would duplicate that of an existing variable in the
 417    dictionary. */
 418 struct variable *
 419 dict_clone_var (struct dictionary *d, const struct variable *old_var,
 420                 const char *name)
 421 {
 422   return (dict_lookup_var (d, name) == NULL
 423           ? dict_clone_var_assert (d, old_var, name)
 424           : NULL);
 425 }
 426
 427 /* Creates and returns a new variable in D with name NAME, as a
 428    copy of existing variable OLD_VAR, which need not be in D or
 429    in any dictionary.  Assert-fails if the given NAME would
 430    duplicate that of an existing variable in the dictionary. */
 431 struct variable *
 432 dict_clone_var_assert (struct dictionary *d, const struct variable *old_var,
 433                        const char *name)
 434 {
 435   struct variable *new_var = var_clone (old_var);
 436   assert (dict_lookup_var (d, name) == NULL);
 437   var_set_name (new_var, name);
 438   return add_var (d, new_var);
 439 }
 440
 441 /* Returns the variable named NAME in D, or a null pointer if no
 442    variable has that name. */
 443 struct variable *
 444 dict_lookup_var (const struct dictionary *d, const char *name)
 445 {
 446   struct variable *target ;
 447   struct variable *result ;
 448
 449   if ( ! var_is_plausible_name (name, false))
 450     return NULL;
 451
 452   target = var_create (name, 0);
 453   result = hsh_find (d->name_tab, target);
 454   var_destroy (target);
 455
 456   if ( result && var_has_vardict (result))
 457   {
 458       const struct vardict_info *vdi = var_get_vardict (result);
 459       assert (vdi->dict == d);
 460   }
 461
 462   return result;
 463 }
 464
 465 /* Returns the variable named NAME in D.  Assert-fails if no
 466    variable has that name. */
 467 struct variable *
 468 dict_lookup_var_assert (const struct dictionary *d, const char *name)
 469 {
 470   struct variable *v = dict_lookup_var (d, name);
 471   assert (v != NULL);
 472   return v;
 473 }
 474
 475 /* Returns true if variable V is in dictionary D,
 476    false otherwise. */
 477 bool
 478 dict_contains_var (const struct dictionary *d, const struct variable *v)
 479 {
 480   if (var_has_vardict (v))
 481     {
 482       const struct vardict_info *vdi = var_get_vardict (v);
 483       return (vdi->dict_index >= 0
 484               && vdi->dict_index < d->var_cnt
 485               && d->var[vdi->dict_index] == v);
 486     }
 487   else
 488     return false;
 489 }
 490
 491 /* Compares two double pointers to variables, which should point
 492    to elements of a struct dictionary's `var' member array. */
 493 static int
 494 compare_var_ptrs (const void *a_, const void *b_, const void *aux UNUSED)
 495 {
 496   struct variable *const *a = a_;
 497   struct variable *const *b = b_;
 498
 499   return *a < *b ? -1 : *a > *b;
 500 }
 501
 502 /* Sets the dict_index in V's vardict to DICT_INDEX. */
 503 static void
 504 set_var_dict_index (struct variable *v, int dict_index)
 505 {
 506   struct vardict_info vdi = *var_get_vardict (v);
 507   struct dictionary *d = vdi.dict;
 508   vdi.dict_index = dict_index;
 509   var_set_vardict (v, &vdi);
 510
 511   if ( d->changed ) d->changed (d, d->changed_data);
 512   if ( d->callbacks &&  d->callbacks->var_changed )
 513     d->callbacks->var_changed (d, dict_index, d->cb_data);
 514 }
 515
 516 /* Sets the case_index in V's vardict to CASE_INDEX. */
 517 static void
 518 set_var_case_index (struct variable *v, int case_index)
 519 {
 520   struct vardict_info vdi = *var_get_vardict (v);
 521   vdi.case_index = case_index;
 522   var_set_vardict (v, &vdi);
 523 }
 524
 525 /* Re-sets the dict_index in the dictionary variables with
 526    indexes from FROM to TO (exclusive). */
 527 static void
 528 reindex_vars (struct dictionary *d, size_t from, size_t to)
 529 {
 530   size_t i;
 531
 532   for (i = from; i < to; i++)
 533     set_var_dict_index (d->var[i], i);
 534 }
 535
 536 /* Deletes variable V from dictionary D and frees V.
 537
 538    This is a very bad idea if there might be any pointers to V
 539    from outside D.  In general, no variable in the active file's
 540    dictionary should be deleted when any transformations are
 541    active on the dictionary's dataset, because those
 542    transformations might reference the deleted variable.  The
 543    safest time to delete a variable is just after a procedure has
 544    been executed, as done by DELETE VARIABLES.
 545
 546    Pointers to V within D are not a problem, because
 547    dict_delete_var() knows to remove V from split variables,
 548    weights, filters, etc. */
 549 void
 550 dict_delete_var (struct dictionary *d, struct variable *v)
 551 {
 552   int dict_index = var_get_dict_index (v);
 553   const int case_index = var_get_case_index (v);
 554   const int width = var_get_width (v);
 555
 556   assert (dict_contains_var (d, v));
 557
 558   /* Delete aux data. */
 559   var_clear_aux (v);
 560
 561   dict_unset_split_var (d, v);
 562
 563   if (d->weight == v)
 564     dict_set_weight (d, NULL);
 565
 566   if (d->filter == v)
 567     dict_set_filter (d, NULL);
 568
 569   dict_clear_vectors (d);
 570
 571   /* Remove V from var array. */
 572   remove_element (d->var, d->var_cnt, sizeof *d->var, dict_index);
 573   d->var_cnt--;
 574
 575   /* Update dict_index for each affected variable. */
 576   reindex_vars (d, dict_index, d->var_cnt);
 577
 578   /* Update name hash. */
 579   hsh_force_delete (d->name_tab, v);
 580
 581
 582   /* Free memory. */
 583   var_clear_vardict (v);
 584   var_destroy (v);
 585
 586   if ( d->changed ) d->changed (d, d->changed_data);
 587
 588   invalidate_proto (d);
 589   if (d->callbacks &&  d->callbacks->var_deleted )
 590     d->callbacks->var_deleted (d, dict_index, case_index, width, d->cb_data);
 591 }
 592
 593 /* Deletes the COUNT variables listed in VARS from D.  This is
 594    unsafe; see the comment on dict_delete_var() for details. */
 595 void
 596 dict_delete_vars (struct dictionary *d,
 597                   struct variable *const *vars, size_t count)
 598 {
 599   /* FIXME: this can be done in O(count) time, but this algorithm
 600      is O(count**2). */
 601   assert (d != NULL);
 602   assert (count == 0 || vars != NULL);
 603
 604   while (count-- > 0)
 605     dict_delete_var (d, *vars++);
 606 }
 607
 608 /* Deletes the COUNT variables in D starting at index IDX.  This
 609    is unsafe; see the comment on dict_delete_var() for
 610    details. */
 611 void
 612 dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count)
 613 {
 614   /* FIXME: this can be done in O(count) time, but this algorithm
 615      is O(count**2). */
 616   assert (idx + count <= d->var_cnt);
 617
 618   while (count-- > 0)
 619     dict_delete_var (d, d->var[idx]);
 620 }
 621
 622 /* Deletes scratch variables from dictionary D. */
 623 void
 624 dict_delete_scratch_vars (struct dictionary *d)
 625 {
 626   int i;
 627
 628   /* FIXME: this can be done in O(count) time, but this algorithm
 629      is O(count**2). */
 630   assert (d != NULL);
 631
 632   for (i = 0; i < d->var_cnt; )
 633     if (var_get_dict_class (d->var[i]) == DC_SCRATCH)
 634       dict_delete_var (d, d->var[i]);
 635     else
 636       i++;
 637 }
 638
 639 /* Moves V to 0-based position IDX in D.  Other variables in D,
 640    if any, retain their relative positions.  Runs in time linear
 641    in the distance moved. */
 642 void
 643 dict_reorder_var (struct dictionary *d, struct variable *v, size_t new_index)
 644 {
 645   size_t old_index = var_get_dict_index (v);
 646
 647   assert (new_index < d->var_cnt);
 648   move_element (d->var, d->var_cnt, sizeof *d->var, old_index, new_index);
 649   reindex_vars (d, MIN (old_index, new_index), MAX (old_index, new_index) + 1);
 650 }
 651
 652 /* Reorders the variables in D, placing the COUNT variables
 653    listed in ORDER in that order at the beginning of D.  The
 654    other variables in D, if any, retain their relative
 655    positions. */
 656 void
 657 dict_reorder_vars (struct dictionary *d,
 658                    struct variable *const *order, size_t count)
 659 {
 660   struct variable **new_var;
 661   size_t i;
 662
 663   assert (d != NULL);
 664   assert (count == 0 || order != NULL);
 665   assert (count <= d->var_cnt);
 666
 667   new_var = xnmalloc (d->var_cnt, sizeof *new_var);
 668   memcpy (new_var, order, count * sizeof *new_var);
 669   for (i = 0; i < count; i++)
 670     {
 671       size_t index = var_get_dict_index (order[i]);
 672       assert (d->var[index] == order[i]);
 673       d->var[index] = NULL;
 674       set_var_dict_index (order[i], i);
 675     }
 676   for (i = 0; i < d->var_cnt; i++)
 677     if (d->var[i] != NULL)
 678       {
 679         assert (count < d->var_cnt);
 680         new_var[count] = d->var[i];
 681         set_var_dict_index (new_var[count], count);
 682         count++;
 683       }
 684   free (d->var);
 685   d->var = new_var;
 686 }
 687
 688 /* Changes the name of variable V in dictionary D to NEW_NAME. */
 689 static void
 690 rename_var (struct dictionary *d, struct variable *v, const char *new_name)
 691 {
 692   struct vardict_info vdi;
 693
 694   assert (dict_contains_var (d, v));
 695
 696   vdi = *var_get_vardict (v);
 697   var_clear_vardict (v);
 698   var_set_name (v, new_name);
 699   var_set_vardict (v, &vdi);
 700 }
 701
 702 /* Changes the name of V in D to name NEW_NAME.  Assert-fails if
 703    a variable named NEW_NAME is already in D, except that
 704    NEW_NAME may be the same as V's existing name. */
 705 void
 706 dict_rename_var (struct dictionary *d, struct variable *v,
 707                  const char *new_name)
 708 {
 709   assert (!strcasecmp (var_get_name (v), new_name)
 710           || dict_lookup_var (d, new_name) == NULL);
 711
 712   hsh_force_delete (d->name_tab, v);
 713   rename_var (d, v, new_name);
 714   hsh_force_insert (d->name_tab, v);
 715
 716   if (settings_get_algorithm () == ENHANCED)
 717     var_clear_short_names (v);
 718
 719   if ( d->changed ) d->changed (d, d->changed_data);
 720   if ( d->callbacks &&  d->callbacks->var_changed )
 721     d->callbacks->var_changed (d, var_get_dict_index (v), d->cb_data);
 722 }
 723
 724 /* Renames COUNT variables specified in VARS to the names given
 725    in NEW_NAMES within dictionary D.  If the renaming would
 726    result in a duplicate variable name, returns false and stores a
 727    name that would be duplicated into *ERR_NAME (if ERR_NAME is
 728    non-null).  Otherwise, the renaming is successful, and true
 729    is returned. */
 730 bool
 731 dict_rename_vars (struct dictionary *d,
 732                   struct variable **vars, char **new_names, size_t count,
 733                   char **err_name)
 734 {
 735   struct pool *pool;
 736   char **old_names;
 737   size_t i;
 738
 739   assert (count == 0 || vars != NULL);
 740   assert (count == 0 || new_names != NULL);
 741
 742   /* Save the names of the variables to be renamed. */
 743   pool = pool_create ();
 744   old_names = pool_nalloc (pool, count, sizeof *old_names);
 745   for (i = 0; i < count; i++)
 746     old_names[i] = pool_strdup (pool, var_get_name (vars[i]));
 747
 748   /* Remove the variables to be renamed from the name hash,
 749      and rename them. */
 750   for (i = 0; i < count; i++)
 751     {
 752       hsh_force_delete (d->name_tab, vars[i]);
 753       rename_var (d, vars[i], new_names[i]);
 754     }
 755
 756   /* Add the renamed variables back into the name hash,
 757      checking for conflicts. */
 758   for (i = 0; i < count; i++)
 759     if (hsh_insert (d->name_tab, vars[i]) != NULL)
 760       {
 761         /* There is a name conflict.
 762            Back out all the name changes that have already
 763            taken place, and indicate failure. */
 764         size_t fail_idx = i;
 765         if (err_name != NULL)
 766           *err_name = new_names[i];
 767
 768         for (i = 0; i < fail_idx; i++)
 769           hsh_force_delete (d->name_tab, vars[i]);
 770
 771         for (i = 0; i < count; i++)
 772           {
 773             rename_var (d, vars[i], old_names[i]);
 774             hsh_force_insert (d->name_tab, vars[i]);
 775           }
 776
 777         pool_destroy (pool);
 778         return false;
 779       }
 780
 781   /* Clear short names. */
 782   if (settings_get_algorithm () == ENHANCED)
 783     for (i = 0; i < count; i++)
 784       var_clear_short_names (vars[i]);
 785
 786   pool_destroy (pool);
 787   return true;
 788 }
 789
 790 /* Returns true if a variable named NAME may be inserted in DICT;
 791    that is, if there is not already a variable with that name in
 792    DICT and if NAME is not a reserved word.  (The caller's checks
 793    have already verified that NAME is otherwise acceptable as a
 794    variable name.) */
 795 static bool
 796 var_name_is_insertable (const struct dictionary *dict, const char *name)
 797 {
 798   return (dict_lookup_var (dict, name) == NULL
 799           && lex_id_to_token (ss_cstr (name)) == T_ID);
 800 }
 801
 802 static bool
 803 make_hinted_name (const struct dictionary *dict, const char *hint,
 804                   char name[VAR_NAME_LEN + 1])
 805 {
 806   bool dropped = false;
 807   char *cp;
 808
 809   for (cp = name; *hint && cp < name + VAR_NAME_LEN; hint++)
 810     {
 811       if (cp == name
 812           ? lex_is_id1 (*hint) && *hint != '$'
 813           : lex_is_idn (*hint))
 814         {
 815           if (dropped)
 816             {
 817               *cp++ = '_';
 818               dropped = false;
 819             }
 820           if (cp < name + VAR_NAME_LEN)
 821             *cp++ = *hint;
 822         }
 823       else if (cp > name)
 824         dropped = true;
 825     }
 826   *cp = '\0';
 827
 828   if (name[0] != '\0')
 829     {
 830       size_t len = strlen (name);
 831       unsigned long int i;
 832
 833       if (var_name_is_insertable (dict, name))
 834         return true;
 835
 836       for (i = 0; i < ULONG_MAX; i++)
 837         {
 838           char suffix[INT_BUFSIZE_BOUND (i) + 1];
 839           int ofs;
 840
 841           suffix[0] = '_';
 842           if (!str_format_26adic (i + 1, &suffix[1], sizeof suffix - 1))
 843             NOT_REACHED ();
 844
 845           ofs = MIN (VAR_NAME_LEN - strlen (suffix), len);
 846           strcpy (&name[ofs], suffix);
 847
 848           if (var_name_is_insertable (dict, name))
 849             return true;
 850         }
 851     }
 852
 853   return false;
 854 }
 855
 856 static bool
 857 make_numeric_name (const struct dictionary *dict, unsigned long int *num_start,
 858                    char name[VAR_NAME_LEN + 1])
 859 {
 860   unsigned long int number;
 861
 862   for (number = num_start != NULL ? MAX (*num_start, 1) : 1;
 863        number < ULONG_MAX;
 864        number++)
 865     {
 866       sprintf (name, "VAR%03lu", number);
 867       if (dict_lookup_var (dict, name) == NULL)
 868         {
 869           if (num_start != NULL)
 870             *num_start = number + 1;
 871           return true;
 872         }
 873     }
 874
 875   if (num_start != NULL)
 876     *num_start = ULONG_MAX;
 877   return false;
 878 }
 879
 880
 881 /* Attempts to devise a variable name unique within DICT.
 882    Returns true if successful, in which case the new variable
 883    name is stored into NAME.  Returns false if all names that can
 884    be generated have already been taken.  (Returning false is
 885    quite unlikely: at least ULONG_MAX unique names can be
 886    generated.)
 887
 888    HINT, if it is non-null, is used as a suggestion that will be
 889    modified for suitability as a variable name and for
 890    uniqueness.
 891
 892    If HINT is null or entirely unsuitable, a name in the form
 893    "VAR%03d" will be generated, where the smallest unused integer
 894    value is used.  If NUM_START is non-null, then its value is
 895    used as the minimum numeric value to check, and it is updated
 896    to the next value to be checked.
 897    */
 898 bool
 899 dict_make_unique_var_name (const struct dictionary *dict, const char *hint,
 900                            unsigned long int *num_start,
 901                            char name[VAR_NAME_LEN + 1])
 902 {
 903   return ((hint != NULL && make_hinted_name (dict, hint, name))
 904           || make_numeric_name (dict, num_start, name));
 905 }
 906
 907 /* Returns the weighting variable in dictionary D, or a null
 908    pointer if the dictionary is unweighted. */
 909 struct variable *
 910 dict_get_weight (const struct dictionary *d)
 911 {
 912   assert (d != NULL);
 913   assert (d->weight == NULL || dict_contains_var (d, d->weight));
 914
 915   return d->weight;
 916 }
 917
 918 /* Returns the value of D's weighting variable in case C, except
 919    that a negative weight is returned as 0.  Returns 1 if the
 920    dictionary is unweighted.  Will warn about missing, negative,
 921    or zero values if *WARN_ON_INVALID is true.  The function will
 922    set *WARN_ON_INVALID to false if an invalid weight is
 923    found. */
 924 double
 925 dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
 926                       bool *warn_on_invalid)
 927 {
 928   assert (d != NULL);
 929   assert (c != NULL);
 930
 931   if (d->weight == NULL)
 932     return 1.0;
 933   else
 934     {
 935       double w = case_num (c, d->weight);
 936       if (w < 0.0 || var_is_num_missing (d->weight, w, MV_ANY))
 937         w = 0.0;
 938       if ( w == 0.0 && warn_on_invalid != NULL && *warn_on_invalid ) {
 939           *warn_on_invalid = false;
 940           msg (SW, _("At least one case in the data file had a weight value "
 941                      "that was user-missing, system-missing, zero, or "
 942                      "negative.  These case(s) were ignored."));
 943       }
 944       return w;
 945     }
 946 }
 947
 948 /* Sets the weighting variable of D to V, or turning off
 949    weighting if V is a null pointer. */
 950 void
 951 dict_set_weight (struct dictionary *d, struct variable *v)
 952 {
 953   assert (d != NULL);
 954   assert (v == NULL || dict_contains_var (d, v));
 955   assert (v == NULL || var_is_numeric (v));
 956
 957   d->weight = v;
 958
 959   if (d->changed) d->changed (d, d->changed_data);
 960   if ( d->callbacks &&  d->callbacks->weight_changed )
 961     d->callbacks->weight_changed (d,
 962                                   v ? var_get_dict_index (v) : -1,
 963                                   d->cb_data);
 964 }
 965
 966 /* Returns the filter variable in dictionary D (see cmd_filter())
 967    or a null pointer if the dictionary is unfiltered. */
 968 struct variable *
 969 dict_get_filter (const struct dictionary *d)
 970 {
 971   assert (d != NULL);
 972   assert (d->filter == NULL || dict_contains_var (d, d->filter));
 973
 974   return d->filter;
 975 }
 976
 977 /* Sets V as the filter variable for dictionary D.  Passing a
 978    null pointer for V turn off filtering. */
 979 void
 980 dict_set_filter (struct dictionary *d, struct variable *v)
 981 {
 982   assert (d != NULL);
 983   assert (v == NULL || dict_contains_var (d, v));
 984   assert (v == NULL || var_is_numeric (v));
 985
 986   d->filter = v;
 987
 988   if (d->changed) d->changed (d, d->changed_data);
 989   if ( d->callbacks && d->callbacks->filter_changed )
 990     d->callbacks->filter_changed (d,
 991                                   v ? var_get_dict_index (v) : -1,
 992                                   d->cb_data);
 993 }
 994
 995 /* Returns the case limit for dictionary D, or zero if the number
 996    of cases is unlimited. */
 997 casenumber
 998 dict_get_case_limit (const struct dictionary *d)
 999 {
1000   assert (d != NULL);
1001
1002   return d->case_limit;
1003 }
1004
1005 /* Sets CASE_LIMIT as the case limit for dictionary D.  Use
1006    0 for CASE_LIMIT to indicate no limit. */
1007 void
1008 dict_set_case_limit (struct dictionary *d, casenumber case_limit)
1009 {
1010   assert (d != NULL);
1011
1012   d->case_limit = case_limit;
1013 }
1014
1015 /* Returns the prototype used for cases created by dictionary D. */
1016 const struct caseproto *
1017 dict_get_proto (const struct dictionary *d_)
1018 {
1019   struct dictionary *d = (struct dictionary *) d_;
1020   if (d->proto == NULL)
1021     {
1022       size_t i;
1023
1024       d->proto = caseproto_create ();
1025       d->proto = caseproto_reserve (d->proto, d->var_cnt);
1026       for (i = 0; i < d->var_cnt; i++)
1027         d->proto = caseproto_set_width (d->proto,
1028                                         var_get_case_index (d->var[i]),
1029                                         var_get_width (d->var[i]));
1030     }
1031   return d->proto;
1032 }
1033
1034 /* Returns the case index of the next value to be added to D.
1035    This value is the number of `union value's that need to be
1036    allocated to store a case for dictionary D. */
1037 int
1038 dict_get_next_value_idx (const struct dictionary *d)
1039 {
1040   assert (d != NULL);
1041
1042   return d->next_value_idx;
1043 }
1044
1045 /* Returns the number of bytes needed to store a case for
1046    dictionary D. */
1047 size_t
1048 dict_get_case_size (const struct dictionary *d)
1049 {
1050   assert (d != NULL);
1051
1052   return sizeof (union value) * dict_get_next_value_idx (d);
1053 }
1054
1055 /* Reassigns values in dictionary D so that fragmentation is
1056    eliminated. */
1057 void
1058 dict_compact_values (struct dictionary *d)
1059 {
1060   size_t i;
1061
1062   d->next_value_idx = 0;
1063   for (i = 0; i < d->var_cnt; i++)
1064     {
1065       struct variable *v = d->var[i];
1066       set_var_case_index (v, d->next_value_idx++);
1067     }
1068   invalidate_proto (d);
1069 }
1070
1071 /* Returns the number of values occupied by the variables in
1072    dictionary D.  All variables are considered if EXCLUDE_CLASSES
1073    is 0, or it may contain one or more of (1u << DC_ORDINARY),
1074    (1u << DC_SYSTEM), or (1u << DC_SCRATCH) to exclude the
1075    corresponding type of variable.
1076
1077    The return value may be less than the number of values in one
1078    of dictionary D's cases (as returned by
1079    dict_get_next_value_idx) even if E is 0, because there may be
1080    gaps in D's cases due to deleted variables. */
1081 size_t
1082 dict_count_values (const struct dictionary *d, unsigned int exclude_classes)
1083 {
1084   size_t i;
1085   size_t cnt;
1086
1087   assert ((exclude_classes & ~((1u << DC_ORDINARY)
1088                                | (1u << DC_SYSTEM)
1089                                | (1u << DC_SCRATCH))) == 0);
1090
1091   cnt = 0;
1092   for (i = 0; i < d->var_cnt; i++)
1093     {
1094       enum dict_class class = var_get_dict_class (d->var[i]);
1095       if (!(exclude_classes & (1u << class)))
1096         cnt++;
1097     }
1098   return cnt;
1099 }
1100
1101 /* Returns the case prototype that would result after deleting
1102    all variables from D that are not in one of the
1103    EXCLUDE_CLASSES and compacting the dictionary with
1104    dict_compact().
1105
1106    The caller must unref the returned caseproto when it is no
1107    longer needed. */
1108 struct caseproto *
1109 dict_get_compacted_proto (const struct dictionary *d,
1110                           unsigned int exclude_classes)
1111 {
1112   struct caseproto *proto;
1113   size_t i;
1114
1115   assert ((exclude_classes & ~((1u << DC_ORDINARY)
1116                                | (1u << DC_SYSTEM)
1117                                | (1u << DC_SCRATCH))) == 0);
1118
1119   proto = caseproto_create ();
1120   for (i = 0; i < d->var_cnt; i++)
1121     {
1122       struct variable *v = d->var[i];
1123       if (!(exclude_classes & (1u << var_get_dict_class (v))))
1124         proto = caseproto_add_width (proto, var_get_width (v));
1125     }
1126   return proto;
1127 }
1128 \f
1129 /* Returns the SPLIT FILE vars (see cmd_split_file()).  Call
1130    dict_get_split_cnt() to determine how many SPLIT FILE vars
1131    there are.  Returns a null pointer if and only if there are no
1132    SPLIT FILE vars. */
1133 const struct variable *const *
1134 dict_get_split_vars (const struct dictionary *d)
1135 {
1136   assert (d != NULL);
1137
1138   return d->split;
1139 }
1140
1141 /* Returns the number of SPLIT FILE vars. */
1142 size_t
1143 dict_get_split_cnt (const struct dictionary *d)
1144 {
1145   assert (d != NULL);
1146
1147   return d->split_cnt;
1148 }
1149
1150 /* Removes variable V, which must be in D, from D's set of split
1151    variables. */
1152 void
1153 dict_unset_split_var (struct dictionary *d, struct variable *v)
1154 {
1155   int orig_count;
1156
1157   assert (dict_contains_var (d, v));
1158
1159   orig_count = d->split_cnt;
1160   d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split,
1161                                &v, compare_var_ptrs, NULL);
1162   if (orig_count != d->split_cnt)
1163     {
1164       if (d->changed) d->changed (d, d->changed_data);
1165       /* We changed the set of split variables so invoke the
1166          callback. */
1167       if (d->callbacks &&  d->callbacks->split_changed)
1168         d->callbacks->split_changed (d, d->cb_data);
1169     }
1170 }
1171
1172 /* Sets CNT split vars SPLIT in dictionary D. */
1173 void
1174 dict_set_split_vars (struct dictionary *d,
1175                      struct variable *const *split, size_t cnt)
1176 {
1177   assert (d != NULL);
1178   assert (cnt == 0 || split != NULL);
1179
1180   d->split_cnt = cnt;
1181   if ( cnt > 0 )
1182    {
1183     d->split = xnrealloc (d->split, cnt, sizeof *d->split) ;
1184     memcpy (d->split, split, cnt * sizeof *d->split);
1185    }
1186   else
1187    {
1188     free (d->split);
1189     d->split = NULL;
1190    }
1191
1192   if (d->changed) d->changed (d, d->changed_data);
1193   if ( d->callbacks &&  d->callbacks->split_changed )
1194     d->callbacks->split_changed (d, d->cb_data);
1195 }
1196
1197 /* Returns the file label for D, or a null pointer if D is
1198    unlabeled (see cmd_file_label()). */
1199 const char *
1200 dict_get_label (const struct dictionary *d)
1201 {
1202   assert (d != NULL);
1203
1204   return d->label;
1205 }
1206
1207 /* Sets D's file label to LABEL, truncating it to a maximum of 60
1208    characters. */
1209 void
1210 dict_set_label (struct dictionary *d, const char *label)
1211 {
1212   assert (d != NULL);
1213
1214   free (d->label);
1215   d->label = label != NULL ? xstrndup (label, 60) : NULL;
1216 }
1217
1218 /* Returns the documents for D, or a null pointer if D has no
1219    documents.  If the return value is nonnull, then the string
1220    will be an exact multiple of DOC_LINE_LENGTH bytes in length,
1221    with each segment corresponding to one line. */
1222 const char *
1223 dict_get_documents (const struct dictionary *d)
1224 {
1225   return ds_is_empty (&d->documents) ? NULL : ds_cstr (&d->documents);
1226 }
1227
1228 /* Sets the documents for D to DOCUMENTS, or removes D's
1229    documents if DOCUMENT is a null pointer.  If DOCUMENTS is
1230    nonnull, then it should be an exact multiple of
1231    DOC_LINE_LENGTH bytes in length, with each segment
1232    corresponding to one line. */
1233 void
1234 dict_set_documents (struct dictionary *d, const char *documents)
1235 {
1236   size_t remainder;
1237
1238   ds_assign_cstr (&d->documents, documents != NULL ? documents : "");
1239
1240   /* In case the caller didn't get it quite right, pad out the
1241      final line with spaces. */
1242   remainder = ds_length (&d->documents) % DOC_LINE_LENGTH;
1243   if (remainder != 0)
1244     ds_put_char_multiple (&d->documents, ' ', DOC_LINE_LENGTH - remainder);
1245 }
1246
1247 /* Drops the documents from dictionary D. */
1248 void
1249 dict_clear_documents (struct dictionary *d)
1250 {
1251   ds_clear (&d->documents);
1252 }
1253
1254 /* Appends LINE to the documents in D.  LINE will be truncated or
1255    padded on the right with spaces to make it exactly
1256    DOC_LINE_LENGTH bytes long. */
1257 void
1258 dict_add_document_line (struct dictionary *d, const char *line)
1259 {
1260   if (strlen (line) > DOC_LINE_LENGTH)
1261     {
1262       /* Note to translators: "bytes" is correct, not characters */
1263       msg (SW, _("Truncating document line to %d bytes."), DOC_LINE_LENGTH);
1264     }
1265   buf_copy_str_rpad (ds_put_uninit (&d->documents, DOC_LINE_LENGTH),
1266                      DOC_LINE_LENGTH, line, ' ');
1267 }
1268
1269 /* Returns the number of document lines in dictionary D. */
1270 size_t
1271 dict_get_document_line_cnt (const struct dictionary *d)
1272 {
1273   return ds_length (&d->documents) / DOC_LINE_LENGTH;
1274 }
1275
1276 /* Copies document line number IDX from dictionary D into
1277    LINE, trimming off any trailing white space. */
1278 void
1279 dict_get_document_line (const struct dictionary *d,
1280                         size_t idx, struct string *line)
1281 {
1282   assert (idx < dict_get_document_line_cnt (d));
1283   ds_assign_substring (line, ds_substr (&d->documents, idx * DOC_LINE_LENGTH,
1284                                         DOC_LINE_LENGTH));
1285   ds_rtrim (line, ss_cstr (CC_SPACES));
1286 }
1287
1288 /* Creates in D a vector named NAME that contains the CNT
1289    variables in VAR.  Returns true if successful, or false if a
1290    vector named NAME already exists in D. */
1291 bool
1292 dict_create_vector (struct dictionary *d,
1293                     const char *name,
1294                     struct variable **var, size_t cnt)
1295 {
1296   size_t i;
1297
1298   assert (var != NULL);
1299   assert (cnt > 0);
1300   for (i = 0; i < cnt; i++)
1301     assert (dict_contains_var (d, var[i]));
1302
1303   if (dict_lookup_vector (d, name) == NULL)
1304     {
1305       d->vector = xnrealloc (d->vector, d->vector_cnt + 1, sizeof *d->vector);
1306       d->vector[d->vector_cnt++] = vector_create (name, var, cnt);
1307       return true;
1308     }
1309   else
1310     return false;
1311 }
1312
1313 /* Creates in D a vector named NAME that contains the CNT
1314    variables in VAR.  A vector named NAME must not already exist
1315    in D. */
1316 void
1317 dict_create_vector_assert (struct dictionary *d,
1318                            const char *name,
1319                            struct variable **var, size_t cnt)
1320 {
1321   assert (dict_lookup_vector (d, name) == NULL);
1322   dict_create_vector (d, name, var, cnt);
1323 }
1324
1325 /* Returns the vector in D with index IDX, which must be less
1326    than dict_get_vector_cnt (D). */
1327 const struct vector *
1328 dict_get_vector (const struct dictionary *d, size_t idx)
1329 {
1330   assert (d != NULL);
1331   assert (idx < d->vector_cnt);
1332
1333   return d->vector[idx];
1334 }
1335
1336 /* Returns the number of vectors in D. */
1337 size_t
1338 dict_get_vector_cnt (const struct dictionary *d)
1339 {
1340   assert (d != NULL);
1341
1342   return d->vector_cnt;
1343 }
1344
1345 /* Looks up and returns the vector within D with the given
1346    NAME. */
1347 const struct vector *
1348 dict_lookup_vector (const struct dictionary *d, const char *name)
1349 {
1350   size_t i;
1351   for (i = 0; i < d->vector_cnt; i++)
1352     if (!strcasecmp (vector_get_name (d->vector[i]), name))
1353       return d->vector[i];
1354   return NULL;
1355 }
1356
1357 /* Deletes all vectors from D. */
1358 void
1359 dict_clear_vectors (struct dictionary *d)
1360 {
1361   size_t i;
1362
1363   for (i = 0; i < d->vector_cnt; i++)
1364     vector_destroy (d->vector[i]);
1365   free (d->vector);
1366
1367   d->vector = NULL;
1368   d->vector_cnt = 0;
1369 }
1370
1371 /* Returns D's attribute set.  The caller may examine or modify
1372    the attribute set, but must not destroy it.  Destroying D or
1373    calling dict_set_attributes for D will also destroy D's
1374    attribute set. */
1375 struct attrset *
1376 dict_get_attributes (const struct dictionary *d)
1377 {
1378   return (struct attrset *) &d->attributes;
1379 }
1380
1381 /* Replaces D's attributes set by a copy of ATTRS. */
1382 void
1383 dict_set_attributes (struct dictionary *d, const struct attrset *attrs)
1384 {
1385   attrset_destroy (&d->attributes);
1386   attrset_clone (&d->attributes, attrs);
1387 }
1388
1389 /* Returns true if D has at least one attribute in its attribute
1390    set, false if D's attribute set is empty. */
1391 bool
1392 dict_has_attributes (const struct dictionary *d)
1393 {
1394   return attrset_count (&d->attributes) > 0;
1395 }
1396
1397 /* Called from variable.c to notify the dictionary that some property of
1398    the variable has changed */
1399 void
1400 dict_var_changed (const struct variable *v)
1401 {
1402   if ( var_has_vardict (v))
1403     {
1404       const struct vardict_info *vdi = var_get_vardict (v);
1405       struct dictionary *d = vdi->dict;
1406
1407       if ( NULL == d)
1408         return;
1409
1410       if (d->changed ) d->changed (d, d->changed_data);
1411       if ( d->callbacks && d->callbacks->var_changed )
1412         d->callbacks->var_changed (d, var_get_dict_index (v), d->cb_data);
1413     }
1414 }
1415
1416
1417 /* Called from variable.c to notify the dictionary that the variable's width
1418    has changed */
1419 void
1420 dict_var_resized (const struct variable *v, int old_width)
1421 {
1422   if ( var_has_vardict (v))
1423     {
1424       const struct vardict_info *vdi = var_get_vardict (v);
1425       struct dictionary *d;
1426
1427       d = vdi->dict;
1428
1429       if (d->changed) d->changed (d, d->changed_data);
1430
1431       invalidate_proto (d);
1432       if ( d->callbacks && d->callbacks->var_resized )
1433         d->callbacks->var_resized (d, var_get_dict_index (v), old_width,
1434                                    d->cb_data);
1435     }
1436 }
1437
1438 /* Called from variable.c to notify the dictionary that the variable's display width
1439    has changed */
1440 void
1441 dict_var_display_width_changed (const struct variable *v)
1442 {
1443   if ( var_has_vardict (v))
1444     {
1445       const struct vardict_info *vdi = var_get_vardict (v);
1446       struct dictionary *d;
1447
1448       d = vdi->dict;
1449
1450       if (d->changed) d->changed (d, d->changed_data);
1451       if ( d->callbacks && d->callbacks->var_display_width_changed )
1452         d->callbacks->var_display_width_changed (d, var_get_dict_index (v), d->cb_data);
1453     }
1454 }
1455