src/data/dictionary.c

   1 /* PSPP - computes sample statistics.
   2    Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
   3    Written by Ben Pfaff <blp@gnu.org>.
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18    02110-1301, USA. */
  19
  20 #include <config.h>
  21 #include "dictionary.h"
  22 #include <stdlib.h>
  23 #include <ctype.h>
  24 #include "array.h"
  25 #include "alloc.h"
  26 #include "case.h"
  27 #include "category.h"
  28 #include "cat-routines.h"
  29 #include "message.h"
  30 #include "hash.h"
  31 #include "misc.h"
  32 #include "settings.h"
  33 #include "str.h"
  34 #include "value-labels.h"
  35 #include "variable.h"
  36
  37 #include "gettext.h"
  38 #define _(msgid) gettext (msgid)
  39
  40 /* A dictionary. */
  41 struct dictionary
  42   {
  43     struct variable **var;      /* Variables. */
  44     size_t var_cnt, var_cap;    /* Number of variables, capacity. */
  45     struct hsh_table *name_tab; /* Variable index by name. */
  46     int next_value_idx;         /* Index of next `union value' to allocate. */
  47     struct variable **split;    /* SPLIT FILE vars. */
  48     size_t split_cnt;           /* SPLIT FILE count. */
  49     struct variable *weight;    /* WEIGHT variable. */
  50     struct variable *filter;    /* FILTER variable. */
  51     int case_limit;             /* Current case limit (N command). */
  52     char *label;                /* File label. */
  53     char *documents;            /* Documents, as a string. */
  54     struct vector **vector;     /* Vectors of variables. */
  55     size_t vector_cnt;          /* Number of vectors. */
  56   };
  57
  58 /* Active file dictionary. */
  59 struct dictionary *default_dict;
  60
  61 /* Creates and returns a new dictionary. */
  62 struct dictionary *
  63 dict_create (void)
  64 {
  65   struct dictionary *d = xmalloc (sizeof *d);
  66
  67   d->var = NULL;
  68   d->var_cnt = d->var_cap = 0;
  69   d->name_tab = hsh_create (8, compare_var_names, hash_var_name, NULL, NULL);
  70   d->next_value_idx = 0;
  71   d->split = NULL;
  72   d->split_cnt = 0;
  73   d->weight = NULL;
  74   d->filter = NULL;
  75   d->case_limit = 0;
  76   d->label = NULL;
  77   d->documents = NULL;
  78   d->vector = NULL;
  79   d->vector_cnt = 0;
  80
  81   return d;
  82 }
  83
  84 /* Creates and returns a (deep) copy of an existing
  85    dictionary. */
  86 struct dictionary *
  87 dict_clone (const struct dictionary *s)
  88 {
  89   struct dictionary *d;
  90   size_t i;
  91
  92   assert (s != NULL);
  93
  94   d = dict_create ();
  95
  96   for (i = 0; i < s->var_cnt; i++)
  97     {
  98       struct variable *sv = s->var[i];
  99       struct variable *dv = dict_clone_var_assert (d, sv, sv->name);
 100       var_set_short_name (dv, sv->short_name);
 101     }
 102
 103   d->next_value_idx = s->next_value_idx;
 104
 105   d->split_cnt = s->split_cnt;
 106   if (d->split_cnt > 0)
 107     {
 108       d->split = xnmalloc (d->split_cnt, sizeof *d->split);
 109       for (i = 0; i < d->split_cnt; i++)
 110         d->split[i] = dict_lookup_var_assert (d, s->split[i]->name);
 111     }
 112
 113   if (s->weight != NULL)
 114     d->weight = dict_lookup_var_assert (d, s->weight->name);
 115
 116   if (s->filter != NULL)
 117     d->filter = dict_lookup_var_assert (d, s->filter->name);
 118
 119   d->case_limit = s->case_limit;
 120   dict_set_label (d, dict_get_label (s));
 121   dict_set_documents (d, dict_get_documents (s));
 122
 123   d->vector_cnt = s->vector_cnt;
 124   d->vector = xnmalloc (d->vector_cnt, sizeof *d->vector);
 125   for (i = 0; i < s->vector_cnt; i++)
 126     {
 127       struct vector *sv = s->vector[i];
 128       struct vector *dv = d->vector[i] = xmalloc (sizeof *dv);
 129       int j;
 130
 131       dv->idx = i;
 132       strcpy (dv->name, sv->name);
 133       dv->cnt = sv->cnt;
 134       dv->var = xnmalloc (dv->cnt, sizeof *dv->var);
 135       for (j = 0; j < dv->cnt; j++)
 136         dv->var[j] = d->var[sv->var[j]->index];
 137     }
 138
 139   return d;
 140 }
 141
 142 /* Clears the contents from a dictionary without destroying the
 143    dictionary itself. */
 144 void
 145 dict_clear (struct dictionary *d)
 146 {
 147   /* FIXME?  Should we really clear case_limit, label, documents?
 148      Others are necessarily cleared by deleting all the variables.*/
 149   int i;
 150
 151   assert (d != NULL);
 152
 153   for (i = 0; i < d->var_cnt; i++)
 154     {
 155       struct variable *v = d->var[i];
 156       var_clear_aux (v);
 157       val_labs_destroy (v->val_labs);
 158       free (v->label);
 159       free (v);
 160     }
 161   free (d->var);
 162   d->var = NULL;
 163   d->var_cnt = d->var_cap = 0;
 164   hsh_clear (d->name_tab);
 165   d->next_value_idx = 0;
 166   free (d->split);
 167   d->split = NULL;
 168   d->split_cnt = 0;
 169   d->weight = NULL;
 170   d->filter = NULL;
 171   d->case_limit = 0;
 172   free (d->label);
 173   d->label = NULL;
 174   free (d->documents);
 175   d->documents = NULL;
 176   dict_clear_vectors (d);
 177 }
 178
 179 /* Destroys the aux data for every variable in D, by calling
 180    var_clear_aux() for each variable. */
 181 void
 182 dict_clear_aux (struct dictionary *d)
 183 {
 184   int i;
 185
 186   assert (d != NULL);
 187
 188   for (i = 0; i < d->var_cnt; i++)
 189     var_clear_aux (d->var[i]);
 190 }
 191
 192 /* Clears a dictionary and destroys it. */
 193 void
 194 dict_destroy (struct dictionary *d)
 195 {
 196   if (d != NULL)
 197     {
 198       dict_clear (d);
 199       hsh_destroy (d->name_tab);
 200       free (d);
 201     }
 202 }
 203
 204 /* Returns the number of variables in D. */
 205 size_t
 206 dict_get_var_cnt (const struct dictionary *d)
 207 {
 208   assert (d != NULL);
 209
 210   return d->var_cnt;
 211 }
 212
 213 /* Returns the variable in D with index IDX, which must be
 214    between 0 and the count returned by dict_get_var_cnt(),
 215    exclusive. */
 216 struct variable *
 217 dict_get_var (const struct dictionary *d, size_t idx)
 218 {
 219   assert (d != NULL);
 220   assert (idx < d->var_cnt);
 221
 222   return d->var[idx];
 223 }
 224
 225 /* Sets *VARS to an array of pointers to variables in D and *CNT
 226    to the number of variables in *D.  By default all variables
 227    are returned, but bits may be set in EXCLUDE_CLASSES to
 228    exclude ordinary, system, and/or scratch variables. */
 229 void
 230 dict_get_vars (const struct dictionary *d, struct variable ***vars,
 231                size_t *cnt, unsigned exclude_classes)
 232 {
 233   size_t count;
 234   size_t i;
 235
 236   assert (d != NULL);
 237   assert (vars != NULL);
 238   assert (cnt != NULL);
 239   assert ((exclude_classes & ~((1u << DC_ORDINARY)
 240                                | (1u << DC_SYSTEM)
 241                                | (1u << DC_SCRATCH))) == 0);
 242
 243   count = 0;
 244   for (i = 0; i < d->var_cnt; i++)
 245     if (!(exclude_classes & (1u << dict_class_from_id (d->var[i]->name))))
 246       count++;
 247
 248   *vars = xnmalloc (count, sizeof **vars);
 249   *cnt = 0;
 250   for (i = 0; i < d->var_cnt; i++)
 251     if (!(exclude_classes & (1u << dict_class_from_id (d->var[i]->name))))
 252       (*vars)[(*cnt)++] = d->var[i];
 253   assert (*cnt == count);
 254 }
 255
 256
 257 /* Creates and returns a new variable in D with the given NAME
 258    and WIDTH.  Returns a null pointer if the given NAME would
 259    duplicate that of an existing variable in the dictionary. */
 260 struct variable *
 261 dict_create_var (struct dictionary *d, const char *name, int width)
 262 {
 263   struct variable *v;
 264
 265   assert (d != NULL);
 266   assert (name != NULL);
 267
 268   assert (width >= 0 && width < 256);
 269
 270   assert (var_is_valid_name(name,0));
 271
 272   /* Make sure there's not already a variable by that name. */
 273   if (dict_lookup_var (d, name) != NULL)
 274     return NULL;
 275
 276   /* Allocate and initialize variable. */
 277   v = xmalloc (sizeof *v);
 278   str_copy_trunc (v->name, sizeof v->name, name);
 279   v->type = width == 0 ? NUMERIC : ALPHA;
 280   v->width = width;
 281   v->fv = d->next_value_idx;
 282   v->nv = width == 0 ? 1 : DIV_RND_UP (width, 8);
 283   v->init = 1;
 284   v->reinit = dict_class_from_id (v->name) != DC_SCRATCH;
 285   v->index = d->var_cnt;
 286   mv_init (&v->miss, width);
 287   if (v->type == NUMERIC)
 288     {
 289       v->print = f8_2;
 290       v->alignment = ALIGN_RIGHT;
 291       v->display_width = 8;
 292       v->measure = MEASURE_SCALE;
 293     }
 294   else
 295     {
 296       v->print = make_output_format (FMT_A, v->width, 0);
 297       v->alignment = ALIGN_LEFT;
 298       v->display_width = 8;
 299       v->measure = MEASURE_NOMINAL;
 300     }
 301   v->write = v->print;
 302   v->val_labs = val_labs_create (v->width);
 303   v->label = NULL;
 304   var_clear_short_name (v);
 305   v->aux = NULL;
 306   v->aux_dtor = NULL;
 307   v->obs_vals = NULL;
 308
 309   /* Update dictionary. */
 310   if (d->var_cnt >= d->var_cap)
 311     {
 312       d->var_cap = 8 + 2 * d->var_cap;
 313       d->var = xnrealloc (d->var, d->var_cap, sizeof *d->var);
 314     }
 315   d->var[v->index] = v;
 316   d->var_cnt++;
 317   hsh_force_insert (d->name_tab, v);
 318
 319   d->next_value_idx += v->nv;
 320
 321   return v;
 322 }
 323
 324 /* Creates and returns a new variable in D with the given NAME
 325    and WIDTH.  Assert-fails if the given NAME would duplicate
 326    that of an existing variable in the dictionary. */
 327 struct variable *
 328 dict_create_var_assert (struct dictionary *d, const char *name, int width)
 329 {
 330   struct variable *v = dict_create_var (d, name, width);
 331   assert (v != NULL);
 332   return v;
 333 }
 334
 335 /* Creates and returns a new variable in D with name NAME, as a
 336    copy of existing variable OV, which need not be in D or in any
 337    dictionary.  Returns a null pointer if the given NAME would
 338    duplicate that of an existing variable in the dictionary. */
 339 struct variable *
 340 dict_clone_var (struct dictionary *d, const struct variable *ov,
 341                 const char *name)
 342 {
 343   struct variable *nv;
 344
 345   assert (d != NULL);
 346   assert (ov != NULL);
 347   assert (name != NULL);
 348
 349   assert (strlen (name) >= 1);
 350   assert (strlen (name) <= LONG_NAME_LEN);
 351
 352   nv = dict_create_var (d, name, ov->width);
 353   if (nv == NULL)
 354     return NULL;
 355
 356   /* Copy most members not copied via dict_create_var().
 357      short_name[] is intentionally not copied, because there is
 358      no reason to give a new variable with potentially a new name
 359      the same short name. */
 360   nv->init = 1;
 361   nv->reinit = ov->reinit;
 362   mv_copy (&nv->miss, &ov->miss);
 363   nv->print = ov->print;
 364   nv->write = ov->write;
 365   val_labs_destroy (nv->val_labs);
 366   nv->val_labs = val_labs_copy (ov->val_labs);
 367   if (ov->label != NULL)
 368     nv->label = xstrdup (ov->label);
 369   nv->measure = ov->measure;
 370   nv->display_width = ov->display_width;
 371   nv->alignment = ov->alignment;
 372
 373   return nv;
 374 }
 375
 376 /* Creates and returns a new variable in D with name NAME, as a
 377    copy of existing variable OV, which need not be in D or in any
 378    dictionary.  Assert-fails if the given NAME would duplicate
 379    that of an existing variable in the dictionary. */
 380 struct variable *
 381 dict_clone_var_assert (struct dictionary *d, const struct variable *ov,
 382                        const char *name)
 383 {
 384   struct variable *v = dict_clone_var (d, ov, name);
 385   assert (v != NULL);
 386   return v;
 387 }
 388
 389 /* Returns the variable named NAME in D, or a null pointer if no
 390    variable has that name. */
 391 struct variable *
 392 dict_lookup_var (const struct dictionary *d, const char *name)
 393 {
 394   struct variable v;
 395
 396   assert (d != NULL);
 397   assert (name != NULL);
 398
 399   str_copy_trunc (v.name, sizeof v.name, name);
 400   return hsh_find (d->name_tab, &v);
 401 }
 402
 403 /* Returns the variable named NAME in D.  Assert-fails if no
 404    variable has that name. */
 405 struct variable *
 406 dict_lookup_var_assert (const struct dictionary *d, const char *name)
 407 {
 408   struct variable *v = dict_lookup_var (d, name);
 409   assert (v != NULL);
 410   return v;
 411 }
 412
 413 /* Returns true if variable V is in dictionary D,
 414    false otherwise. */
 415 bool
 416 dict_contains_var (const struct dictionary *d, const struct variable *v)
 417 {
 418   assert (d != NULL);
 419   assert (v != NULL);
 420
 421   return v->index >= 0 && v->index < d->var_cnt && d->var[v->index] == v;
 422 }
 423
 424 /* Compares two double pointers to variables, which should point
 425    to elements of a struct dictionary's `var' member array. */
 426 static int
 427 compare_var_ptrs (const void *a_, const void *b_, void *aux UNUSED)
 428 {
 429   struct variable *const *a = a_;
 430   struct variable *const *b = b_;
 431
 432   return *a < *b ? -1 : *a > *b;
 433 }
 434
 435 /* Deletes variable V from dictionary D and frees V.
 436
 437    This is a very bad idea if there might be any pointers to V
 438    from outside D.  In general, no variable in default_dict
 439    should be deleted when any transformations are active, because
 440    those transformations might reference the deleted variable.
 441    The safest time to delete a variable is just after a procedure
 442    has been executed, as done by MODIFY VARS.
 443
 444    Pointers to V within D are not a problem, because
 445    dict_delete_var() knows to remove V from split variables,
 446    weights, filters, etc. */
 447 void
 448 dict_delete_var (struct dictionary *d, struct variable *v)
 449 {
 450   size_t i;
 451
 452   assert (d != NULL);
 453   assert (v != NULL);
 454   assert (dict_contains_var (d, v));
 455
 456   /* Delete aux data. */
 457   var_clear_aux (v);
 458
 459   /* Remove V from splits, weight, filter variables. */
 460   d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split,
 461                                &v, compare_var_ptrs, NULL);
 462   if (d->weight == v)
 463     d->weight = NULL;
 464   if (d->filter == v)
 465     d->filter = NULL;
 466   dict_clear_vectors (d);
 467
 468   /* Remove V from var array. */
 469   remove_element (d->var, d->var_cnt, sizeof *d->var, v->index);
 470   d->var_cnt--;
 471
 472   /* Update index. */
 473   for (i = v->index; i < d->var_cnt; i++)
 474     d->var[i]->index = i;
 475
 476   /* Update name hash. */
 477   hsh_force_delete (d->name_tab, v);
 478
 479   /* Free memory. */
 480   val_labs_destroy (v->val_labs);
 481   cat_stored_values_destroy (v);
 482   free (v->label);
 483   free (v);
 484 }
 485
 486 /* Deletes the COUNT variables listed in VARS from D.  This is
 487    unsafe; see the comment on dict_delete_var() for details. */
 488 void
 489 dict_delete_vars (struct dictionary *d,
 490                   struct variable *const *vars, size_t count)
 491 {
 492   /* FIXME: this can be done in O(count) time, but this algorithm
 493      is O(count**2). */
 494   assert (d != NULL);
 495   assert (count == 0 || vars != NULL);
 496
 497   while (count-- > 0)
 498     dict_delete_var (d, *vars++);
 499 }
 500
 501 /* Deletes scratch variables from dictionary D. */
 502 void
 503 dict_delete_scratch_vars (struct dictionary *d)
 504 {
 505   int i;
 506
 507   /* FIXME: this can be done in O(count) time, but this algorithm
 508      is O(count**2). */
 509   assert (d != NULL);
 510
 511   for (i = 0; i < d->var_cnt; )
 512     if (dict_class_from_id (d->var[i]->name) == DC_SCRATCH)
 513       dict_delete_var (d, d->var[i]);
 514     else
 515       i++;
 516 }
 517
 518 /* Moves V to 0-based position IDX in D.  Other variables in D,
 519    if any, retain their relative positions.  Runs in time linear
 520    in the distance moved. */
 521 void
 522 dict_reorder_var (struct dictionary *d, struct variable *v,
 523                   size_t new_index)
 524 {
 525   size_t min_idx, max_idx;
 526   size_t i;
 527
 528   assert (d != NULL);
 529   assert (v != NULL);
 530   assert (dict_contains_var (d, v));
 531   assert (new_index < d->var_cnt);
 532
 533   move_element (d->var, d->var_cnt, sizeof *d->var, v->index, new_index);
 534
 535   min_idx = min (v->index, new_index);
 536   max_idx = max (v->index, new_index);
 537   for (i = min_idx; i <= max_idx; i++)
 538     d->var[i]->index = i;
 539 }
 540
 541 /* Reorders the variables in D, placing the COUNT variables
 542    listed in ORDER in that order at the beginning of D.  The
 543    other variables in D, if any, retain their relative
 544    positions. */
 545 void
 546 dict_reorder_vars (struct dictionary *d,
 547                    struct variable *const *order, size_t count)
 548 {
 549   struct variable **new_var;
 550   size_t i;
 551
 552   assert (d != NULL);
 553   assert (count == 0 || order != NULL);
 554   assert (count <= d->var_cnt);
 555
 556   new_var = xnmalloc (d->var_cnt, sizeof *new_var);
 557   memcpy (new_var, order, count * sizeof *new_var);
 558   for (i = 0; i < count; i++)
 559     {
 560       assert (d->var[order[i]->index] != NULL);
 561       d->var[order[i]->index] = NULL;
 562       order[i]->index = i;
 563     }
 564   for (i = 0; i < d->var_cnt; i++)
 565     if (d->var[i] != NULL)
 566       {
 567         assert (count < d->var_cnt);
 568         new_var[count] = d->var[i];
 569         new_var[count]->index = count;
 570         count++;
 571       }
 572   free (d->var);
 573   d->var = new_var;
 574 }
 575
 576 /* Changes the name of V in D to name NEW_NAME.  Assert-fails if
 577    a variable named NEW_NAME is already in D, except that
 578    NEW_NAME may be the same as V's existing name. */
 579 void
 580 dict_rename_var (struct dictionary *d, struct variable *v,
 581                  const char *new_name)
 582 {
 583   assert (d != NULL);
 584   assert (v != NULL);
 585   assert (new_name != NULL);
 586   assert (var_is_valid_name (new_name, false));
 587   assert (dict_contains_var (d, v));
 588   assert (!compare_var_names (v->name, new_name, NULL)
 589           || dict_lookup_var (d, new_name) == NULL);
 590
 591   hsh_force_delete (d->name_tab, v);
 592   str_copy_trunc (v->name, sizeof v->name, new_name);
 593   hsh_force_insert (d->name_tab, v);
 594
 595   if (get_algorithm () == ENHANCED)
 596     var_clear_short_name (v);
 597 }
 598
 599 /* Renames COUNT variables specified in VARS to the names given
 600    in NEW_NAMES within dictionary D.  If the renaming would
 601    result in a duplicate variable name, returns false and stores a
 602    name that would be duplicated into *ERR_NAME (if ERR_NAME is
 603    non-null).  Otherwise, the renaming is successful, and true
 604    is returned. */
 605 bool
 606 dict_rename_vars (struct dictionary *d,
 607                   struct variable **vars, char **new_names,
 608                   size_t count, char **err_name)
 609 {
 610   char **old_names;
 611   size_t i;
 612   bool success = true;
 613
 614   assert (d != NULL);
 615   assert (count == 0 || vars != NULL);
 616   assert (count == 0 || new_names != NULL);
 617
 618   /* Remove the variables to be renamed from the name hash,
 619      save their names, and rename them. */
 620   old_names = xnmalloc (count, sizeof *old_names);
 621   for (i = 0; i < count; i++)
 622     {
 623       assert (d->var[vars[i]->index] == vars[i]);
 624       assert (var_is_valid_name (new_names[i], false));
 625       hsh_force_delete (d->name_tab, vars[i]);
 626       old_names[i] = xstrdup (vars[i]->name);
 627       strcpy (vars[i]->name, new_names[i]);
 628     }
 629
 630   /* Add the renamed variables back into the name hash,
 631      checking for conflicts. */
 632   for (i = 0; i < count; i++)
 633     {
 634       assert (new_names[i] != NULL);
 635       assert (*new_names[i] != '\0');
 636       assert (strlen (new_names[i]) >= 1);
 637       assert (strlen (new_names[i]) <= LONG_NAME_LEN);
 638
 639       if (hsh_insert (d->name_tab, vars[i]) != NULL)
 640         {
 641           /* There is a name conflict.
 642              Back out all the name changes that have already
 643              taken place, and indicate failure. */
 644           size_t fail_idx = i;
 645           if (err_name != NULL)
 646             *err_name = new_names[i];
 647
 648           for (i = 0; i < fail_idx; i++)
 649             hsh_force_delete (d->name_tab, vars[i]);
 650
 651           for (i = 0; i < count; i++)
 652             {
 653               strcpy (vars[i]->name, old_names[i]);
 654               hsh_force_insert (d->name_tab, vars[i]);
 655             }
 656
 657           success = false;
 658           goto done;
 659         }
 660     }
 661
 662   /* Clear short names. */
 663   if (get_algorithm () == ENHANCED)
 664     for (i = 0; i < count; i++)
 665       var_clear_short_name (vars[i]);
 666
 667  done:
 668   /* Free the old names we kept around. */
 669   for (i = 0; i < count; i++)
 670     free (old_names[i]);
 671   free (old_names);
 672
 673   return success;
 674 }
 675
 676 /* Returns the weighting variable in dictionary D, or a null
 677    pointer if the dictionary is unweighted. */
 678 struct variable *
 679 dict_get_weight (const struct dictionary *d)
 680 {
 681   assert (d != NULL);
 682   assert (d->weight == NULL || dict_contains_var (d, d->weight));
 683
 684   return d->weight;
 685 }
 686
 687 /* Returns the value of D's weighting variable in case C, except that a
 688    negative weight is returned as 0.  Returns 1 if the dictionary is
 689    unweighted. Will warn about missing, negative, or zero values if
 690    warn_on_invalid is nonzero. The function will set warn_on_invalid to zero
 691    if an invalid weight is found. */
 692 double
 693 dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
 694                       int *warn_on_invalid)
 695 {
 696   assert (d != NULL);
 697   assert (c != NULL);
 698
 699   if (d->weight == NULL)
 700     return 1.0;
 701   else
 702     {
 703       double w = case_num (c, d->weight->fv);
 704       if (w < 0.0 || mv_is_num_missing (&d->weight->miss, w))
 705         w = 0.0;
 706       if ( w == 0.0 && *warn_on_invalid ) {
 707           *warn_on_invalid = 0;
 708           msg (SW, _("At least one case in the data file had a weight value "
 709                      "that was user-missing, system-missing, zero, or "
 710                      "negative.  These case(s) were ignored."));
 711       }
 712       return w;
 713     }
 714 }
 715
 716 /* Sets the weighting variable of D to V, or turning off
 717    weighting if V is a null pointer. */
 718 void
 719 dict_set_weight (struct dictionary *d, struct variable *v)
 720 {
 721   assert (d != NULL);
 722   assert (v == NULL || dict_contains_var (d, v));
 723   assert (v == NULL || v->type == NUMERIC);
 724
 725   d->weight = v;
 726 }
 727
 728 /* Returns the filter variable in dictionary D (see cmd_filter())
 729    or a null pointer if the dictionary is unfiltered. */
 730 struct variable *
 731 dict_get_filter (const struct dictionary *d)
 732 {
 733   assert (d != NULL);
 734   assert (d->filter == NULL || dict_contains_var (d, d->filter));
 735
 736   return d->filter;
 737 }
 738
 739 /* Sets V as the filter variable for dictionary D.  Passing a
 740    null pointer for V turn off filtering. */
 741 void
 742 dict_set_filter (struct dictionary *d, struct variable *v)
 743 {
 744   assert (d != NULL);
 745   assert (v == NULL || dict_contains_var (d, v));
 746
 747   d->filter = v;
 748 }
 749
 750 /* Returns the case limit for dictionary D, or zero if the number
 751    of cases is unlimited (see cmd_n()). */
 752 int
 753 dict_get_case_limit (const struct dictionary *d)
 754 {
 755   assert (d != NULL);
 756
 757   return d->case_limit;
 758 }
 759
 760 /* Sets CASE_LIMIT as the case limit for dictionary D.  Zero for
 761    CASE_LIMIT indicates no limit. */
 762 void
 763 dict_set_case_limit (struct dictionary *d, int case_limit)
 764 {
 765   assert (d != NULL);
 766   assert (case_limit >= 0);
 767
 768   d->case_limit = case_limit;
 769 }
 770
 771 /* Returns the index of the next value to be added to D.  This
 772    value is the number of `union value's that need to be
 773    allocated to store a case for dictionary D. */
 774 int
 775 dict_get_next_value_idx (const struct dictionary *d)
 776 {
 777   assert (d != NULL);
 778
 779   return d->next_value_idx;
 780 }
 781
 782 /* Returns the number of bytes needed to store a case for
 783    dictionary D. */
 784 size_t
 785 dict_get_case_size (const struct dictionary *d)
 786 {
 787   assert (d != NULL);
 788
 789   return sizeof (union value) * dict_get_next_value_idx (d);
 790 }
 791
 792 /* Deletes scratch variables in dictionary D and reassigns values
 793    so that fragmentation is eliminated. */
 794 void
 795 dict_compact_values (struct dictionary *d)
 796 {
 797   size_t i;
 798
 799   d->next_value_idx = 0;
 800   for (i = 0; i < d->var_cnt; )
 801     {
 802       struct variable *v = d->var[i];
 803
 804       if (dict_class_from_id (v->name) != DC_SCRATCH)
 805         {
 806           v->fv = d->next_value_idx;
 807           d->next_value_idx += v->nv;
 808           i++;
 809         }
 810       else
 811         dict_delete_var (d, v);
 812     }
 813 }
 814
 815 /* Returns the number of values that would be used by a case if
 816    dict_compact_values() were called. */
 817 size_t
 818 dict_get_compacted_value_cnt (const struct dictionary *d)
 819 {
 820   size_t i;
 821   size_t cnt;
 822
 823   cnt = 0;
 824   for (i = 0; i < d->var_cnt; i++)
 825     if (dict_class_from_id (d->var[i]->name) != DC_SCRATCH)
 826       cnt += d->var[i]->nv;
 827   return cnt;
 828 }
 829
 830 /* Creates and returns an array mapping from a dictionary index
 831    to the `fv' that the corresponding variable will have after
 832    calling dict_compact_values().  Scratch variables receive -1
 833    for `fv' because dict_compact_values() will delete them. */
 834 int *
 835 dict_get_compacted_idx_to_fv (const struct dictionary *d)
 836 {
 837   size_t i;
 838   size_t next_value_idx;
 839   int *idx_to_fv;
 840
 841   idx_to_fv = xnmalloc (d->var_cnt, sizeof *idx_to_fv);
 842   next_value_idx = 0;
 843   for (i = 0; i < d->var_cnt; i++)
 844     {
 845       struct variable *v = d->var[i];
 846
 847       if (dict_class_from_id (v->name) != DC_SCRATCH)
 848         {
 849           idx_to_fv[i] = next_value_idx;
 850           next_value_idx += v->nv;
 851         }
 852       else
 853         idx_to_fv[i] = -1;
 854     }
 855   return idx_to_fv;
 856 }
 857
 858 /* Returns true if a case for dictionary D would be smaller after
 859    compaction, false otherwise.  Compacting a case eliminates
 860    "holes" between values and after the last value.  Holes are
 861    created by deleting variables (or by scratch variables).
 862
 863    The return value may differ from whether compacting a case
 864    from dictionary D would *change* the case: compaction could
 865    rearrange values even if it didn't reduce space
 866    requirements. */
 867 bool
 868 dict_needs_compaction (const struct dictionary *d)
 869 {
 870   return dict_get_compacted_value_cnt (d) < dict_get_next_value_idx (d);
 871 }
 872 \f
 873 /* How to copy a contiguous range of values between cases. */
 874 struct copy_map
 875   {
 876     size_t src_idx;             /* Starting value index in source case. */
 877     size_t dst_idx;             /* Starting value index in target case. */
 878     size_t cnt;                 /* Number of values. */
 879   };
 880
 881 /* How to compact a case. */
 882 struct dict_compactor
 883   {
 884     struct copy_map *maps;      /* Array of mappings. */
 885     size_t map_cnt;             /* Number of mappings. */
 886   };
 887
 888 /* Creates and returns a dict_compactor that can be used to
 889    compact cases for dictionary D.
 890
 891    Compacting a case eliminates "holes" between values and after
 892    the last value.  Holes are created by deleting variables (or
 893    by scratch variables). */
 894 struct dict_compactor *
 895 dict_make_compactor (const struct dictionary *d)
 896 {
 897   struct dict_compactor *compactor;
 898   struct copy_map *map;
 899   size_t map_allocated;
 900   size_t value_idx;
 901   size_t i;
 902
 903   compactor = xmalloc (sizeof *compactor);
 904   compactor->maps = NULL;
 905   compactor->map_cnt = 0;
 906   map_allocated = 0;
 907
 908   value_idx = 0;
 909   map = NULL;
 910   for (i = 0; i < d->var_cnt; i++)
 911     {
 912       struct variable *v = d->var[i];
 913
 914       if (dict_class_from_id (v->name) == DC_SCRATCH)
 915         continue;
 916       if (map != NULL && map->src_idx + map->cnt == v->fv)
 917         map->cnt += v->nv;
 918       else
 919         {
 920           if (compactor->map_cnt == map_allocated)
 921             compactor->maps = x2nrealloc (compactor->maps, &map_allocated,
 922                                           sizeof *compactor->maps);
 923           map = &compactor->maps[compactor->map_cnt++];
 924           map->src_idx = v->fv;
 925           map->dst_idx = value_idx;
 926           map->cnt = v->nv;
 927         }
 928       value_idx += v->nv;
 929     }
 930
 931   return compactor;
 932 }
 933
 934 /* Compacts SRC by copying it to DST according to the scheme in
 935    COMPACTOR.
 936
 937    Compacting a case eliminates "holes" between values and after
 938    the last value.  Holes are created by deleting variables (or
 939    by scratch variables). */
 940 void
 941 dict_compactor_compact (const struct dict_compactor *compactor,
 942                         struct ccase *dst, const struct ccase *src)
 943 {
 944   size_t i;
 945
 946   for (i = 0; i < compactor->map_cnt; i++)
 947     {
 948       const struct copy_map *map = &compactor->maps[i];
 949       case_copy (dst, map->dst_idx, src, map->src_idx, map->cnt);
 950     }
 951 }
 952
 953 /* Destroys COMPACTOR. */
 954 void
 955 dict_compactor_destroy (struct dict_compactor *compactor)
 956 {
 957   if (compactor != NULL)
 958     {
 959       free (compactor->maps);
 960       free (compactor);
 961     }
 962 }
 963
 964 /* Returns the SPLIT FILE vars (see cmd_split_file()).  Call
 965    dict_get_split_cnt() to determine how many SPLIT FILE vars
 966    there are.  Returns a null pointer if and only if there are no
 967    SPLIT FILE vars. */
 968 struct variable *const *
 969 dict_get_split_vars (const struct dictionary *d)
 970 {
 971   assert (d != NULL);
 972
 973   return d->split;
 974 }
 975
 976 /* Returns the number of SPLIT FILE vars. */
 977 size_t
 978 dict_get_split_cnt (const struct dictionary *d)
 979 {
 980   assert (d != NULL);
 981
 982   return d->split_cnt;
 983 }
 984
 985 /* Sets CNT split vars SPLIT in dictionary D. */
 986 void
 987 dict_set_split_vars (struct dictionary *d,
 988                      struct variable *const *split, size_t cnt)
 989 {
 990   assert (d != NULL);
 991   assert (cnt == 0 || split != NULL);
 992
 993   d->split_cnt = cnt;
 994   d->split = xnrealloc (d->split, cnt, sizeof *d->split);
 995   memcpy (d->split, split, cnt * sizeof *d->split);
 996 }
 997
 998 /* Returns the file label for D, or a null pointer if D is
 999    unlabeled (see cmd_file_label()). */
