1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2006, 2007, 2009-2015 Free Software Foundation, Inc.
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.
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.
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/>. */
19 #include "data/dictionary.h"
26 #include "data/attributes.h"
27 #include "data/case.h"
28 #include "data/identifier.h"
29 #include "data/mrset.h"
30 #include "data/settings.h"
31 #include "data/value-labels.h"
32 #include "data/vardict.h"
33 #include "data/variable.h"
34 #include "data/vector.h"
35 #include "libpspp/array.h"
36 #include "libpspp/assertion.h"
37 #include "libpspp/compiler.h"
38 #include "libpspp/hash-functions.h"
39 #include "libpspp/hmap.h"
40 #include "libpspp/i18n.h"
41 #include "libpspp/message.h"
42 #include "libpspp/misc.h"
43 #include "libpspp/pool.h"
44 #include "libpspp/pxd.h"
45 #include "libpspp/str.h"
46 #include "libpspp/string-array.h"
48 #include "gl/intprops.h"
49 #include "gl/minmax.h"
50 #include "gl/xalloc.h"
51 #include "gl/xmemdup0.h"
54 #define _(msgid) gettext (msgid)
59 struct vardict_info *var; /* Variables. */
60 size_t var_cnt, var_cap; /* Number of variables, capacity. */
61 struct caseproto *proto; /* Prototype for dictionary cases
63 struct hmap name_map; /* Variable index by name. */
64 int next_value_idx; /* Index of next `union value' to allocate. */
65 const struct variable **split; /* SPLIT FILE vars. */
66 size_t split_cnt; /* SPLIT FILE count. */
67 struct variable *weight; /* WEIGHT variable. */
68 struct variable *filter; /* FILTER variable. */
69 casenumber case_limit; /* Current case limit (N command). */
70 char *label; /* File label. */
71 struct string_array documents; /* Documents. */
72 struct vector **vector; /* Vectors of variables. */
73 size_t vector_cnt; /* Number of vectors. */
74 struct attrset attributes; /* Custom attributes. */
75 struct mrset **mrsets; /* Multiple response sets. */
76 size_t n_mrsets; /* Number of multiple response sets. */
78 char *encoding; /* Character encoding of string data */
80 const struct dict_callbacks *callbacks; /* Callbacks on dictionary
82 void *cb_data ; /* Data passed to callbacks */
84 void (*changed) (struct dictionary *, void *); /* Generic change callback */
88 static void dict_unset_split_var (struct dictionary *, struct variable *);
89 static void dict_unset_mrset_var (struct dictionary *, struct variable *);
91 static void dict_uncache (struct dictionary *);
93 /* Returns the encoding for data in dictionary D. The return value is a
94 nonnull string that contains an IANA character set name. */
96 dict_get_encoding (const struct dictionary *d)
101 /* Returns true if UTF-8 string ID is an acceptable identifier in DICT's
102 encoding, false otherwise. If ISSUE_ERROR is true, issues an explanatory
103 error message on failure. */
105 dict_id_is_valid (const struct dictionary *dict, const char *id,
108 return id_is_valid (id, dict->encoding, issue_error);
112 dict_set_change_callback (struct dictionary *d,
113 void (*changed) (struct dictionary *, void*),
116 d->changed = changed;
117 d->changed_data = data;
120 /* Discards dictionary D's caseproto. (It will be regenerated
121 lazily, on demand.) */
123 invalidate_proto (struct dictionary *d)
125 caseproto_unref (d->proto);
129 /* Print a representation of dictionary D to stdout, for
130 debugging purposes. */
132 dict_dump (const struct dictionary *d)
135 for (i = 0 ; i < d->var_cnt ; ++i )
137 const struct variable *v = d->var[i].var;
138 printf ("Name: %s;\tdict_idx: %zu; case_idx: %zu\n",
140 var_get_dict_index (v),
141 var_get_case_index (v));
146 /* Associate CALLBACKS with DICT. Callbacks will be invoked whenever
147 the dictionary or any of the variables it contains are modified.
148 Each callback will get passed CALLBACK_DATA.
149 Any callback may be NULL, in which case it'll be ignored.
152 dict_set_callbacks (struct dictionary *dict,
153 const struct dict_callbacks *callbacks,
156 dict->callbacks = callbacks;
157 dict->cb_data = callback_data;
160 /* Shallow copy the callbacks from SRC to DEST */
162 dict_copy_callbacks (struct dictionary *dest,
163 const struct dictionary *src)
165 dest->callbacks = src->callbacks;
166 dest->cb_data = src->cb_data;
169 /* Creates and returns a new dictionary with the specified ENCODING. */
171 dict_create (const char *encoding)
173 struct dictionary *d = xzalloc (sizeof *d);
175 d->encoding = xstrdup (encoding);
176 hmap_init (&d->name_map);
177 attrset_init (&d->attributes);
182 /* Creates and returns a (deep) copy of an existing
185 The new dictionary's case indexes are copied from the old
186 dictionary. If the new dictionary won't be used to access
187 cases produced with the old dictionary, then the new
188 dictionary's case indexes should be compacted with
189 dict_compact_values to save space.
191 Callbacks are not cloned. */
193 dict_clone (const struct dictionary *s)
195 struct dictionary *d;
198 d = dict_create (s->encoding);
200 for (i = 0; i < s->var_cnt; i++)
202 struct variable *sv = s->var[i].var;
203 struct variable *dv = dict_clone_var_assert (d, sv);
206 for (i = 0; i < var_get_short_name_cnt (sv); i++)
207 var_set_short_name (dv, i, var_get_short_name (sv, i));
209 var_get_vardict (dv)->case_index = var_get_vardict (sv)->case_index;
212 d->next_value_idx = s->next_value_idx;
214 d->split_cnt = s->split_cnt;
215 if (d->split_cnt > 0)
217 d->split = xnmalloc (d->split_cnt, sizeof *d->split);
218 for (i = 0; i < d->split_cnt; i++)
219 d->split[i] = dict_lookup_var_assert (d, var_get_name (s->split[i]));
222 if (s->weight != NULL)
223 dict_set_weight (d, dict_lookup_var_assert (d, var_get_name (s->weight)));
225 if (s->filter != NULL)
226 dict_set_filter (d, dict_lookup_var_assert (d, var_get_name (s->filter)));
228 d->case_limit = s->case_limit;
229 dict_set_label (d, dict_get_label (s));
230 dict_set_documents (d, dict_get_documents (s));
232 d->vector_cnt = s->vector_cnt;
233 d->vector = xnmalloc (d->vector_cnt, sizeof *d->vector);
234 for (i = 0; i < s->vector_cnt; i++)
235 d->vector[i] = vector_clone (s->vector[i], s, d);
237 dict_set_attributes (d, dict_get_attributes (s));
239 for (i = 0; i < s->n_mrsets; i++)
241 const struct mrset *old = s->mrsets[i];
245 /* Clone old mrset, then replace vars from D by vars from S. */
246 new = mrset_clone (old);
247 for (j = 0; j < new->n_vars; j++)
248 new->vars[j] = dict_lookup_var_assert (d, var_get_name (new->vars[j]));
250 dict_add_mrset (d, new);
256 /* Clears the contents from a dictionary without destroying the
257 dictionary itself. */
259 dict_clear (struct dictionary *d)
263 /* FIXME? Should we really clear case_limit, label, documents?
264 Others are necessarily cleared by deleting all the variables.*/
265 while (d->var_cnt > 0 )
267 dict_delete_var (d, d->var[d->var_cnt - 1].var);
272 d->var_cnt = d->var_cap = 0;
273 invalidate_proto (d);
274 hmap_clear (&d->name_map);
275 d->next_value_idx = 0;
276 dict_set_split_vars (d, NULL, 0);
277 dict_set_weight (d, NULL);
278 dict_set_filter (d, NULL);
282 string_array_clear (&d->documents);
283 dict_clear_vectors (d);
284 attrset_clear (&d->attributes);
287 /* Clears a dictionary and destroys it. */
289 dict_destroy (struct dictionary *d)
293 /* In general, we don't want callbacks occuring, if the dictionary
294 is being destroyed */
295 d->callbacks = NULL ;
298 string_array_destroy (&d->documents);
299 hmap_destroy (&d->name_map);
300 attrset_destroy (&d->attributes);
301 dict_clear_mrsets (d);
307 /* Returns the number of variables in D. */
309 dict_get_var_cnt (const struct dictionary *d)
314 /* Returns the variable in D with dictionary index IDX, which
315 must be between 0 and the count returned by
316 dict_get_var_cnt(), exclusive. */
318 dict_get_var (const struct dictionary *d, size_t idx)
320 assert (idx < d->var_cnt);
322 return d->var[idx].var;
325 /* Sets *VARS to an array of pointers to variables in D and *CNT
326 to the number of variables in *D. All variables are returned
327 except for those, if any, in the classes indicated by EXCLUDE.
328 (There is no point in putting DC_SYSTEM in EXCLUDE as
329 dictionaries never include system variables.) */
331 dict_get_vars (const struct dictionary *d, const struct variable ***vars,
332 size_t *cnt, enum dict_class exclude)
334 dict_get_vars_mutable (d, (struct variable ***) vars, cnt, exclude);
337 /* Sets *VARS to an array of pointers to variables in D and *CNT
338 to the number of variables in *D. All variables are returned
339 except for those, if any, in the classes indicated by EXCLUDE.
340 (There is no point in putting DC_SYSTEM in EXCLUDE as
341 dictionaries never include system variables.) */
343 dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars,
344 size_t *cnt, enum dict_class exclude)
349 assert (exclude == (exclude & DC_ALL));
352 for (i = 0; i < d->var_cnt; i++)
354 enum dict_class class = var_get_dict_class (d->var[i].var);
355 if (!(class & exclude))
359 *vars = xnmalloc (count, sizeof **vars);
361 for (i = 0; i < d->var_cnt; i++)
363 enum dict_class class = var_get_dict_class (d->var[i].var);
364 if (!(class & exclude))
365 (*vars)[(*cnt)++] = d->var[i].var;
367 assert (*cnt == count);
370 static struct variable *
371 add_var_with_case_index (struct dictionary *d, struct variable *v,
374 struct vardict_info *vardict;
376 assert (case_index >= d->next_value_idx);
378 /* Update dictionary. */
379 if (d->var_cnt >= d->var_cap)
383 d->var = x2nrealloc (d->var, &d->var_cap, sizeof *d->var);
384 hmap_clear (&d->name_map);
385 for (i = 0; i < d->var_cnt; i++)
387 var_set_vardict (d->var[i].var, &d->var[i]);
388 hmap_insert_fast (&d->name_map, &d->var[i].name_node,
389 d->var[i].name_node.hash);
393 vardict = &d->var[d->var_cnt++];
396 hmap_insert (&d->name_map, &vardict->name_node,
397 utf8_hash_case_string (var_get_name (v), 0));
398 vardict->case_index = case_index;
399 var_set_vardict (v, vardict);
401 if ( d->changed ) d->changed (d, d->changed_data);
402 if ( d->callbacks && d->callbacks->var_added )
403 d->callbacks->var_added (d, var_get_dict_index (v), d->cb_data);
405 invalidate_proto (d);
406 d->next_value_idx = case_index + 1;
411 static struct variable *
412 add_var (struct dictionary *d, struct variable *v)
414 return add_var_with_case_index (d, v, d->next_value_idx);
417 /* Creates and returns a new variable in D with the given NAME
418 and WIDTH. Returns a null pointer if the given NAME would
419 duplicate that of an existing variable in the dictionary. */
421 dict_create_var (struct dictionary *d, const char *name, int width)
423 return (dict_lookup_var (d, name) == NULL
424 ? dict_create_var_assert (d, name, width)
428 /* Creates and returns a new variable in D with the given NAME
429 and WIDTH. Assert-fails if the given NAME would duplicate
430 that of an existing variable in the dictionary. */
432 dict_create_var_assert (struct dictionary *d, const char *name, int width)
434 assert (dict_lookup_var (d, name) == NULL);
435 return add_var (d, var_create (name, width));
438 /* Creates and returns a new variable in D, as a copy of existing variable
439 OLD_VAR, which need not be in D or in any dictionary. Returns a null
440 pointer if OLD_VAR's name would duplicate that of an existing variable in
443 dict_clone_var (struct dictionary *d, const struct variable *old_var)
445 return dict_clone_var_as (d, old_var, var_get_name (old_var));
448 /* Creates and returns a new variable in D, as a copy of existing variable
449 OLD_VAR, which need not be in D or in any dictionary. Assert-fails if
450 OLD_VAR's name would duplicate that of an existing variable in the
453 dict_clone_var_assert (struct dictionary *d, const struct variable *old_var)
455 return dict_clone_var_as_assert (d, old_var, var_get_name (old_var));
458 /* Creates and returns a new variable in D with name NAME, as a copy of
459 existing variable OLD_VAR, which need not be in D or in any dictionary.
460 Returns a null pointer if the given NAME would duplicate that of an existing
461 variable in the dictionary. */
463 dict_clone_var_as (struct dictionary *d, const struct variable *old_var,
466 return (dict_lookup_var (d, name) == NULL
467 ? dict_clone_var_as_assert (d, old_var, name)
471 /* Creates and returns a new variable in D with name NAME, as a copy of
472 existing variable OLD_VAR, which need not be in D or in any dictionary.
473 Assert-fails if the given NAME would duplicate that of an existing variable
474 in the dictionary. */
476 dict_clone_var_as_assert (struct dictionary *d, const struct variable *old_var,
479 struct variable *new_var = var_clone (old_var);
480 assert (dict_lookup_var (d, name) == NULL);
481 var_set_name (new_var, name);
482 return add_var (d, new_var);
486 dict_clone_var_in_place_assert (struct dictionary *d,
487 const struct variable *old_var)
489 assert (dict_lookup_var (d, var_get_name (old_var)) == NULL);
490 return add_var_with_case_index (d, var_clone (old_var),
491 var_get_case_index (old_var));
494 /* Returns the variable named NAME in D, or a null pointer if no
495 variable has that name. */
497 dict_lookup_var (const struct dictionary *d, const char *name)
499 struct vardict_info *vardict;
501 HMAP_FOR_EACH_WITH_HASH (vardict, struct vardict_info, name_node,
502 utf8_hash_case_string (name, 0), &d->name_map)
504 struct variable *var = vardict->var;
505 if (!utf8_strcasecmp (var_get_name (var), name))
512 /* Returns the variable named NAME in D. Assert-fails if no
513 variable has that name. */
515 dict_lookup_var_assert (const struct dictionary *d, const char *name)
517 struct variable *v = dict_lookup_var (d, name);
522 /* Returns true if variable V is in dictionary D,
525 dict_contains_var (const struct dictionary *d, const struct variable *v)
527 return (var_has_vardict (v)
528 && vardict_get_dictionary (var_get_vardict (v)) == d);
531 /* Compares two double pointers to variables, which should point
532 to elements of a struct dictionary's `var' member array. */
534 compare_var_ptrs (const void *a_, const void *b_, const void *aux UNUSED)
536 struct variable *const *a = a_;
537 struct variable *const *b = b_;
539 return *a < *b ? -1 : *a > *b;
543 unindex_var (struct dictionary *d, struct vardict_info *vardict)
545 hmap_delete (&d->name_map, &vardict->name_node);
548 /* This function assumes that vardict->name_node.hash is valid, that is, that
549 its name has not changed since it was hashed (rename_var() updates this
550 hash along with the name itself). */
552 reindex_var (struct dictionary *d, struct vardict_info *vardict)
554 struct variable *var = vardict->var;
555 struct variable *old = var_clone (var);
557 var_set_vardict (var, vardict);
558 hmap_insert_fast (&d->name_map, &vardict->name_node,
559 vardict->name_node.hash);
561 if ( d->changed ) d->changed (d, d->changed_data);
562 if ( d->callbacks && d->callbacks->var_changed )
563 d->callbacks->var_changed (d, var_get_dict_index (var), VAR_TRAIT_POSITION, old, d->cb_data);
567 /* Sets the case_index in V's vardict to CASE_INDEX. */
569 set_var_case_index (struct variable *v, int case_index)
571 var_get_vardict (v)->case_index = case_index;
574 /* Removes the dictionary variables with indexes from FROM to TO (exclusive)
577 unindex_vars (struct dictionary *d, size_t from, size_t to)
581 for (i = from; i < to; i++)
582 unindex_var (d, &d->var[i]);
585 /* Re-sets the dict_index in the dictionary variables with
586 indexes from FROM to TO (exclusive). */
588 reindex_vars (struct dictionary *d, size_t from, size_t to)
592 for (i = from; i < to; i++)
593 reindex_var (d, &d->var[i]);
596 /* Deletes variable V from dictionary D and frees V.
598 This is a very bad idea if there might be any pointers to V
599 from outside D. In general, no variable in the active dataset's
600 dictionary should be deleted when any transformations are
601 active on the dictionary's dataset, because those
602 transformations might reference the deleted variable. The
603 safest time to delete a variable is just after a procedure has
604 been executed, as done by DELETE VARIABLES.
606 Pointers to V within D are not a problem, because
607 dict_delete_var() knows to remove V from split variables,
608 weights, filters, etc. */
610 dict_delete_var (struct dictionary *d, struct variable *v)
612 int dict_index = var_get_dict_index (v);
613 const int case_index = var_get_case_index (v);
615 assert (dict_contains_var (d, v));
617 dict_unset_split_var (d, v);
618 dict_unset_mrset_var (d, v);
621 dict_set_weight (d, NULL);
624 dict_set_filter (d, NULL);
626 dict_clear_vectors (d);
628 /* Remove V from var array. */
629 unindex_vars (d, dict_index, d->var_cnt);
630 remove_element (d->var, d->var_cnt, sizeof *d->var, dict_index);
633 /* Update dict_index for each affected variable. */
634 reindex_vars (d, dict_index, d->var_cnt);
637 var_clear_vardict (v);
639 if ( d->changed ) d->changed (d, d->changed_data);
641 invalidate_proto (d);
642 if (d->callbacks && d->callbacks->var_deleted )
643 d->callbacks->var_deleted (d, v, dict_index, case_index, d->cb_data);
648 /* Deletes the COUNT variables listed in VARS from D. This is
649 unsafe; see the comment on dict_delete_var() for details. */
651 dict_delete_vars (struct dictionary *d,
652 struct variable *const *vars, size_t count)
654 /* FIXME: this can be done in O(count) time, but this algorithm
656 assert (count == 0 || vars != NULL);
659 dict_delete_var (d, *vars++);
662 /* Deletes the COUNT variables in D starting at index IDX. This
663 is unsafe; see the comment on dict_delete_var() for
666 dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count)
668 /* FIXME: this can be done in O(count) time, but this algorithm
670 assert (idx + count <= d->var_cnt);
673 dict_delete_var (d, d->var[idx].var);
676 /* Deletes scratch variables from dictionary D. */
678 dict_delete_scratch_vars (struct dictionary *d)
682 /* FIXME: this can be done in O(count) time, but this algorithm
684 for (i = 0; i < d->var_cnt; )
685 if (var_get_dict_class (d->var[i].var) == DC_SCRATCH)
686 dict_delete_var (d, d->var[i].var);
691 /* Moves V to 0-based position IDX in D. Other variables in D,
692 if any, retain their relative positions. Runs in time linear
693 in the distance moved. */
695 dict_reorder_var (struct dictionary *d, struct variable *v, size_t new_index)
697 size_t old_index = var_get_dict_index (v);
699 assert (new_index < d->var_cnt);
701 unindex_vars (d, MIN (old_index, new_index), MAX (old_index, new_index) + 1);
702 move_element (d->var, d->var_cnt, sizeof *d->var, old_index, new_index);
703 reindex_vars (d, MIN (old_index, new_index), MAX (old_index, new_index) + 1);
706 /* Reorders the variables in D, placing the COUNT variables
707 listed in ORDER in that order at the beginning of D. The
708 other variables in D, if any, retain their relative
711 dict_reorder_vars (struct dictionary *d,
712 struct variable *const *order, size_t count)
714 struct vardict_info *new_var;
717 assert (count == 0 || order != NULL);
718 assert (count <= d->var_cnt);
720 new_var = xnmalloc (d->var_cap, sizeof *new_var);
722 /* Add variables in ORDER to new_var. */
723 for (i = 0; i < count; i++)
725 struct vardict_info *old_var;
727 assert (dict_contains_var (d, order[i]));
729 old_var = var_get_vardict (order[i]);
730 new_var[i] = *old_var;
731 old_var->dict = NULL;
734 /* Add remaining variables to new_var. */
735 for (i = 0; i < d->var_cnt; i++)
736 if (d->var[i].dict != NULL)
737 new_var[count++] = d->var[i];
738 assert (count == d->var_cnt);
740 /* Replace old vardicts by new ones. */
744 hmap_clear (&d->name_map);
745 reindex_vars (d, 0, d->var_cnt);
748 /* Changes the name of variable V that is currently in a dictionary to
751 rename_var (struct variable *v, const char *new_name)
753 struct vardict_info *vardict = var_get_vardict (v);
754 var_clear_vardict (v);
755 var_set_name (v, new_name);
756 vardict->name_node.hash = utf8_hash_case_string (new_name, 0);
757 var_set_vardict (v, vardict);
760 /* Changes the name of V in D to name NEW_NAME. Assert-fails if
761 a variable named NEW_NAME is already in D, except that
762 NEW_NAME may be the same as V's existing name. */
764 dict_rename_var (struct dictionary *d, struct variable *v,
765 const char *new_name)
767 struct variable *old = var_clone (v);
768 assert (!utf8_strcasecmp (var_get_name (v), new_name)
769 || dict_lookup_var (d, new_name) == NULL);
771 unindex_var (d, var_get_vardict (v));
772 rename_var (v, new_name);
773 reindex_var (d, var_get_vardict (v));
775 if (settings_get_algorithm () == ENHANCED)
776 var_clear_short_names (v);
778 if ( d->changed ) d->changed (d, d->changed_data);
779 if ( d->callbacks && d->callbacks->var_changed )
780 d->callbacks->var_changed (d, var_get_dict_index (v), VAR_TRAIT_NAME, old, d->cb_data);
785 /* Renames COUNT variables specified in VARS to the names given
786 in NEW_NAMES within dictionary D. If the renaming would
787 result in a duplicate variable name, returns false and stores a
788 name that would be duplicated into *ERR_NAME (if ERR_NAME is
789 non-null). Otherwise, the renaming is successful, and true
792 dict_rename_vars (struct dictionary *d,
793 struct variable **vars, char **new_names, size_t count,
800 assert (count == 0 || vars != NULL);
801 assert (count == 0 || new_names != NULL);
803 /* Save the names of the variables to be renamed. */
804 pool = pool_create ();
805 old_names = pool_nalloc (pool, count, sizeof *old_names);
806 for (i = 0; i < count; i++)
807 old_names[i] = pool_strdup (pool, var_get_name (vars[i]));
809 /* Remove the variables to be renamed from the name hash,
811 for (i = 0; i < count; i++)
813 unindex_var (d, var_get_vardict (vars[i]));
814 rename_var (vars[i], new_names[i]);
817 /* Add the renamed variables back into the name hash,
818 checking for conflicts. */
819 for (i = 0; i < count; i++)
821 if (dict_lookup_var (d, var_get_name (vars[i])) != NULL)
823 /* There is a name conflict.
824 Back out all the name changes that have already
825 taken place, and indicate failure. */
827 if (err_name != NULL)
828 *err_name = new_names[i];
830 for (i = 0; i < fail_idx; i++)
831 unindex_var (d, var_get_vardict (vars[i]));
833 for (i = 0; i < count; i++)
835 rename_var (vars[i], old_names[i]);
836 reindex_var (d, var_get_vardict (vars[i]));
842 reindex_var (d, var_get_vardict (vars[i]));
845 /* Clear short names. */
846 if (settings_get_algorithm () == ENHANCED)
847 for (i = 0; i < count; i++)
848 var_clear_short_names (vars[i]);
854 /* Returns true if a variable named NAME may be inserted in DICT;
855 that is, if there is not already a variable with that name in
856 DICT and if NAME is not a reserved word. (The caller's checks
857 have already verified that NAME is otherwise acceptable as a
860 var_name_is_insertable (const struct dictionary *dict, const char *name)
862 return (dict_lookup_var (dict, name) == NULL
863 && lex_id_to_token (ss_cstr (name)) == T_ID);
867 make_hinted_name (const struct dictionary *dict, const char *hint)
869 size_t hint_len = strlen (hint);
870 bool dropped = false;
875 /* The allocation size here is OK: characters that are copied directly fit
876 OK, and characters that are not copied directly are replaced by a single
877 '_' byte. If u8_mbtouc() replaces bad input by 0xfffd, then that will get
878 replaced by '_' too. */
879 root = rp = xmalloc (hint_len + 1);
880 for (ofs = 0; ofs < hint_len; ofs += mblen)
884 mblen = u8_mbtouc (&uc, CHAR_CAST (const uint8_t *, hint + ofs),
887 ? lex_uc_is_id1 (uc) && uc != '$'
888 : lex_uc_is_idn (uc))
895 rp += u8_uctomb (CHAR_CAST (uint8_t *, rp), uc, 6);
906 if (var_name_is_insertable (dict, root))
909 for (i = 0; i < ULONG_MAX; i++)
911 char suffix[INT_BUFSIZE_BOUND (i) + 1];
915 if (!str_format_26adic (i + 1, true, &suffix[1], sizeof suffix - 1))
918 name = utf8_encoding_concat (root, suffix, dict->encoding, 64);
919 if (var_name_is_insertable (dict, name))
934 make_numeric_name (const struct dictionary *dict, unsigned long int *num_start)
936 unsigned long int number;
938 for (number = num_start != NULL ? MAX (*num_start, 1) : 1;
942 char name[3 + INT_STRLEN_BOUND (number) + 1];
944 sprintf (name, "VAR%03lu", number);
945 if (dict_lookup_var (dict, name) == NULL)
947 if (num_start != NULL)
948 *num_start = number + 1;
949 return xstrdup (name);
957 /* Devises and returns a variable name unique within DICT. The variable name
958 is owned by the caller, which must free it with free() when it is no longer
961 HINT, if it is non-null, is used as a suggestion that will be
962 modified for suitability as a variable name and for
965 If HINT is null or entirely unsuitable, a name in the form
966 "VAR%03d" will be generated, where the smallest unused integer
967 value is used. If NUM_START is non-null, then its value is
968 used as the minimum numeric value to check, and it is updated
969 to the next value to be checked.
972 dict_make_unique_var_name (const struct dictionary *dict, const char *hint,
973 unsigned long int *num_start)
977 char *hinted_name = make_hinted_name (dict, hint);
978 if (hinted_name != NULL)
981 return make_numeric_name (dict, num_start);
984 /* Returns the weighting variable in dictionary D, or a null
985 pointer if the dictionary is unweighted. */
987 dict_get_weight (const struct dictionary *d)
989 assert (d->weight == NULL || dict_contains_var (d, d->weight));
994 /* Returns the value of D's weighting variable in case C, except
995 that a negative weight is returned as 0. Returns 1 if the
996 dictionary is unweighted. Will warn about missing, negative,
997 or zero values if *WARN_ON_INVALID is true. The function will
998 set *WARN_ON_INVALID to false if an invalid weight is
1001 dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
1002 bool *warn_on_invalid)
1006 if (d->weight == NULL)
1010 double w = case_num (c, d->weight);
1011 if (w < 0.0 || var_is_num_missing (d->weight, w, MV_ANY))
1013 if ( w == 0.0 && warn_on_invalid != NULL && *warn_on_invalid ) {
1014 *warn_on_invalid = false;
1015 msg (SW, _("At least one case in the data file had a weight value "
1016 "that was user-missing, system-missing, zero, or "
1017 "negative. These case(s) were ignored."));
1023 /* Sets the weighting variable of D to V, or turning off
1024 weighting if V is a null pointer. */
1026 dict_set_weight (struct dictionary *d, struct variable *v)
1028 assert (v == NULL || dict_contains_var (d, v));
1029 assert (v == NULL || var_is_numeric (v));
1033 if (d->changed) d->changed (d, d->changed_data);
1034 if ( d->callbacks && d->callbacks->weight_changed )
1035 d->callbacks->weight_changed (d,
1036 v ? var_get_dict_index (v) : -1,
1040 /* Returns the filter variable in dictionary D (see cmd_filter())
1041 or a null pointer if the dictionary is unfiltered. */
1043 dict_get_filter (const struct dictionary *d)
1045 assert (d->filter == NULL || dict_contains_var (d, d->filter));
1050 /* Sets V as the filter variable for dictionary D. Passing a
1051 null pointer for V turn off filtering. */
1053 dict_set_filter (struct dictionary *d, struct variable *v)
1055 assert (v == NULL || dict_contains_var (d, v));
1056 assert (v == NULL || var_is_numeric (v));
1060 if (d->changed) d->changed (d, d->changed_data);
1061 if ( d->callbacks && d->callbacks->filter_changed )
1062 d->callbacks->filter_changed (d,
1063 v ? var_get_dict_index (v) : -1,
1067 /* Returns the case limit for dictionary D, or zero if the number
1068 of cases is unlimited. */
1070 dict_get_case_limit (const struct dictionary *d)
1072 return d->case_limit;
1075 /* Sets CASE_LIMIT as the case limit for dictionary D. Use
1076 0 for CASE_LIMIT to indicate no limit. */
1078 dict_set_case_limit (struct dictionary *d, casenumber case_limit)
1080 d->case_limit = case_limit;
1083 /* Returns the prototype used for cases created by dictionary D. */
1084 const struct caseproto *
1085 dict_get_proto (const struct dictionary *d_)
1087 struct dictionary *d = CONST_CAST (struct dictionary *, d_);
1088 if (d->proto == NULL)
1092 d->proto = caseproto_create ();
1093 d->proto = caseproto_reserve (d->proto, d->var_cnt);
1094 for (i = 0; i < d->var_cnt; i++)
1095 d->proto = caseproto_set_width (d->proto,
1096 var_get_case_index (d->var[i].var),
1097 var_get_width (d->var[i].var));
1102 /* Returns the case index of the next value to be added to D.
1103 This value is the number of `union value's that need to be
1104 allocated to store a case for dictionary D. */
1106 dict_get_next_value_idx (const struct dictionary *d)
1108 return d->next_value_idx;
1111 /* Returns the number of bytes needed to store a case for
1114 dict_get_case_size (const struct dictionary *d)
1116 return sizeof (union value) * dict_get_next_value_idx (d);
1119 /* Reassigns values in dictionary D so that fragmentation is
1122 dict_compact_values (struct dictionary *d)
1126 d->next_value_idx = 0;
1127 for (i = 0; i < d->var_cnt; i++)
1129 struct variable *v = d->var[i].var;
1130 set_var_case_index (v, d->next_value_idx++);
1132 invalidate_proto (d);
1135 /* Returns the number of values occupied by the variables in
1136 dictionary D. All variables are considered if EXCLUDE_CLASSES
1137 is 0, or it may contain one or more of (1u << DC_ORDINARY),
1138 (1u << DC_SYSTEM), or (1u << DC_SCRATCH) to exclude the
1139 corresponding type of variable.
1141 The return value may be less than the number of values in one
1142 of dictionary D's cases (as returned by
1143 dict_get_next_value_idx) even if E is 0, because there may be
1144 gaps in D's cases due to deleted variables. */
1146 dict_count_values (const struct dictionary *d, unsigned int exclude_classes)
1151 assert ((exclude_classes & ~((1u << DC_ORDINARY)
1153 | (1u << DC_SCRATCH))) == 0);
1156 for (i = 0; i < d->var_cnt; i++)
1158 enum dict_class class = var_get_dict_class (d->var[i].var);
1159 if (!(exclude_classes & (1u << class)))
1165 /* Returns the case prototype that would result after deleting
1166 all variables from D that are not in one of the
1167 EXCLUDE_CLASSES and compacting the dictionary with
1170 The caller must unref the returned caseproto when it is no
1173 dict_get_compacted_proto (const struct dictionary *d,
1174 unsigned int exclude_classes)
1176 struct caseproto *proto;
1179 assert ((exclude_classes & ~((1u << DC_ORDINARY)
1181 | (1u << DC_SCRATCH))) == 0);
1183 proto = caseproto_create ();
1184 for (i = 0; i < d->var_cnt; i++)
1186 struct variable *v = d->var[i].var;
1187 if (!(exclude_classes & (1u << var_get_dict_class (v))))
1188 proto = caseproto_add_width (proto, var_get_width (v));
1193 /* Returns the SPLIT FILE vars (see cmd_split_file()). Call
1194 dict_get_split_cnt() to determine how many SPLIT FILE vars
1195 there are. Returns a null pointer if and only if there are no
1197 const struct variable *const *
1198 dict_get_split_vars (const struct dictionary *d)
1203 /* Returns the number of SPLIT FILE vars. */
1205 dict_get_split_cnt (const struct dictionary *d)
1207 return d->split_cnt;
1210 /* Removes variable V, which must be in D, from D's set of split
1213 dict_unset_split_var (struct dictionary *d, struct variable *v)
1217 assert (dict_contains_var (d, v));
1219 orig_count = d->split_cnt;
1220 d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split,
1221 &v, compare_var_ptrs, NULL);
1222 if (orig_count != d->split_cnt)
1224 if (d->changed) d->changed (d, d->changed_data);
1225 /* We changed the set of split variables so invoke the
1227 if (d->callbacks && d->callbacks->split_changed)
1228 d->callbacks->split_changed (d, d->cb_data);
1232 /* Sets CNT split vars SPLIT in dictionary D. */
1234 dict_set_split_vars (struct dictionary *d,
1235 struct variable *const *split, size_t cnt)
1237 assert (cnt == 0 || split != NULL);
1242 d->split = xnrealloc (d->split, cnt, sizeof *d->split) ;
1243 memcpy (d->split, split, cnt * sizeof *d->split);
1251 if (d->changed) d->changed (d, d->changed_data);
1252 if ( d->callbacks && d->callbacks->split_changed )
1253 d->callbacks->split_changed (d, d->cb_data);
1256 /* Returns the file label for D, or a null pointer if D is
1257 unlabeled (see cmd_file_label()). */
1259 dict_get_label (const struct dictionary *d)
1264 /* Sets D's file label to LABEL, truncating it to at most 60 bytes in D's
1267 Removes D's label if LABEL is null or the empty string. */
1269 dict_set_label (struct dictionary *d, const char *label)
1272 if (label == NULL || label[0] == '\0')
1275 d->label = utf8_encoding_trunc (label, d->encoding, 60);
1278 /* Returns the documents for D, as an UTF-8 encoded string_array. The
1279 return value is always nonnull; if there are no documents then the
1280 string_arary is empty.*/
1281 const struct string_array *
1282 dict_get_documents (const struct dictionary *d)
1284 return &d->documents;
1287 /* Replaces the documents for D by NEW_DOCS, a UTF-8 encoded string_array. */
1289 dict_set_documents (struct dictionary *d, const struct string_array *new_docs)
1293 dict_clear_documents (d);
1295 for (i = 0; i < new_docs->n; i++)
1296 dict_add_document_line (d, new_docs->strings[i], false);
1299 /* Replaces the documents for D by UTF-8 encoded string NEW_DOCS, dividing it
1300 into individual lines at new-line characters. Each line is truncated to at
1301 most DOC_LINE_LENGTH bytes in D's encoding. */
1303 dict_set_documents_string (struct dictionary *d, const char *new_docs)
1307 dict_clear_documents (d);
1308 for (s = new_docs; *s != '\0'; )
1310 size_t len = strcspn (s, "\n");
1311 char *line = xmemdup0 (s, len);
1312 dict_add_document_line (d, line, false);
1321 /* Drops the documents from dictionary D. */
1323 dict_clear_documents (struct dictionary *d)
1325 string_array_clear (&d->documents);
1328 /* Appends the UTF-8 encoded LINE to the documents in D. LINE will be
1329 truncated so that it is no more than 80 bytes in the dictionary's
1330 encoding. If this causes some text to be lost, and ISSUE_WARNING is true,
1331 then a warning will be issued. */
1333 dict_add_document_line (struct dictionary *d, const char *line,
1339 trunc_len = utf8_encoding_trunc_len (line, d->encoding, DOC_LINE_LENGTH);
1340 truncated = line[trunc_len] != '\0';
1341 if (truncated && issue_warning)
1343 /* Note to translators: "bytes" is correct, not characters */
1344 msg (SW, _("Truncating document line to %d bytes."), DOC_LINE_LENGTH);
1347 string_array_append_nocopy (&d->documents, xmemdup0 (line, trunc_len));
1352 /* Returns the number of document lines in dictionary D. */
1354 dict_get_document_line_cnt (const struct dictionary *d)
1356 return d->documents.n;
1359 /* Returns document line number IDX in dictionary D. The caller must not
1360 modify or free the returned string. */
1362 dict_get_document_line (const struct dictionary *d, size_t idx)
1364 assert (idx < d->documents.n);
1365 return d->documents.strings[idx];
1368 /* Creates in D a vector named NAME that contains the CNT
1369 variables in VAR. Returns true if successful, or false if a
1370 vector named NAME already exists in D. */
1372 dict_create_vector (struct dictionary *d,
1374 struct variable **var, size_t cnt)
1379 for (i = 0; i < cnt; i++)
1380 assert (dict_contains_var (d, var[i]));
1382 if (dict_lookup_vector (d, name) == NULL)
1384 d->vector = xnrealloc (d->vector, d->vector_cnt + 1, sizeof *d->vector);
1385 d->vector[d->vector_cnt++] = vector_create (name, var, cnt);
1392 /* Creates in D a vector named NAME that contains the CNT
1393 variables in VAR. A vector named NAME must not already exist
1396 dict_create_vector_assert (struct dictionary *d,
1398 struct variable **var, size_t cnt)
1400 assert (dict_lookup_vector (d, name) == NULL);
1401 dict_create_vector (d, name, var, cnt);
1404 /* Returns the vector in D with index IDX, which must be less
1405 than dict_get_vector_cnt (D). */
1406 const struct vector *
1407 dict_get_vector (const struct dictionary *d, size_t idx)
1409 assert (idx < d->vector_cnt);
1411 return d->vector[idx];
1414 /* Returns the number of vectors in D. */
1416 dict_get_vector_cnt (const struct dictionary *d)
1418 return d->vector_cnt;
1421 /* Looks up and returns the vector within D with the given
1423 const struct vector *
1424 dict_lookup_vector (const struct dictionary *d, const char *name)
1427 for (i = 0; i < d->vector_cnt; i++)
1428 if (!utf8_strcasecmp (vector_get_name (d->vector[i]), name))
1429 return d->vector[i];
1433 /* Deletes all vectors from D. */
1435 dict_clear_vectors (struct dictionary *d)
1439 for (i = 0; i < d->vector_cnt; i++)
1440 vector_destroy (d->vector[i]);
1447 /* Multiple response sets. */
1449 /* Returns the multiple response set in DICT with index IDX, which must be
1450 between 0 and the count returned by dict_get_n_mrsets(), exclusive. */
1451 const struct mrset *
1452 dict_get_mrset (const struct dictionary *dict, size_t idx)
1454 assert (idx < dict->n_mrsets);
1455 return dict->mrsets[idx];
1458 /* Returns the number of multiple response sets in DICT. */
1460 dict_get_n_mrsets (const struct dictionary *dict)
1462 return dict->n_mrsets;
1465 /* Looks for a multiple response set named NAME in DICT. If it finds one,
1466 returns its index; otherwise, returns SIZE_MAX. */
1468 dict_lookup_mrset_idx (const struct dictionary *dict, const char *name)
1472 for (i = 0; i < dict->n_mrsets; i++)
1473 if (!utf8_strcasecmp (name, dict->mrsets[i]->name))
1479 /* Looks for a multiple response set named NAME in DICT. If it finds one,
1480 returns it; otherwise, returns NULL. */
1481 const struct mrset *
1482 dict_lookup_mrset (const struct dictionary *dict, const char *name)
1484 size_t idx = dict_lookup_mrset_idx (dict, name);
1485 return idx != SIZE_MAX ? dict->mrsets[idx] : NULL;
1488 /* Adds MRSET to DICT, replacing any existing set with the same name. Returns
1489 true if a set was replaced, false if none existed with the specified name.
1491 Ownership of MRSET is transferred to DICT. */
1493 dict_add_mrset (struct dictionary *dict, struct mrset *mrset)
1497 assert (mrset_ok (mrset, dict));
1499 idx = dict_lookup_mrset_idx (dict, mrset->name);
1500 if (idx == SIZE_MAX)
1502 dict->mrsets = xrealloc (dict->mrsets,
1503 (dict->n_mrsets + 1) * sizeof *dict->mrsets);
1504 dict->mrsets[dict->n_mrsets++] = mrset;
1509 mrset_destroy (dict->mrsets[idx]);
1510 dict->mrsets[idx] = mrset;
1515 /* Looks for a multiple response set in DICT named NAME. If found, removes it
1516 from DICT and returns true. If none is found, returns false without
1519 Deleting one multiple response set causes the indexes of other sets within
1522 dict_delete_mrset (struct dictionary *dict, const char *name)
1524 size_t idx = dict_lookup_mrset_idx (dict, name);
1525 if (idx != SIZE_MAX)
1527 mrset_destroy (dict->mrsets[idx]);
1528 dict->mrsets[idx] = dict->mrsets[--dict->n_mrsets];
1535 /* Deletes all multiple response sets from DICT. */
1537 dict_clear_mrsets (struct dictionary *dict)
1541 for (i = 0; i < dict->n_mrsets; i++)
1542 mrset_destroy (dict->mrsets[i]);
1543 free (dict->mrsets);
1544 dict->mrsets = NULL;
1548 /* Removes VAR, which must be in DICT, from DICT's multiple response sets. */
1550 dict_unset_mrset_var (struct dictionary *dict, struct variable *var)
1554 assert (dict_contains_var (dict, var));
1556 for (i = 0; i < dict->n_mrsets; )
1558 struct mrset *mrset = dict->mrsets[i];
1561 for (j = 0; j < mrset->n_vars; )
1562 if (mrset->vars[j] == var)
1563 remove_element (mrset->vars, mrset->n_vars--,
1564 sizeof *mrset->vars, j);
1568 if (mrset->n_vars < 2)
1570 mrset_destroy (mrset);
1571 dict->mrsets[i] = dict->mrsets[--dict->n_mrsets];
1578 /* Returns D's attribute set. The caller may examine or modify
1579 the attribute set, but must not destroy it. Destroying D or
1580 calling dict_set_attributes for D will also destroy D's
1583 dict_get_attributes (const struct dictionary *d)
1585 return CONST_CAST (struct attrset *, &d->attributes);
1588 /* Replaces D's attributes set by a copy of ATTRS. */
1590 dict_set_attributes (struct dictionary *d, const struct attrset *attrs)
1592 attrset_destroy (&d->attributes);
1593 attrset_clone (&d->attributes, attrs);
1596 /* Returns true if D has at least one attribute in its attribute
1597 set, false if D's attribute set is empty. */
1599 dict_has_attributes (const struct dictionary *d)
1601 return attrset_count (&d->attributes) > 0;
1604 /* Called from variable.c to notify the dictionary that some property (indicated
1605 by WHAT) of the variable has changed. OLDVAR is a copy of V as it existed
1606 prior to the change. OLDVAR is destroyed by this function.
1609 dict_var_changed (const struct variable *v, unsigned int what, struct variable *oldvar)
1611 if ( var_has_vardict (v))
1613 const struct vardict_info *vardict = var_get_vardict (v);
1614 struct dictionary *d = vardict->dict;
1619 if (d->changed ) d->changed (d, d->changed_data);
1620 if ( d->callbacks && d->callbacks->var_changed )
1621 d->callbacks->var_changed (d, var_get_dict_index (v), what, oldvar, d->cb_data);
1623 var_destroy (oldvar);
1628 /* Dictionary used to contain "internal variables". */
1629 static struct dictionary *internal_dict;
1631 /* Create a variable of the specified WIDTH to be used for internal
1632 calculations only. The variable is assigned case index CASE_IDX. */
1634 dict_create_internal_var (int case_idx, int width)
1636 if (internal_dict == NULL)
1637 internal_dict = dict_create ("UTF-8");
1641 static int counter = INT_MAX / 2;
1642 struct variable *var;
1645 if (++counter == INT_MAX)
1646 counter = INT_MAX / 2;
1648 sprintf (name, "$internal%d", counter);
1649 var = dict_create_var (internal_dict, name, width);
1652 set_var_case_index (var, case_idx);
1658 /* Destroys VAR, which must have been created with
1659 dict_create_internal_var(). */
1661 dict_destroy_internal_var (struct variable *var)
1665 dict_delete_var (internal_dict, var);
1667 /* Destroy internal_dict if it has no variables left, just so that
1668 valgrind --leak-check --show-reachable won't show internal_dict. */
1669 if (dict_get_var_cnt (internal_dict) == 0)
1671 dict_destroy (internal_dict);
1672 internal_dict = NULL;
1678 vardict_get_dict_index (const struct vardict_info *vardict)
1680 return vardict - vardict->dict->var;
1683 static struct pxd_object *
1684 vardict_info_save (const struct vardict_info *vardict, struct pxd *pxd)
1686 struct pxd_builder b;
1688 pxd_builder_init (&b, pxd);
1689 pxd_builder_put_s32 (&b, vardict->case_index);
1690 pxd_builder_put_link (&b, var_save (vardict->var, pxd));
1691 return pxd_builder_commit (&b);
1695 dict_save (const struct dictionary *dict, struct pxd *pxd)
1697 struct pxd_array_builder ab;
1698 struct pxd_object *vars;
1699 struct pxd_builder b;
1702 pxd_array_builder_init (&ab, pxd);
1703 for (i = 0; i < dict->var_cnt; i++)
1704 pxd_array_builder_add (&ab, vardict_info_save (&dict->var[i], pxd));
1705 vars = pxd_array_builder_commit (&ab);
1707 pxd_builder_init (&b, pxd);
1708 pxd_builder_put_link (&b, vars);
1709 pxd_builder_put_u32 (&b, dict->next_value_idx);
1711 pxd_builder_put_size_t (&b, dict->split_cnt);
1712 for (i = 0; i < dict->split_cnt; i++)
1713 pxd_builder_put_u32 (&b, var_get_dict_index (dict->split[i]));
1715 pxd_builder_put_s32 (&b,
1716 (dict->weight == NULL ? -1
1717 : var_get_dict_index (dict->weight)));
1718 pxd_builder_put_s32 (&b,
1719 (dict->filter == NULL ? -1
1720 : var_get_dict_index (dict->filter)));
1722 pxd_builder_put_casenumber (&b, dict->case_limit);
1723 pxd_builder_put_string (&b, dict->label != NULL ? dict->label : "");
1724 //XXX pxd_builder_put_string (&b, ds_cstr (&dict->documents));
1726 pxd_builder_put_size_t (&b, dict->vector_cnt);
1727 for (i = 0; i < dict->split_cnt; i++)
1728 pxd_builder_put_link (&b, vector_save (dict->vector[i], pxd));
1730 pxd_builder_put_link (&b, attrset_save (&dict->attributes, pxd));
1732 pxd_builder_put_size_t (&b, dict->n_mrsets);
1733 for (i = 0; i < dict->n_mrsets; i++)
1734 pxd_builder_put_link (&b, mrset_save (dict->mrsets[i], pxd));
1736 pxd_builder_put_string (&b, dict->encoding ? dict->encoding : "");
1738 return pxd_builder_commit (&b);
1742 vardict_info_load (struct dictionary *dict, struct pxd_object *obj,
1743 const struct pxd *pxd)
1745 struct pxd_parser p;
1746 struct variable *var;
1749 pxd_parser_init (&p, obj, pxd);
1750 case_index = pxd_parser_get_u32 (&p);
1751 var = add_var (dict, var_load (pxd_parser_get_link (&p), pxd));
1752 var_get_vardict (var)->case_index = case_index;
1753 pxd_parser_destroy (&p);
1757 dict_load (struct pxd_object *obj, const struct pxd *pxd)
1759 struct dictionary *dict;
1760 struct pxd_array array;
1761 struct pxd_parser p;
1767 pxd_parser_init (&p, obj, pxd);
1769 encoding = pxd_parser_get_string (&p);
1770 dict = dict_create (encoding);
1773 pxd_array_init (&array, pxd_parser_get_link (&p), pxd);
1774 for (i = 0; i < pxd_array_size (&array); i++)
1775 vardict_info_load (dict, pxd_array_get (&array, i), pxd);
1776 pxd_array_destroy (&array);
1778 dict->next_value_idx = pxd_parser_get_u32 (&p);
1780 dict->split_cnt = pxd_parser_get_size_t (&p);
1781 if (dict->split_cnt > 0)
1783 dict->split = xnmalloc (dict->split_cnt, sizeof *dict->split);
1784 for (i = 0; i < dict->split_cnt; i++)
1785 dict->split[i] = dict_get_var (dict, i);
1788 weight_idx = pxd_parser_get_s32 (&p);
1789 if (weight_idx >= 0)
1790 dict_set_weight (dict, dict_get_var (dict, weight_idx));
1792 filter_idx = pxd_parser_get_s32 (&p);
1793 if (filter_idx >= 0)
1794 dict_set_filter (dict, dict_get_var (dict, filter_idx));
1796 dict->case_limit = pxd_parser_get_casenumber (&p);
1798 dict->label = pxd_parser_get_string (&p);
1799 if (dict->label[0] == '\0')
1800 dict_set_label (dict, NULL);
1803 documents = pxd_parser_get_string (&p);
1804 if (documents[0] != '\0')
1805 ds_assign_cstr (&dict->documents, documents);
1809 dict->vector_cnt = pxd_parser_get_size_t (&p);
1810 if (dict->vector_cnt > 0)
1812 dict->vector = xnmalloc (dict->vector_cnt, sizeof *dict->vector);
1813 for (i = 0; i < dict->vector_cnt; i++)
1814 dict->vector[i] = vector_load (pxd_parser_get_link (&p), pxd, dict);
1817 attrset_destroy (&dict->attributes);
1818 attrset_load (&dict->attributes, pxd_parser_get_link (&p), pxd);
1820 dict->n_mrsets = pxd_parser_get_size_t (&p);
1821 if (dict->n_mrsets > 0)
1823 dict->mrsets = xnmalloc (dict->n_mrsets, sizeof *dict->mrsets);
1824 for (i = 0; i < dict->n_mrsets; i++)
1825 dict->mrsets[i] = mrset_load (pxd_parser_get_link (&p), pxd, dict);
1828 dict->encoding = pxd_parser_get_string (&p);
1829 if (dict->encoding[0] == '\0')
1831 free (dict->encoding);
1832 dict->encoding = NULL;
1835 pxd_parser_destroy (&p);
1841 dict_uncache (struct dictionary *dict UNUSED)