Fix assertion for proper Huffman merge pattern: 0 == 1 modulo 1.
[pspp] / src / dictionary.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000 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., 59 Temple Place - Suite 330, Boston, MA
18    02111-1307, USA. */
19
20 #include <config.h>
21 #include "dictionary.h"
22 #include <stdlib.h>
23 #include "algorithm.h"
24 #include "alloc.h"
25 #include "case.h"
26 #include "error.h"
27 #include "hash.h"
28 #include "misc.h"
29 #include "str.h"
30 #include "value-labels.h"
31 #include "var.h"
32
33 /* A dictionary. */
34 struct dictionary
35   {
36     struct variable **var;      /* Variables. */
37     size_t var_cnt, var_cap;    /* Number of variables, capacity. */
38     struct hsh_table *name_tab; /* Variable index by name. */
39     int next_value_idx;         /* Index of next `union value' to allocate. */
40     struct variable **split;    /* SPLIT FILE vars. */
41     size_t split_cnt;           /* SPLIT FILE count. */
42     struct variable *weight;    /* WEIGHT variable. */
43     struct variable *filter;    /* FILTER variable. */
44     int case_limit;             /* Current case limit (N command). */
45     char *label;                /* File label. */
46     char *documents;            /* Documents, as a string. */
47     struct vector **vector;     /* Vectors of variables. */
48     size_t vector_cnt;          /* Number of vectors. */
49   };
50
51 /* Creates and returns a new dictionary. */
52 struct dictionary *
53 dict_create (void) 
54 {
55   struct dictionary *d = xmalloc (sizeof *d);
56   
57   d->var = NULL;
58   d->var_cnt = d->var_cap = 0;
59   d->name_tab = hsh_create (8, compare_variables, hash_variable, NULL, NULL);
60   d->next_value_idx = 0;
61   d->split = NULL;
62   d->split_cnt = 0;
63   d->weight = NULL;
64   d->filter = NULL;
65   d->case_limit = 0;
66   d->label = NULL;
67   d->documents = NULL;
68   d->vector = NULL;
69   d->vector_cnt = 0;
70
71   return d;
72 }
73
74 /* Creates and returns a (deep) copy of an existing
75    dictionary. */
76 struct dictionary *
77 dict_clone (const struct dictionary *s) 
78 {
79   struct dictionary *d;
80   size_t i;
81   
82   assert (s != NULL);
83   
84   d = dict_create ();
85   for (i = 0; i < s->var_cnt; i++)
86     dict_clone_var (d, s->var[i], s->var[i]->name);
87   d->next_value_idx = s->next_value_idx;
88
89   d->split_cnt = s->split_cnt;
90   if (d->split_cnt > 0) 
91     {
92       d->split = xmalloc (d->split_cnt * sizeof *d->split);
93       for (i = 0; i < d->split_cnt; i++) 
94         d->split[i] = dict_lookup_var_assert (d, s->split[i]->name);
95     }
96
97   if (s->weight != NULL) 
98     d->weight = dict_lookup_var_assert (d, s->weight->name);
99
100   if (s->filter != NULL) 
101     d->filter = dict_lookup_var_assert (d, s->filter->name);
102
103   d->case_limit = s->case_limit;
104   dict_set_label (d, dict_get_label (s));
105   dict_set_documents (d, dict_get_documents (s));
106
107   for (i = 0; i < s->vector_cnt; i++) 
108     dict_create_vector (d, s->vector[i]->name,
109                         s->vector[i]->var, s->vector[i]->cnt);
110
111   return d;
112 }
113
114 /* Clears the contents from a dictionary without destroying the
115    dictionary itself. */
116 void
117 dict_clear (struct dictionary *d) 
118 {
119   /* FIXME?  Should we really clear case_limit, label, documents?
120      Others are necessarily cleared by deleting all the variables.*/
121   int i;
122
123   assert (d != NULL);
124
125   for (i = 0; i < d->var_cnt; i++) 
126     {
127       struct variable *v = d->var[i];
128       var_clear_aux (v);
129       val_labs_destroy (v->val_labs);
130       free (v->label);
131       free (v); 
132     }
133   free (d->var);
134   d->var = NULL;
135   d->var_cnt = d->var_cap = 0;
136   hsh_clear (d->name_tab);
137   d->next_value_idx = 0;
138   free (d->split);
139   d->split = NULL;
140   d->split_cnt = 0;
141   d->weight = NULL;
142   d->filter = NULL;
143   d->case_limit = 0;
144   free (d->label);
145   d->label = NULL;
146   free (d->documents);
147   d->documents = NULL;
148   dict_clear_vectors (d);
149 }
150
151 /* Destroys the aux data for every variable in D, by calling
152    var_clear_aux() for each variable. */
153 void
154 dict_clear_aux (struct dictionary *d) 
155 {
156   int i;
157   
158   assert (d != NULL);
159   
160   for (i = 0; i < d->var_cnt; i++)
161     var_clear_aux (d->var[i]);
162 }
163
164 /* Clears a dictionary and destroys it. */
165 void
166 dict_destroy (struct dictionary *d)
167 {
168   if (d != NULL) 
169     {
170       dict_clear (d);
171       hsh_destroy (d->name_tab);
172       free (d);
173     }
174 }
175
176 /* Returns the number of variables in D. */
177 size_t
178 dict_get_var_cnt (const struct dictionary *d) 
179 {
180   assert (d != NULL);
181
182   return d->var_cnt;
183 }
184
185 /* Returns the variable in D with index IDX, which must be
186    between 0 and the count returned by dict_get_var_cnt(),
187    exclusive. */
188 struct variable *
189 dict_get_var (const struct dictionary *d, size_t idx) 
190 {
191   assert (d != NULL);
192   assert (idx < d->var_cnt);
193
194   return d->var[idx];
195 }
196
197 /* Sets *VARS to an array of pointers to variables in D and *CNT
198    to the number of variables in *D.  By default all variables
199    are returned, but bits may be set in EXCLUDE_CLASSES to
200    exclude ordinary, system, and/or scratch variables. */
201 void
202 dict_get_vars (const struct dictionary *d, struct variable ***vars,
203                size_t *cnt, unsigned exclude_classes)
204 {
205   size_t count;
206   size_t i;
207   
208   assert (d != NULL);
209   assert (vars != NULL);
210   assert (cnt != NULL);
211   assert ((exclude_classes & ~((1u << DC_ORDINARY)
212                                | (1u << DC_SYSTEM)
213                                | (1u << DC_SCRATCH))) == 0);
214   
215   count = 0;
216   for (i = 0; i < d->var_cnt; i++)
217     if (!(exclude_classes & (1u << dict_class_from_id (d->var[i]->name))))
218       count++;
219
220   *vars = xmalloc (count * sizeof **vars);
221   *cnt = 0;
222   for (i = 0; i < d->var_cnt; i++)
223     if (!(exclude_classes & (1u << dict_class_from_id (d->var[i]->name))))
224       (*vars)[(*cnt)++] = d->var[i];
225   assert (*cnt == count);
226 }
227
228 /* Creates and returns a new variable in D with the given NAME
229    and WIDTH.  Returns a null pointer if the given NAME would
230    duplicate that of an existing variable in the dictionary. */
231 struct variable *
232 dict_create_var (struct dictionary *d, const char *name, int width) 
233 {
234   struct variable *v;
235
236   assert (d != NULL);
237   assert (name != NULL);
238   assert (strlen (name) >= 1 && strlen (name) <= 8);
239   assert (width >= 0 && width < 256);
240
241   /* Make sure there's not already a variable by that name. */
242   if (dict_lookup_var (d, name) != NULL)
243     return NULL;
244
245   /* Allocate and initialize variable. */
246   v = xmalloc (sizeof *v);
247   strncpy (v->name, name, sizeof v->name);
248   v->name[8] = '\0';
249   v->index = d->var_cnt;
250   v->type = width == 0 ? NUMERIC : ALPHA;
251   v->width = width;
252   v->fv = d->next_value_idx;
253   v->nv = width == 0 ? 1 : DIV_RND_UP (width, 8);
254   v->init = 1;
255   v->reinit = dict_class_from_id (name) != DC_SCRATCH;
256   v->miss_type = MISSING_NONE;
257   if (v->type == NUMERIC)
258     {
259       v->print.type = FMT_F;
260       v->print.w = 8;
261       v->print.d = 2;
262     }
263   else
264     {
265       v->print.type = FMT_A;
266       v->print.w = v->width;
267       v->print.d = 0;
268     }
269   v->write = v->print;
270   v->val_labs = val_labs_create (v->width);
271   v->label = NULL;
272   v->aux = NULL;
273   v->aux_dtor = NULL;
274
275   /* Update dictionary. */
276   if (d->var_cnt >= d->var_cap) 
277     {
278       d->var_cap = 8 + 2 * d->var_cap; 
279       d->var = xrealloc (d->var, d->var_cap * sizeof *d->var);
280     }
281   d->var[v->index] = v;
282   d->var_cnt++;
283   hsh_force_insert (d->name_tab, v);
284   d->next_value_idx += v->nv;
285
286   return v;
287 }
288
289 /* Creates and returns a new variable in D with the given NAME
290    and WIDTH.  Assert-fails if the given NAME would duplicate
291    that of an existing variable in the dictionary. */
292 struct variable *
293 dict_create_var_assert (struct dictionary *d, const char *name, int width) 
294 {
295   struct variable *v = dict_create_var (d, name, width);
296   assert (v != NULL);
297   return v;
298 }
299
300 /* Creates a new variable in D named NAME, as a copy of existing
301    variable OV, which need not be in D or in any dictionary. */
302 struct variable *
303 dict_clone_var (struct dictionary *d, const struct variable *ov,
304                 const char *name)
305 {
306   struct variable *nv;
307
308   assert (d != NULL);
309   assert (ov != NULL);
310   assert (name != NULL);
311   assert (strlen (name) >= 1 && strlen (name) <= 8);
312
313   nv = dict_create_var (d, name, ov->width);
314   if (nv == NULL)
315     return NULL;
316
317   nv->init = 1;
318   nv->reinit = ov->reinit;
319   nv->miss_type = ov->miss_type;
320   memcpy (nv->missing, ov->missing, sizeof nv->missing);
321   nv->print = ov->print;
322   nv->write = ov->write;
323   val_labs_destroy (nv->val_labs);
324   nv->val_labs = val_labs_copy (ov->val_labs);
325   if (ov->label != NULL)
326     nv->label = xstrdup (ov->label);
327
328   return nv;
329 }
330
331 /* Changes the name of V in D to name NEW_NAME.  Assert-fails if
332    a variable named NEW_NAME is already in D, except that
333    NEW_NAME may be the same as V's existing name. */
334 void 
335 dict_rename_var (struct dictionary *d, struct variable *v,
336                  const char *new_name) 
337 {
338   assert (d != NULL);
339   assert (v != NULL);
340   assert (new_name != NULL);
341   assert (strlen (new_name) >= 1 && strlen (new_name) <= 8);
342   assert (dict_contains_var (d, v));
343
344   if (!strcmp (v->name, new_name))
345     return;
346
347   assert (dict_lookup_var (d, new_name) == NULL);
348
349   hsh_force_delete (d->name_tab, v);
350   strncpy (v->name, new_name, sizeof v->name);
351   v->name[8] = '\0';
352   hsh_force_insert (d->name_tab, v);
353 }
354
355 /* Returns the variable named NAME in D, or a null pointer if no
356    variable has that name. */
357 struct variable *
358 dict_lookup_var (const struct dictionary *d, const char *name)
359 {
360   struct variable v;
361   
362   assert (d != NULL);
363   assert (name != NULL);
364   assert (strlen (name) >= 1 && strlen (name) <= 8);
365
366   strncpy (v.name, name, sizeof v.name);
367   v.name[8] = '\0';
368
369   return hsh_find (d->name_tab, &v);
370 }
371
372 /* Returns the variable named NAME in D.  Assert-fails if no
373    variable has that name. */
374 struct variable *
375 dict_lookup_var_assert (const struct dictionary *d, const char *name)
376 {
377   struct variable *v = dict_lookup_var (d, name);
378   assert (v != NULL);
379   return v;
380 }
381
382 /* Returns nonzero if variable V is in dictionary D. */
383 int
384 dict_contains_var (const struct dictionary *d, const struct variable *v)
385 {
386   assert (d != NULL);
387   assert (v != NULL);
388
389   return v->index >= 0 && v->index < d->var_cnt && d->var[v->index] == v;
390 }
391
392 /* Compares two double pointers to variables, which should point
393    to elements of a struct dictionary's `var' member array. */
394 static int
395 compare_variable_dblptrs (const void *a_, const void *b_, void *aux UNUSED) 
396 {
397   struct variable *const *a = a_;
398   struct variable *const *b = b_;
399
400   if (a > b)
401     return 1;
402   else if (a < b)
403     return -1;
404   else
405     return 0;
406 }
407
408 /* Deletes variable V from dictionary D and frees V.
409
410    This is a very bad idea if there might be any pointers to V
411    from outside D.  In general, no variable in default_dict
412    should be deleted when any transformations are active, because
413    those transformations might reference the deleted variable.
414    The safest time to delete a variable is just after a procedure
415    has been executed, as done by MODIFY VARS.
416
417    Pointers to V within D are not a problem, because
418    dict_delete_var() knows to remove V from split variables,
419    weights, filters, etc. */
420 void
421 dict_delete_var (struct dictionary *d, struct variable *v) 
422 {
423   size_t i;
424
425   assert (d != NULL);
426   assert (v != NULL);
427   assert (dict_contains_var (d, v));
428   assert (d->var[v->index] == v);
429
430   /* Delete aux data. */
431   var_clear_aux (v);
432
433   /* Remove V from splits, weight, filter variables. */
434   d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split,
435                                &v,
436                                compare_variable_dblptrs, NULL);
437   if (d->weight == v)
438     d->weight = NULL;
439   if (d->filter == v)
440     d->filter = NULL;
441   dict_clear_vectors (d);
442
443   /* Remove V from var array. */
444   d->var_cnt--;
445   memmove (d->var + v->index, d->var + v->index + 1,
446            (d->var_cnt - v->index) * sizeof *d->var);
447
448   /* Update index. */
449   for (i = v->index; i < d->var_cnt; i++)
450     d->var[i]->index = i;
451
452   /* Update name hash. */
453   hsh_force_delete (d->name_tab, v);
454
455   /* Free memory. */
456   val_labs_destroy (v->val_labs);
457   free (v->label);
458   free (v);
459 }
460
461 /* Deletes the COUNT variables listed in VARS from D.  This is
462    unsafe; see the comment on dict_delete_var() for details. */
463 void 
464 dict_delete_vars (struct dictionary *d,
465                   struct variable *const *vars, size_t count) 
466 {
467   /* FIXME: this can be done in O(count) time, but this algorithm
468      is O(count**2). */
469   assert (d != NULL);
470   assert (count == 0 || vars != NULL);
471
472   while (count-- > 0)
473     dict_delete_var (d, *vars++);
474 }
475
476 /* Reorders the variables in D, placing the COUNT variables
477    listed in ORDER in that order at the beginning of D.  The
478    other variables in D, if any, retain their relative
479    positions. */
480 void 
481 dict_reorder_vars (struct dictionary *d,
482                    struct variable *const *order, size_t count) 
483 {
484   struct variable **new_var;
485   size_t i;
486   
487   assert (d != NULL);
488   assert (count == 0 || order != NULL);
489   assert (count <= d->var_cnt);
490
491   new_var = xmalloc (d->var_cnt * sizeof *new_var);
492   memcpy (new_var, order, count * sizeof *new_var);
493   for (i = 0; i < count; i++) 
494     {
495       assert (d->var[order[i]->index] != NULL);
496       d->var[order[i]->index] = NULL;
497       order[i]->index = i;
498     }
499   for (i = 0; i < d->var_cnt; i++)
500     if (d->var[i] != NULL)
501       {
502         assert (count < d->var_cnt);
503         new_var[count] = d->var[i];
504         new_var[count]->index = count;
505         count++;
506       }
507   free (d->var);
508   d->var = new_var;
509 }
510
511 /* Renames COUNT variables specified in VARS to the names given
512    in NEW_NAMES within dictionary D.  If the renaming would
513    result in a duplicate variable name, returns zero and stores a
514    name that would be duplicated into *ERR_NAME (if ERR_NAME is
515    non-null).  Otherwise, the renaming is successful, and nonzero
516    is returned. */
517 int
518 dict_rename_vars (struct dictionary *d,
519                   struct variable **vars, char **new_names,
520                   size_t count, char **err_name) 
521 {
522   char **old_names;
523   size_t i;
524   int success = 1;
525
526   assert (d != NULL);
527   assert (count == 0 || vars != NULL);
528   assert (count == 0 || new_names != NULL);
529
530   old_names = xmalloc (count * sizeof *old_names);
531   for (i = 0; i < count; i++) 
532     {
533       assert (d->var[vars[i]->index] == vars[i]);
534       hsh_force_delete (d->name_tab, vars[i]);
535       old_names[i] = xstrdup (vars[i]->name);
536     }
537   
538   for (i = 0; i < count; i++)
539     {
540       assert (new_names[i] != NULL);
541       assert (*new_names[i] != '\0');
542       assert (strlen (new_names[i]) < 9);
543       strcpy (vars[i]->name, new_names[i]);
544       if (hsh_insert (d->name_tab, vars[i]) != NULL) 
545         {
546           size_t fail_idx = i;
547           if (err_name != NULL) 
548             *err_name = new_names[i];
549
550           for (i = 0; i < fail_idx; i++)
551             hsh_force_delete (d->name_tab, vars[i]);
552           
553           for (i = 0; i < count; i++)
554             {
555               strcpy (vars[i]->name, old_names[i]);
556               hsh_force_insert (d->name_tab, vars[i]);
557             }
558
559           success = 0;
560           break;
561         }
562     }
563
564   for (i = 0; i < count; i++)
565     free (old_names[i]);
566   free (old_names);
567
568   return success;
569 }
570
571 /* Returns the weighting variable in dictionary D, or a null
572    pointer if the dictionary is unweighted. */
573 struct variable *
574 dict_get_weight (const struct dictionary *d) 
575 {
576   assert (d != NULL);
577   assert (d->weight == NULL || dict_contains_var (d, d->weight));
578   
579   return d->weight;
580 }
581
582 /* Returns the value of D's weighting variable in case C, except that a
583    negative weight is returned as 0.  Returns 1 if the dictionary is
584    unweighted. Will warn about missing, negative, or zero values if
585    warn_on_invalid is nonzero. The function will set warn_on_invalid to zero
586    if an invalid weight is found. */
587 double
588 dict_get_case_weight (const struct dictionary *d, const struct ccase *c, 
589                       int *warn_on_invalid)
590 {
591   assert (d != NULL);
592   assert (c != NULL);
593
594   if (d->weight == NULL)
595     return 1.0;
596   else 
597     {
598       double w = case_num (c, d->weight->fv);
599       if ( w < 0.0 || w == SYSMIS || is_num_user_missing(w, d->weight) )
600         w = 0.0;
601       if ( w == 0.0 && *warn_on_invalid ) {
602           *warn_on_invalid = 0;
603           msg (SW, _("At least one case in the data file had a weight value "
604                      "that was user-missing, system-missing, zero, or "
605                      "negative.  These case(s) were ignored."));
606       }
607       return w;
608     }
609 }
610
611 /* Sets the weighting variable of D to V, or turning off
612    weighting if V is a null pointer. */
613 void
614 dict_set_weight (struct dictionary *d, struct variable *v) 
615 {
616   assert (d != NULL);
617   assert (v == NULL || dict_contains_var (d, v));
618   assert (v == NULL || v->type == NUMERIC);
619
620   d->weight = v;
621 }
622
623 /* Returns the filter variable in dictionary D (see cmd_filter())
624    or a null pointer if the dictionary is unfiltered. */
625 struct variable *
626 dict_get_filter (const struct dictionary *d) 
627 {
628   assert (d != NULL);
629   assert (d->filter == NULL || dict_contains_var (d, d->filter));
630   
631   return d->filter;
632 }
633
634 /* Sets V as the filter variable for dictionary D.  Passing a
635    null pointer for V turn off filtering. */
636 void
637 dict_set_filter (struct dictionary *d, struct variable *v)
638 {
639   assert (d != NULL);
640   assert (v == NULL || dict_contains_var (d, v));
641
642   d->filter = v;
643 }
644
645 /* Returns the case limit for dictionary D, or zero if the number
646    of cases is unlimited (see cmd_n()). */
647 int
648 dict_get_case_limit (const struct dictionary *d) 
649 {
650   assert (d != NULL);
651
652   return d->case_limit;
653 }
654
655 /* Sets CASE_LIMIT as the case limit for dictionary D.  Zero for
656    CASE_LIMIT indicates no limit. */
657 void
658 dict_set_case_limit (struct dictionary *d, int case_limit) 
659 {
660   assert (d != NULL);
661   assert (case_limit >= 0);
662
663   d->case_limit = case_limit;
664 }
665
666 /* Returns the index of the next value to be added to D.  This
667    value is the number of `union value's that need to be
668    allocated to store a case for dictionary D. */
669 int
670 dict_get_next_value_idx (const struct dictionary *d) 
671 {
672   assert (d != NULL);
673
674   return d->next_value_idx;
675 }
676
677 /* Returns the number of bytes needed to store a case for
678    dictionary D. */
679 size_t
680 dict_get_case_size (const struct dictionary *d) 
681 {
682   assert (d != NULL);
683
684   return sizeof (union value) * dict_get_next_value_idx (d);
685 }
686
687 /* Deletes scratch variables in dictionary D and reassigns values
688    so that fragmentation is eliminated. */
689 void
690 dict_compact_values (struct dictionary *d) 
691 {
692   size_t i;
693
694   d->next_value_idx = 0;
695   for (i = 0; i < d->var_cnt; )
696     {
697       struct variable *v = d->var[i];
698
699       if (dict_class_from_id (v->name) != DC_SCRATCH) 
700         {
701           v->fv = d->next_value_idx;
702           d->next_value_idx += v->nv;
703           i++;
704         }
705       else
706         dict_delete_var (default_dict, v);
707     }
708 }
709
710 /* Returns the number of values that would be used by a case if
711    dict_compact_values() were called. */
712 size_t
713 dict_get_compacted_value_cnt (const struct dictionary *d) 
714 {
715   size_t i;
716   size_t cnt;
717
718   cnt = 0;
719   for (i = 0; i < d->var_cnt; i++)
720     if (dict_class_from_id (d->var[i]->name) != DC_SCRATCH) 
721       cnt += d->var[i]->nv;
722   return cnt;
723 }
724
725 /* Creates and returns an array mapping from a dictionary index
726    to the `fv' that the corresponding variable will have after
727    calling dict_compact_values().  Scratch variables receive -1
728    for `fv' because dict_compact_values() will delete them. */
729 int *
730 dict_get_compacted_idx_to_fv (const struct dictionary *d) 
731 {
732   size_t i;
733   size_t next_value_idx;
734   int *idx_to_fv;
735   
736   idx_to_fv = xmalloc (d->var_cnt * sizeof *idx_to_fv);
737   next_value_idx = 0;
738   for (i = 0; i < d->var_cnt; i++)
739     {
740       struct variable *v = d->var[i];
741
742       if (dict_class_from_id (v->name) != DC_SCRATCH) 
743         {
744           idx_to_fv[i] = next_value_idx;
745           next_value_idx += v->nv;
746         }
747       else 
748         idx_to_fv[i] = -1;
749     }
750   return idx_to_fv;
751 }
752
753 /* Returns the SPLIT FILE vars (see cmd_split_file()).  Call
754    dict_get_split_cnt() to determine how many SPLIT FILE vars
755    there are.  Returns a null pointer if and only if there are no
756    SPLIT FILE vars. */
757 struct variable *const *
758 dict_get_split_vars (const struct dictionary *d) 
759 {
760   assert (d != NULL);
761   
762   return d->split;
763 }
764
765 /* Returns the number of SPLIT FILE vars. */
766 size_t
767 dict_get_split_cnt (const struct dictionary *d) 
768 {
769   assert (d != NULL);
770
771   return d->split_cnt;
772 }
773
774 /* Sets CNT split vars SPLIT in dictionary D. */
775 void
776 dict_set_split_vars (struct dictionary *d,
777                      struct variable *const *split, size_t cnt)
778 {
779   assert (d != NULL);
780   assert (cnt == 0 || split != NULL);
781
782   d->split_cnt = cnt;
783   d->split = xrealloc (d->split, cnt * sizeof *d->split);
784   memcpy (d->split, split, cnt * sizeof *d->split);
785 }
786
787 /* Returns the file label for D, or a null pointer if D is
788    unlabeled (see cmd_file_label()). */
789 const char *
790 dict_get_label (const struct dictionary *d) 
791 {
792   assert (d != NULL);
793
794   return d->label;
795 }
796
797 /* Sets D's file label to LABEL, truncating it to a maximum of 60
798    characters. */
799 void
800 dict_set_label (struct dictionary *d, const char *label) 
801 {
802   assert (d != NULL);
803
804   free (d->label);
805   if (label == NULL)
806     d->label = NULL;
807   else if (strlen (label) < 60)
808     d->label = xstrdup (label);
809   else 
810     {
811       d->label = xmalloc (61);
812       memcpy (d->label, label, 60);
813       d->label[60] = '\0';
814     }
815 }
816
817 /* Returns the documents for D, or a null pointer if D has no
818    documents (see cmd_document()).. */
819 const char *
820 dict_get_documents (const struct dictionary *d) 
821 {
822   assert (d != NULL);
823
824   return d->documents;
825 }
826
827 /* Sets the documents for D to DOCUMENTS, or removes D's
828    documents if DOCUMENT is a null pointer. */
829 void
830 dict_set_documents (struct dictionary *d, const char *documents)
831 {
832   assert (d != NULL);
833
834   free (d->documents);
835   if (documents == NULL)
836     d->documents = NULL;
837   else
838     d->documents = xstrdup (documents);
839 }
840
841 /* Creates in D a vector named NAME that contains CNT variables
842    VAR (see cmd_vector()).  Returns nonzero if successful, or
843    zero if a vector named NAME already exists in D. */
844 int
845 dict_create_vector (struct dictionary *d,
846                     const char *name,
847                     struct variable **var, size_t cnt) 
848 {
849   struct vector *vector;
850
851   assert (d != NULL);
852   assert (name != NULL);
853   assert (strlen (name) > 0 && strlen (name) < 9);
854   assert (var != NULL);
855   assert (cnt > 0);
856   
857   if (dict_lookup_vector (d, name) != NULL)
858     return 0;
859
860   d->vector = xrealloc (d->vector, (d->vector_cnt + 1) * sizeof *d->vector);
861   vector = d->vector[d->vector_cnt] = xmalloc (sizeof *vector);
862   vector->idx = d->vector_cnt++;
863   strncpy (vector->name, name, 8);
864   vector->name[8] = '\0';
865   vector->var = xmalloc (cnt * sizeof *var);
866   memcpy (vector->var, var, cnt * sizeof *var);
867   vector->cnt = cnt;
868   
869   return 1;
870 }
871
872 /* Returns the vector in D with index IDX, which must be less
873    than dict_get_vector_cnt (D). */
874 const struct vector *
875 dict_get_vector (const struct dictionary *d, size_t idx) 
876 {
877   assert (d != NULL);
878   assert (idx < d->vector_cnt);
879
880   return d->vector[idx];
881 }
882
883 /* Returns the number of vectors in D. */
884 size_t
885 dict_get_vector_cnt (const struct dictionary *d) 
886 {
887   assert (d != NULL);
888
889   return d->vector_cnt;
890 }
891
892 /* Looks up and returns the vector within D with the given
893    NAME. */
894 const struct vector *
895 dict_lookup_vector (const struct dictionary *d, const char *name) 
896 {
897   size_t i;
898
899   assert (d != NULL);
900   assert (name != NULL);
901
902   for (i = 0; i < d->vector_cnt; i++)
903     if (!strcmp (d->vector[i]->name, name))
904       return d->vector[i];
905   return NULL;
906 }
907
908 /* Deletes all vectors from D. */
909 void
910 dict_clear_vectors (struct dictionary *d) 
911 {
912   size_t i;
913   
914   assert (d != NULL);
915
916   for (i = 0; i < d->vector_cnt; i++) 
917     {
918       free (d->vector[i]->var);
919       free (d->vector[i]);
920     }
921   free (d->vector);
922   d->vector = NULL;
923   d->vector_cnt = 0;
924 }