1000 const char *
1001 dict_get_label (const struct dictionary *d)
1002 {
1003   assert (d != NULL);
1004
1005   return d->label;
1006 }
1007
1008 /* Sets D's file label to LABEL, truncating it to a maximum of 60
1009    characters. */
1010 void
1011 dict_set_label (struct dictionary *d, const char *label)
1012 {
1013   assert (d != NULL);
1014
1015   free (d->label);
1016   if (label == NULL)
1017     d->label = NULL;
1018   else if (strlen (label) < 60)
1019     d->label = xstrdup (label);
1020   else
1021     {
1022       d->label = xmalloc (61);
1023       memcpy (d->label, label, 60);
1024       d->label[60] = '\0';
1025     }
1026 }
1027
1028 /* Returns the documents for D, or a null pointer if D has no
1029    documents (see cmd_document()).. */
1030 const char *
1031 dict_get_documents (const struct dictionary *d)
1032 {
1033   assert (d != NULL);
1034
1035   return d->documents;
1036 }
1037
1038 /* Sets the documents for D to DOCUMENTS, or removes D's
1039    documents if DOCUMENT is a null pointer. */
1040 void
1041 dict_set_documents (struct dictionary *d, const char *documents)
1042 {
1043   assert (d != NULL);
1044
1045   free (d->documents);
1046   if (documents == NULL)
1047     d->documents = NULL;
1048   else
1049     d->documents = xstrdup (documents);
1050 }
1051
1052 /* Creates in D a vector named NAME that contains CNT variables
1053    VAR (see cmd_vector()).  Returns true if successful, or
1054    false if a vector named NAME already exists in D. */
1055 bool
1056 dict_create_vector (struct dictionary *d,
1057                     const char *name,
1058                     struct variable **var, size_t cnt)
1059 {
1060   struct vector *vector;
1061   size_t i;
1062
1063   assert (d != NULL);
1064   assert (name != NULL);
1065   assert (var_is_valid_name (name, false));
1066   assert (var != NULL);
1067   assert (cnt > 0);
1068
1069   if (dict_lookup_vector (d, name) != NULL)
1070     return false;
1071
1072   d->vector = xnrealloc (d->vector, d->vector_cnt + 1, sizeof *d->vector);
1073   vector = d->vector[d->vector_cnt] = xmalloc (sizeof *vector);
1074   vector->idx = d->vector_cnt++;
1075   str_copy_trunc (vector->name, sizeof vector->name, name);
1076   vector->var = xnmalloc (cnt, sizeof *var);
1077   for (i = 0; i < cnt; i++)
1078     {
1079       assert (dict_contains_var (d, var[i]));
1080       vector->var[i] = var[i];
1081     }
1082   vector->cnt = cnt;
1083
1084   return true;
1085 }
1086
1087 /* Returns the vector in D with index IDX, which must be less
1088    than dict_get_vector_cnt (D). */
1089 const struct vector *
1090 dict_get_vector (const struct dictionary *d, size_t idx)
1091 {
1092   assert (d != NULL);
1093   assert (idx < d->vector_cnt);
1094
1095   return d->vector[idx];
1096 }
1097
1098 /* Returns the number of vectors in D. */
1099 size_t
1100 dict_get_vector_cnt (const struct dictionary *d)
1101 {
1102   assert (d != NULL);
1103
1104   return d->vector_cnt;
1105 }
1106
1107 /* Looks up and returns the vector within D with the given
1108    NAME. */
1109 const struct vector *
1110 dict_lookup_vector (const struct dictionary *d, const char *name)
1111 {
1112   size_t i;
1113
1114   assert (d != NULL);
1115   assert (name != NULL);
1116
1117   for (i = 0; i < d->vector_cnt; i++)
1118     if (!strcasecmp (d->vector[i]->name, name))
1119       return d->vector[i];
1120   return NULL;
1121 }
1122
1123 /* Deletes all vectors from D. */
1124 void
1125 dict_clear_vectors (struct dictionary *d)
1126 {
1127   size_t i;
1128
1129   assert (d != NULL);
1130
1131   for (i = 0; i < d->vector_cnt; i++)
1132     {
1133       free (d->vector[i]->var);
1134       free (d->vector[i]);
1135     }
1136   free (d->vector);
1137   d->vector = NULL;
1138   d->vector_cnt = 0;
1139 }
1140
1141 /* Compares two strings. */
1142 static int
1143 compare_strings (const void *a, const void *b, void *aux UNUSED)
1144 {
1145   return strcmp (a, b);
1146 }
1147
1148 /* Hashes a string. */
1149 static unsigned
1150 hash_string (const void *s, void *aux UNUSED)
1151 {
1152   return hsh_hash_string (s);
1153 }
1154
1155 /* Assigns a valid, unique short_name[] to each variable in D.
1156    Each variable whose actual name is short has highest priority
1157    for that short name.  Otherwise, variables with an existing
1158    short_name[] have the next highest priority for a given short
1159    name; if it is already taken, then the variable is treated as
1160    if short_name[] had been empty.  Otherwise, long names are
1161    truncated to form short names.  If that causes conflicts,
1162    variables are renamed as PREFIX_A, PREFIX_B, and so on. */
1163 void
1164 dict_assign_short_names (struct dictionary *d)
1165 {
1166   struct hsh_table *short_names;
1167   size_t i;
1168
1169   /* Give variables whose names are short the corresponding short
1170      names, and clear short_names[] that conflict with a variable
1171      name. */
1172   for (i = 0; i < d->var_cnt; i++)
1173     {
1174       struct variable *v = d->var[i];
1175       if (strlen (v->name) <= SHORT_NAME_LEN)
1176         var_set_short_name (v, v->name);
1177       else if (dict_lookup_var (d, v->short_name) != NULL)
1178         var_clear_short_name (v);
1179     }
1180
1181   /* Each variable with an assigned short_name[] now gets it
1182      unless there is a conflict. */
1183   short_names = hsh_create (d->var_cnt, compare_strings, hash_string,
1184                             NULL, NULL);
1185   for (i = 0; i < d->var_cnt; i++)
1186     {
1187       struct variable *v = d->var[i];
1188       if (v->short_name[0] && hsh_insert (short_names, v->short_name) != NULL)
1189         var_clear_short_name (v);
1190     }
1191
1192   /* Now assign short names to remaining variables. */
1193   for (i = 0; i < d->var_cnt; i++)
1194     {
1195       struct variable *v = d->var[i];
1196       if (v->short_name[0] == '\0')
1197         {
1198           int sfx;
1199
1200           /* Form initial short_name. */
1201           var_set_short_name (v, v->name);
1202
1203           /* Try _A, _B, ... _AA, _AB, etc., if needed. */
1204           for (sfx = 0; hsh_insert (short_names, v->short_name) != NULL; sfx++)
1205             var_set_short_name_suffix (v, v->name, sfx);
1206         }
1207     }
1208
1209   /* Get rid of hash table. */
1210   hsh_destroy (short_names);
1211 }