X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fdictionary.c;h=03548c44eb628aef66341b1c3bd53da05ae9aca2;hb=432761249a7e96e81407a123d0e25c3de3066202;hp=44504ed96525ec5c4af0eaffd82f5de2fe3634c1;hpb=f514231dd2fc0c2adc1ebab5c46a4b55d2bd9c2b;p=pspp diff --git a/src/data/dictionary.c b/src/data/dictionary.c index 44504ed965..03548c44eb 100644 --- a/src/data/dictionary.c +++ b/src/data/dictionary.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 1997-9, 2000, 2006, 2007 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2006, 2007, 2009, 2010 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -16,28 +16,33 @@ #include -#include "dictionary.h" +#include "data/dictionary.h" #include #include -#include "case.h" -#include "category.h" -#include "settings.h" -#include "value-labels.h" -#include "vardict.h" -#include "variable.h" -#include "vector.h" -#include -#include -#include -#include -#include -#include -#include -#include - -#include "minmax.h" +#include "data/attributes.h" +#include "data/case.h" +#include "data/category.h" +#include "data/identifier.h" +#include "data/settings.h" +#include "data/value-labels.h" +#include "data/vardict.h" +#include "data/variable.h" +#include "data/vector.h" +#include "libpspp/array.h" +#include "libpspp/assertion.h" +#include "libpspp/compiler.h" +#include "libpspp/hash-functions.h" +#include "libpspp/hmap.h" +#include "libpspp/message.h" +#include "libpspp/misc.h" +#include "libpspp/pool.h" +#include "libpspp/str.h" + +#include "gl/intprops.h" +#include "gl/minmax.h" +#include "gl/xalloc.h" #include "gettext.h" #define _(msgid) gettext (msgid) @@ -45,25 +50,86 @@ /* A dictionary. */ struct dictionary { - struct variable **var; /* Variables. */ + struct vardict_info *var; /* Variables. */ size_t var_cnt, var_cap; /* Number of variables, capacity. */ - struct hsh_table *name_tab; /* Variable index by name. */ + struct caseproto *proto; /* Prototype for dictionary cases + (updated lazily). */ + struct hmap name_map; /* Variable index by name. */ int next_value_idx; /* Index of next `union value' to allocate. */ const struct variable **split; /* SPLIT FILE vars. */ size_t split_cnt; /* SPLIT FILE count. */ struct variable *weight; /* WEIGHT variable. */ struct variable *filter; /* FILTER variable. */ - size_t case_limit; /* Current case limit (N command). */ + casenumber case_limit; /* Current case limit (N command). */ char *label; /* File label. */ struct string documents; /* Documents, as a string. */ struct vector **vector; /* Vectors of variables. */ size_t vector_cnt; /* Number of vectors. */ + struct attrset attributes; /* Custom attributes. */ + + char *encoding; /* Character encoding of string data */ + const struct dict_callbacks *callbacks; /* Callbacks on dictionary modification */ void *cb_data ; /* Data passed to callbacks */ + + void (*changed) (struct dictionary *, void *); /* Generic change callback */ + void *changed_data; }; +void +dict_set_encoding (struct dictionary *d, const char *enc) +{ + if (enc) + { + free (d->encoding); + d->encoding = xstrdup (enc); + } +} + +const char * +dict_get_encoding (const struct dictionary *d) +{ + return d->encoding ; +} + + +void +dict_set_change_callback (struct dictionary *d, + void (*changed) (struct dictionary *, void*), + void *data) +{ + d->changed = changed; + d->changed_data = data; +} + +/* Discards dictionary D's caseproto. (It will be regenerated + lazily, on demand.) */ +static void +invalidate_proto (struct dictionary *d) +{ + caseproto_unref (d->proto); + d->proto = NULL; +} + +/* Print a representation of dictionary D to stdout, for + debugging purposes. */ +void +dict_dump (const struct dictionary *d) +{ + int i; + for (i = 0 ; i < d->var_cnt ; ++i ) + { + const struct variable *v = d->var[i].var; + printf ("Name: %s;\tdict_idx: %zu; case_idx: %zu\n", + var_get_name (v), + var_get_dict_index (v), + var_get_case_index (v)); + + } +} + /* Associate CALLBACKS with DICT. Callbacks will be invoked whenever the dictionary or any of the variables it contains are modified. Each callback will get passed CALLBACK_DATA. @@ -93,28 +159,37 @@ dict_create (void) { struct dictionary *d = xzalloc (sizeof *d); - d->name_tab = hsh_create (8, compare_vars_by_name, hash_var_by_name, - NULL, NULL); + hmap_init (&d->name_map); + attrset_init (&d->attributes); return d; } /* Creates and returns a (deep) copy of an existing - dictionary. */ + dictionary. + + The new dictionary's case indexes are copied from the old + dictionary. If the new dictionary won't be used to access + cases produced with the old dictionary, then the new + dictionary's case indexes should be compacted with + dict_compact_values to save space. */ struct dictionary * dict_clone (const struct dictionary *s) { struct dictionary *d; size_t i; - assert (s != NULL); - d = dict_create (); for (i = 0; i < s->var_cnt; i++) { - struct variable *sv = s->var[i]; - struct variable *dv = dict_clone_var_assert (d, sv, var_get_name (sv)); - var_set_short_name (dv, var_get_short_name (sv)); + struct variable *sv = s->var[i].var; + struct variable *dv = dict_clone_var_assert (d, sv); + size_t i; + + for (i = 0; i < var_get_short_name_cnt (sv); i++) + var_set_short_name (dv, i, var_get_short_name (sv, i)); + + var_get_vardict (dv)->case_index = var_get_vardict (sv)->case_index; } d->next_value_idx = s->next_value_idx; @@ -142,6 +217,11 @@ dict_clone (const struct dictionary *s) for (i = 0; i < s->vector_cnt; i++) d->vector[i] = vector_clone (s->vector[i], s, d); + if ( s->encoding) + d->encoding = xstrdup (s->encoding); + + dict_set_attributes (d, dict_get_attributes (s)); + return d; } @@ -152,30 +232,16 @@ dict_clear (struct dictionary *d) { /* FIXME? Should we really clear case_limit, label, documents? Others are necessarily cleared by deleting all the variables.*/ - assert (d != NULL); - while (d->var_cnt > 0 ) { - struct variable *v = d->var[d->var_cnt - 1]; - int dict_index = var_get_dict_index (v); - int case_index = var_get_case_index (v); - int val_cnt = var_get_value_cnt (v); - - var_clear_vardict (v); - var_destroy (v); - - d->var_cnt--; - - if (d->callbacks && d->callbacks->var_deleted ) - d->callbacks->var_deleted (d, - dict_index, case_index, val_cnt, - d->cb_data); + dict_delete_var (d, d->var[d->var_cnt - 1].var); } free (d->var); d->var = NULL; d->var_cnt = d->var_cap = 0; - hsh_clear (d->name_tab); + invalidate_proto (d); + hmap_clear (&d->name_map); d->next_value_idx = 0; dict_set_split_vars (d, NULL, 0); dict_set_weight (d, NULL); @@ -185,6 +251,7 @@ dict_clear (struct dictionary *d) d->label = NULL; ds_destroy (&d->documents); dict_clear_vectors (d); + attrset_clear (&d->attributes); } /* Destroys the aux data for every variable in D, by calling @@ -194,10 +261,8 @@ dict_clear_aux (struct dictionary *d) { int i; - assert (d != NULL); - for (i = 0; i < d->var_cnt; i++) - var_clear_aux (d->var[i]); + var_clear_aux (d->var[i].var); } /* Clears a dictionary and destroys it. */ @@ -211,7 +276,8 @@ dict_destroy (struct dictionary *d) d->callbacks = NULL ; dict_clear (d); - hsh_destroy (d->name_tab); + hmap_destroy (&d->name_map); + attrset_destroy (&d->attributes); free (d); } } @@ -220,8 +286,6 @@ dict_destroy (struct dictionary *d) size_t dict_get_var_cnt (const struct dictionary *d) { - assert (d != NULL); - return d->var_cnt; } @@ -231,43 +295,42 @@ dict_get_var_cnt (const struct dictionary *d) struct variable * dict_get_var (const struct dictionary *d, size_t idx) { - assert (d != NULL); assert (idx < d->var_cnt); - return d->var[idx]; + return d->var[idx].var; } -inline void +/* Sets *VARS to an array of pointers to variables in D and *CNT + to the number of variables in *D. All variables are returned + except for those, if any, in the classes indicated by EXCLUDE. + (There is no point in putting DC_SYSTEM in EXCLUDE as + dictionaries never include system variables.) */ +void dict_get_vars (const struct dictionary *d, const struct variable ***vars, - size_t *cnt, unsigned exclude_classes) + size_t *cnt, enum dict_class exclude) { - dict_get_vars_mutable (d, (struct variable ***) vars, cnt, exclude_classes); + dict_get_vars_mutable (d, (struct variable ***) vars, cnt, exclude); } /* Sets *VARS to an array of pointers to variables in D and *CNT to the number of variables in *D. All variables are returned - if EXCLUDE_CLASSES is 0, or it may contain one or more of (1u - << DC_ORDINARY), (1u << DC_SYSTEM), or (1u << DC_SCRATCH) to - exclude the corresponding type of variable. */ + except for those, if any, in the classes indicated by EXCLUDE. + (There is no point in putting DC_SYSTEM in EXCLUDE as + dictionaries never include system variables.) */ void dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars, - size_t *cnt, unsigned exclude_classes) + size_t *cnt, enum dict_class exclude) { size_t count; size_t i; - assert (d != NULL); - assert (vars != NULL); - assert (cnt != NULL); - assert ((exclude_classes & ~((1u << DC_ORDINARY) - | (1u << DC_SYSTEM) - | (1u << DC_SCRATCH))) == 0); + assert (exclude == (exclude & DC_ALL)); count = 0; for (i = 0; i < d->var_cnt; i++) { - enum dict_class class = dict_class_from_id (var_get_name (d->var[i])); - if (!(exclude_classes & (1u << class))) + enum dict_class class = var_get_dict_class (d->var[i].var); + if (!(class & exclude)) count++; } @@ -275,9 +338,9 @@ dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars, *cnt = 0; for (i = 0; i < d->var_cnt; i++) { - enum dict_class class = dict_class_from_id (var_get_name (d->var[i])); - if (!(exclude_classes & (1u << class))) - (*vars)[(*cnt)++] = d->var[i]; + enum dict_class class = var_get_dict_class (d->var[i].var); + if (!(class & exclude)) + (*vars)[(*cnt)++] = d->var[i].var; } assert (*cnt == count); } @@ -285,26 +348,37 @@ dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars, static struct variable * add_var (struct dictionary *d, struct variable *v) { - /* Add dictionary info to variable. */ - struct vardict_info vdi; - vdi.case_index = d->next_value_idx; - vdi.dict_index = d->var_cnt; - vdi.dict = d; - var_set_vardict (v, &vdi); + struct vardict_info *vardict; /* Update dictionary. */ if (d->var_cnt >= d->var_cap) { - d->var_cap = 8 + 2 * d->var_cap; - d->var = xnrealloc (d->var, d->var_cap, sizeof *d->var); + size_t i; + + d->var = x2nrealloc (d->var, &d->var_cap, sizeof *d->var); + hmap_clear (&d->name_map); + for (i = 0; i < d->var_cnt; i++) + { + var_set_vardict (d->var[i].var, &d->var[i]); + hmap_insert_fast (&d->name_map, &d->var[i].name_node, + d->var[i].name_node.hash); + } } - d->var[d->var_cnt++] = v; - hsh_force_insert (d->name_tab, v); + vardict = &d->var[d->var_cnt++]; + vardict->dict = d; + vardict->var = v; + hmap_insert (&d->name_map, &vardict->name_node, + hash_case_string (var_get_name (v), 0)); + vardict->case_index = d->next_value_idx; + var_set_vardict (v, vardict); + + if ( d->changed ) d->changed (d, d->changed_data); if ( d->callbacks && d->callbacks->var_added ) d->callbacks->var_added (d, var_get_dict_index (v), d->cb_data); - d->next_value_idx += var_get_value_cnt (v); + d->next_value_idx++; + invalidate_proto (d); return v; } @@ -330,27 +404,46 @@ dict_create_var_assert (struct dictionary *d, const char *name, int width) return add_var (d, var_create (name, width)); } -/* Creates and returns a new variable in D with name NAME, as a - copy of existing variable OLD_VAR, which need not be in D or - in any dictionary. Returns a null pointer if the given NAME - would duplicate that of an existing variable in the +/* Creates and returns a new variable in D, as a copy of existing variable + OLD_VAR, which need not be in D or in any dictionary. Returns a null + pointer if OLD_VAR's name would duplicate that of an existing variable in + the dictionary. */ +struct variable * +dict_clone_var (struct dictionary *d, const struct variable *old_var) +{ + return dict_clone_var_as (d, old_var, var_get_name (old_var)); +} + +/* Creates and returns a new variable in D, as a copy of existing variable + OLD_VAR, which need not be in D or in any dictionary. Assert-fails if + OLD_VAR's name would duplicate that of an existing variable in the dictionary. */ struct variable * -dict_clone_var (struct dictionary *d, const struct variable *old_var, - const char *name) +dict_clone_var_assert (struct dictionary *d, const struct variable *old_var) +{ + return dict_clone_var_as_assert (d, old_var, var_get_name (old_var)); +} + +/* Creates and returns a new variable in D with name NAME, as a copy of + existing variable OLD_VAR, which need not be in D or in any dictionary. + Returns a null pointer if the given NAME would duplicate that of an existing + variable in the dictionary. */ +struct variable * +dict_clone_var_as (struct dictionary *d, const struct variable *old_var, + const char *name) { return (dict_lookup_var (d, name) == NULL - ? dict_clone_var_assert (d, old_var, name) + ? dict_clone_var_as_assert (d, old_var, name) : NULL); } -/* Creates and returns a new variable in D with name NAME, as a - copy of existing variable OLD_VAR, which need not be in D or - in any dictionary. Assert-fails if the given NAME would - duplicate that of an existing variable in the dictionary. */ +/* Creates and returns a new variable in D with name NAME, as a copy of + existing variable OLD_VAR, which need not be in D or in any dictionary. + Assert-fails if the given NAME would duplicate that of an existing variable + in the dictionary. */ struct variable * -dict_clone_var_assert (struct dictionary *d, const struct variable *old_var, - const char *name) +dict_clone_var_as_assert (struct dictionary *d, const struct variable *old_var, + const char *name) { struct variable *new_var = var_clone (old_var); assert (dict_lookup_var (d, name) == NULL); @@ -363,17 +456,17 @@ dict_clone_var_assert (struct dictionary *d, const struct variable *old_var, struct variable * dict_lookup_var (const struct dictionary *d, const char *name) { - struct variable *target ; - struct variable *result ; - - if ( ! var_is_valid_name (name, false)) - return NULL; + struct vardict_info *vardict; - target = var_create (name, 0); - result = hsh_find (d->name_tab, target); - var_destroy (target); + HMAP_FOR_EACH_WITH_HASH (vardict, struct vardict_info, name_node, + hash_case_string (name, 0), &d->name_map) + { + struct variable *var = vardict->var; + if (!strcasecmp (var_get_name (var), name)) + return var; + } - return result; + return NULL; } /* Returns the variable named NAME in D. Assert-fails if no @@ -391,15 +484,8 @@ dict_lookup_var_assert (const struct dictionary *d, const char *name) bool dict_contains_var (const struct dictionary *d, const struct variable *v) { - if (var_has_vardict (v)) - { - const struct vardict_info *vdi = var_get_vardict (v); - return (vdi->dict_index >= 0 - && vdi->dict_index < d->var_cnt - && d->var[vdi->dict_index] == v); - } - else - return false; + return (var_has_vardict (v) + && vardict_get_dictionary (var_get_vardict (v)) == d); } /* Compares two double pointers to variables, which should point @@ -413,26 +499,45 @@ compare_var_ptrs (const void *a_, const void *b_, const void *aux UNUSED) return *a < *b ? -1 : *a > *b; } -/* Sets the dict_index in V's vardict to DICT_INDEX. */ static void -set_var_dict_index (struct variable *v, int dict_index) +unindex_var (struct dictionary *d, struct vardict_info *vardict) { - struct vardict_info vdi = *var_get_vardict (v); - struct dictionary *d = vdi.dict; - vdi.dict_index = dict_index; - var_set_vardict (v, &vdi); + hmap_delete (&d->name_map, &vardict->name_node); +} +/* This function assumes that vardict->name_node.hash is valid, that is, that + its name has not changed since it was hashed (rename_var() updates this + hash along with the name itself). */ +static void +reindex_var (struct dictionary *d, struct vardict_info *vardict) +{ + struct variable *var = vardict->var; + + var_set_vardict (var, vardict); + hmap_insert_fast (&d->name_map, &vardict->name_node, + vardict->name_node.hash); + + if ( d->changed ) d->changed (d, d->changed_data); if ( d->callbacks && d->callbacks->var_changed ) - d->callbacks->var_changed (d, dict_index, d->cb_data); + d->callbacks->var_changed (d, var_get_dict_index (var), d->cb_data); } /* Sets the case_index in V's vardict to CASE_INDEX. */ static void set_var_case_index (struct variable *v, int case_index) { - struct vardict_info vdi = *var_get_vardict (v); - vdi.case_index = case_index; - var_set_vardict (v, &vdi); + var_get_vardict (v)->case_index = case_index; +} + +/* Removes the dictionary variables with indexes from FROM to TO (exclusive) + from name_map. */ +static void +unindex_vars (struct dictionary *d, size_t from, size_t to) +{ + size_t i; + + for (i = from; i < to; i++) + unindex_var (d, &d->var[i]); } /* Re-sets the dict_index in the dictionary variables with @@ -443,7 +548,7 @@ reindex_vars (struct dictionary *d, size_t from, size_t to) size_t i; for (i = from; i < to; i++) - set_var_dict_index (d->var[i], i); + reindex_var (d, &d->var[i]); } /* Deletes variable V from dictionary D and frees V. @@ -454,7 +559,7 @@ reindex_vars (struct dictionary *d, size_t from, size_t to) active on the dictionary's dataset, because those transformations might reference the deleted variable. The safest time to delete a variable is just after a procedure has - been executed, as done by MODIFY VARS. + been executed, as done by DELETE VARIABLES. Pointers to V within D are not a problem, because dict_delete_var() knows to remove V from split variables, @@ -464,7 +569,7 @@ dict_delete_var (struct dictionary *d, struct variable *v) { int dict_index = var_get_dict_index (v); const int case_index = var_get_case_index (v); - const int val_cnt = var_get_value_cnt (v); + const int width = var_get_width (v); assert (dict_contains_var (d, v)); @@ -482,22 +587,22 @@ dict_delete_var (struct dictionary *d, struct variable *v) dict_clear_vectors (d); /* Remove V from var array. */ + unindex_vars (d, dict_index, d->var_cnt); remove_element (d->var, d->var_cnt, sizeof *d->var, dict_index); d->var_cnt--; /* Update dict_index for each affected variable. */ reindex_vars (d, dict_index, d->var_cnt); - /* Update name hash. */ - hsh_force_delete (d->name_tab, v); - - /* Free memory. */ var_clear_vardict (v); var_destroy (v); + if ( d->changed ) d->changed (d, d->changed_data); + + invalidate_proto (d); if (d->callbacks && d->callbacks->var_deleted ) - d->callbacks->var_deleted (d, dict_index, case_index, val_cnt, d->cb_data); + d->callbacks->var_deleted (d, dict_index, case_index, width, d->cb_data); } /* Deletes the COUNT variables listed in VARS from D. This is @@ -508,7 +613,6 @@ dict_delete_vars (struct dictionary *d, { /* FIXME: this can be done in O(count) time, but this algorithm is O(count**2). */ - assert (d != NULL); assert (count == 0 || vars != NULL); while (count-- > 0) @@ -526,7 +630,7 @@ dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count) assert (idx + count <= d->var_cnt); while (count-- > 0) - dict_delete_var (d, d->var[idx]); + dict_delete_var (d, d->var[idx].var); } /* Deletes scratch variables from dictionary D. */ @@ -537,11 +641,9 @@ dict_delete_scratch_vars (struct dictionary *d) /* FIXME: this can be done in O(count) time, but this algorithm is O(count**2). */ - assert (d != NULL); - for (i = 0; i < d->var_cnt; ) - if (dict_class_from_id (var_get_name (d->var[i])) == DC_SCRATCH) - dict_delete_var (d, d->var[i]); + if (var_get_dict_class (d->var[i].var) == DC_SCRATCH) + dict_delete_var (d, d->var[i].var); else i++; } @@ -555,6 +657,8 @@ dict_reorder_var (struct dictionary *d, struct variable *v, size_t new_index) size_t old_index = var_get_dict_index (v); assert (new_index < d->var_cnt); + + unindex_vars (d, MIN (old_index, new_index), MAX (old_index, new_index) + 1); move_element (d->var, d->var_cnt, sizeof *d->var, old_index, new_index); reindex_vars (d, MIN (old_index, new_index), MAX (old_index, new_index) + 1); } @@ -567,46 +671,50 @@ void dict_reorder_vars (struct dictionary *d, struct variable *const *order, size_t count) { - struct variable **new_var; + struct vardict_info *new_var; size_t i; - assert (d != NULL); assert (count == 0 || order != NULL); assert (count <= d->var_cnt); - new_var = xnmalloc (d->var_cnt, sizeof *new_var); - memcpy (new_var, order, count * sizeof *new_var); + new_var = xnmalloc (d->var_cap, sizeof *new_var); + + /* Add variables in ORDER to new_var. */ for (i = 0; i < count; i++) { - size_t index = var_get_dict_index (order[i]); - assert (d->var[index] == order[i]); - d->var[index] = NULL; - set_var_dict_index (order[i], i); + struct vardict_info *old_var; + + assert (dict_contains_var (d, order[i])); + + old_var = var_get_vardict (order[i]); + new_var[i] = *old_var; + old_var->dict = NULL; } + + /* Add remaining variables to new_var. */ for (i = 0; i < d->var_cnt; i++) - if (d->var[i] != NULL) - { - assert (count < d->var_cnt); - new_var[count] = d->var[i]; - set_var_dict_index (new_var[count], count); - count++; - } + if (d->var[i].dict != NULL) + new_var[count++] = d->var[i]; + assert (count == d->var_cnt); + + /* Replace old vardicts by new ones. */ free (d->var); d->var = new_var; + + hmap_clear (&d->name_map); + reindex_vars (d, 0, d->var_cnt); } -/* Changes the name of variable V in dictionary D to NEW_NAME. */ +/* Changes the name of variable V that is currently in a dictionary to + NEW_NAME. */ static void -rename_var (struct dictionary *d, struct variable *v, const char *new_name) +rename_var (struct variable *v, const char *new_name) { - struct vardict_info vdi; - - assert (dict_contains_var (d, v)); - - vdi = *var_get_vardict (v); + struct vardict_info *vardict = var_get_vardict (v); var_clear_vardict (v); var_set_name (v, new_name); - var_set_vardict (v, &vdi); + vardict->name_node.hash = hash_case_string (new_name, 0); + var_set_vardict (v, vardict); } /* Changes the name of V in D to name NEW_NAME. Assert-fails if @@ -619,13 +727,14 @@ dict_rename_var (struct dictionary *d, struct variable *v, assert (!strcasecmp (var_get_name (v), new_name) || dict_lookup_var (d, new_name) == NULL); - hsh_force_delete (d->name_tab, v); - rename_var (d, v, new_name); - hsh_force_insert (d->name_tab, v); + unindex_var (d, var_get_vardict (v)); + rename_var (v, new_name); + reindex_var (d, var_get_vardict (v)); - if (get_algorithm () == ENHANCED) - var_clear_short_name (v); + if (settings_get_algorithm () == ENHANCED) + var_clear_short_names (v); + if ( d->changed ) d->changed (d, d->changed_data); if ( d->callbacks && d->callbacks->var_changed ) d->callbacks->var_changed (d, var_get_dict_index (v), d->cb_data); } @@ -658,65 +767,184 @@ dict_rename_vars (struct dictionary *d, and rename them. */ for (i = 0; i < count; i++) { - hsh_force_delete (d->name_tab, vars[i]); - rename_var (d, vars[i], new_names[i]); + unindex_var (d, var_get_vardict (vars[i])); + rename_var (vars[i], new_names[i]); } /* Add the renamed variables back into the name hash, checking for conflicts. */ for (i = 0; i < count; i++) - if (hsh_insert (d->name_tab, vars[i]) != NULL) - { - /* There is a name conflict. - Back out all the name changes that have already - taken place, and indicate failure. */ - size_t fail_idx = i; - if (err_name != NULL) - *err_name = new_names[i]; - - for (i = 0; i < fail_idx; i++) - hsh_force_delete (d->name_tab, vars[i]); - - for (i = 0; i < count; i++) - { - rename_var (d, vars[i], old_names[i]); - hsh_force_insert (d->name_tab, vars[i]); - } - - pool_destroy (pool); - return false; - } + { + if (dict_lookup_var (d, var_get_name (vars[i])) != NULL) + { + /* There is a name conflict. + Back out all the name changes that have already + taken place, and indicate failure. */ + size_t fail_idx = i; + if (err_name != NULL) + *err_name = new_names[i]; + + for (i = 0; i < fail_idx; i++) + unindex_var (d, var_get_vardict (vars[i])); + + for (i = 0; i < count; i++) + { + rename_var (vars[i], old_names[i]); + reindex_var (d, var_get_vardict (vars[i])); + } + + pool_destroy (pool); + return false; + } + reindex_var (d, var_get_vardict (vars[i])); + } /* Clear short names. */ - if (get_algorithm () == ENHANCED) + if (settings_get_algorithm () == ENHANCED) for (i = 0; i < count; i++) - var_clear_short_name (vars[i]); + var_clear_short_names (vars[i]); pool_destroy (pool); return true; } +/* Returns true if a variable named NAME may be inserted in DICT; + that is, if there is not already a variable with that name in + DICT and if NAME is not a reserved word. (The caller's checks + have already verified that NAME is otherwise acceptable as a + variable name.) */ +static bool +var_name_is_insertable (const struct dictionary *dict, const char *name) +{ + return (dict_lookup_var (dict, name) == NULL + && lex_id_to_token (ss_cstr (name)) == T_ID); +} + +static bool +make_hinted_name (const struct dictionary *dict, const char *hint, + char name[VAR_NAME_LEN + 1]) +{ + bool dropped = false; + char *cp; + + for (cp = name; *hint && cp < name + VAR_NAME_LEN; hint++) + { + if (cp == name + ? lex_is_id1 (*hint) && *hint != '$' + : lex_is_idn (*hint)) + { + if (dropped) + { + *cp++ = '_'; + dropped = false; + } + if (cp < name + VAR_NAME_LEN) + *cp++ = *hint; + } + else if (cp > name) + dropped = true; + } + *cp = '\0'; + + if (name[0] != '\0') + { + size_t len = strlen (name); + unsigned long int i; + + if (var_name_is_insertable (dict, name)) + return true; + + for (i = 0; i < ULONG_MAX; i++) + { + char suffix[INT_BUFSIZE_BOUND (i) + 1]; + int ofs; + + suffix[0] = '_'; + if (!str_format_26adic (i + 1, &suffix[1], sizeof suffix - 1)) + NOT_REACHED (); + + ofs = MIN (VAR_NAME_LEN - strlen (suffix), len); + strcpy (&name[ofs], suffix); + + if (var_name_is_insertable (dict, name)) + return true; + } + } + + return false; +} + +static bool +make_numeric_name (const struct dictionary *dict, unsigned long int *num_start, + char name[VAR_NAME_LEN + 1]) +{ + unsigned long int number; + + for (number = num_start != NULL ? MAX (*num_start, 1) : 1; + number < ULONG_MAX; + number++) + { + sprintf (name, "VAR%03lu", number); + if (dict_lookup_var (dict, name) == NULL) + { + if (num_start != NULL) + *num_start = number + 1; + return true; + } + } + + if (num_start != NULL) + *num_start = ULONG_MAX; + return false; +} + + +/* Attempts to devise a variable name unique within DICT. + Returns true if successful, in which case the new variable + name is stored into NAME. Returns false if all names that can + be generated have already been taken. (Returning false is + quite unlikely: at least ULONG_MAX unique names can be + generated.) + + HINT, if it is non-null, is used as a suggestion that will be + modified for suitability as a variable name and for + uniqueness. + + If HINT is null or entirely unsuitable, a name in the form + "VAR%03d" will be generated, where the smallest unused integer + value is used. If NUM_START is non-null, then its value is + used as the minimum numeric value to check, and it is updated + to the next value to be checked. + */ +bool +dict_make_unique_var_name (const struct dictionary *dict, const char *hint, + unsigned long int *num_start, + char name[VAR_NAME_LEN + 1]) +{ + return ((hint != NULL && make_hinted_name (dict, hint, name)) + || make_numeric_name (dict, num_start, name)); +} + /* Returns the weighting variable in dictionary D, or a null pointer if the dictionary is unweighted. */ struct variable * dict_get_weight (const struct dictionary *d) { - assert (d != NULL); assert (d->weight == NULL || dict_contains_var (d, d->weight)); return d->weight; } -/* Returns the value of D's weighting variable in case C, except that a - negative weight is returned as 0. Returns 1 if the dictionary is - unweighted. Will warn about missing, negative, or zero values if - warn_on_invalid is true. The function will set warn_on_invalid to false - if an invalid weight is found. */ +/* Returns the value of D's weighting variable in case C, except + that a negative weight is returned as 0. Returns 1 if the + dictionary is unweighted. Will warn about missing, negative, + or zero values if *WARN_ON_INVALID is true. The function will + set *WARN_ON_INVALID to false if an invalid weight is + found. */ double dict_get_case_weight (const struct dictionary *d, const struct ccase *c, bool *warn_on_invalid) { - assert (d != NULL); assert (c != NULL); if (d->weight == NULL) @@ -741,12 +969,12 @@ dict_get_case_weight (const struct dictionary *d, const struct ccase *c, void dict_set_weight (struct dictionary *d, struct variable *v) { - assert (d != NULL); assert (v == NULL || dict_contains_var (d, v)); assert (v == NULL || var_is_numeric (v)); d->weight = v; + if (d->changed) d->changed (d, d->changed_data); if ( d->callbacks && d->callbacks->weight_changed ) d->callbacks->weight_changed (d, v ? var_get_dict_index (v) : -1, @@ -758,7 +986,6 @@ dict_set_weight (struct dictionary *d, struct variable *v) struct variable * dict_get_filter (const struct dictionary *d) { - assert (d != NULL); assert (d->filter == NULL || dict_contains_var (d, d->filter)); return d->filter; @@ -769,11 +996,12 @@ dict_get_filter (const struct dictionary *d) void dict_set_filter (struct dictionary *d, struct variable *v) { - assert (d != NULL); assert (v == NULL || dict_contains_var (d, v)); + assert (v == NULL || var_is_numeric (v)); d->filter = v; + if (d->changed) d->changed (d, d->changed_data); if ( d->callbacks && d->callbacks->filter_changed ) d->callbacks->filter_changed (d, v ? var_get_dict_index (v) : -1, @@ -782,32 +1010,45 @@ dict_set_filter (struct dictionary *d, struct variable *v) /* Returns the case limit for dictionary D, or zero if the number of cases is unlimited. */ -size_t +casenumber dict_get_case_limit (const struct dictionary *d) { - assert (d != NULL); - return d->case_limit; } /* Sets CASE_LIMIT as the case limit for dictionary D. Use 0 for CASE_LIMIT to indicate no limit. */ void -dict_set_case_limit (struct dictionary *d, size_t case_limit) +dict_set_case_limit (struct dictionary *d, casenumber case_limit) { - assert (d != NULL); - d->case_limit = case_limit; } +/* Returns the prototype used for cases created by dictionary D. */ +const struct caseproto * +dict_get_proto (const struct dictionary *d_) +{ + struct dictionary *d = CONST_CAST (struct dictionary *, d_); + if (d->proto == NULL) + { + size_t i; + + d->proto = caseproto_create (); + d->proto = caseproto_reserve (d->proto, d->var_cnt); + for (i = 0; i < d->var_cnt; i++) + d->proto = caseproto_set_width (d->proto, + var_get_case_index (d->var[i].var), + var_get_width (d->var[i].var)); + } + return d->proto; +} + /* Returns the case index of the next value to be added to D. This value is the number of `union value's that need to be allocated to store a case for dictionary D. */ int dict_get_next_value_idx (const struct dictionary *d) { - assert (d != NULL); - return d->next_value_idx; } @@ -816,236 +1057,83 @@ dict_get_next_value_idx (const struct dictionary *d) size_t dict_get_case_size (const struct dictionary *d) { - assert (d != NULL); - return sizeof (union value) * dict_get_next_value_idx (d); } -/* Deletes scratch variables in dictionary D and reassigns values - so that fragmentation is eliminated. */ +/* Reassigns values in dictionary D so that fragmentation is + eliminated. */ void dict_compact_values (struct dictionary *d) { size_t i; d->next_value_idx = 0; - for (i = 0; i < d->var_cnt; ) - { - struct variable *v = d->var[i]; - - if (dict_class_from_id (var_get_name (v)) != DC_SCRATCH) - { - set_var_case_index (v, d->next_value_idx); - d->next_value_idx += var_get_value_cnt (v); - i++; - } - else - dict_delete_var (d, v); - } -} - - -/* - Reassigns case indices for D, increasing each index above START by - the value PADDING. -*/ -static void -dict_pad_values (struct dictionary *d, int start, int padding) -{ - size_t i; - - if ( padding <= 0 ) - return; - - for (i = 0; i < d->var_cnt; ++i) + for (i = 0; i < d->var_cnt; i++) { - struct variable *v = d->var[i]; - - int index = var_get_case_index (v); - - if ( index >= start) - set_var_case_index (v, index + padding); + struct variable *v = d->var[i].var; + set_var_case_index (v, d->next_value_idx++); } - - d->next_value_idx += padding; + invalidate_proto (d); } +/* Returns the number of values occupied by the variables in + dictionary D. All variables are considered if EXCLUDE_CLASSES + is 0, or it may contain one or more of (1u << DC_ORDINARY), + (1u << DC_SYSTEM), or (1u << DC_SCRATCH) to exclude the + corresponding type of variable. -/* Returns the number of values that would be used by a case if - dict_compact_values() were called. */ + The return value may be less than the number of values in one + of dictionary D's cases (as returned by + dict_get_next_value_idx) even if E is 0, because there may be + gaps in D's cases due to deleted variables. */ size_t -dict_get_compacted_value_cnt (const struct dictionary *d) +dict_count_values (const struct dictionary *d, unsigned int exclude_classes) { size_t i; size_t cnt; - cnt = 0; - for (i = 0; i < d->var_cnt; i++) - if (dict_class_from_id (var_get_name (d->var[i])) != DC_SCRATCH) - cnt += var_get_value_cnt (d->var[i]); - return cnt; -} - -/* Creates and returns an array mapping from a dictionary index - to the case index that the corresponding variable will have - after calling dict_compact_values(). Scratch variables - receive -1 for case index because dict_compact_values() will - delete them. */ -int * -dict_get_compacted_dict_index_to_case_index (const struct dictionary *d) -{ - size_t i; - size_t next_value_idx; - int *map; + assert ((exclude_classes & ~((1u << DC_ORDINARY) + | (1u << DC_SYSTEM) + | (1u << DC_SCRATCH))) == 0); - map = xnmalloc (d->var_cnt, sizeof *map); - next_value_idx = 0; + cnt = 0; for (i = 0; i < d->var_cnt; i++) { - struct variable *v = d->var[i]; - - if (dict_class_from_id (var_get_name (v)) != DC_SCRATCH) - { - map[i] = next_value_idx; - next_value_idx += var_get_value_cnt (v); - } - else - map[i] = -1; - } - return map; -} - -/* Returns true if a case for dictionary D would be smaller after - compacting, false otherwise. Compacting a case eliminates - "holes" between values and after the last value. Holes are - created by deleting variables (or by scratch variables). - - The return value may differ from whether compacting a case - from dictionary D would *change* the case: compacting could - rearrange values even if it didn't reduce space - requirements. */ -bool -dict_compacting_would_shrink (const struct dictionary *d) -{ - return dict_get_compacted_value_cnt (d) < dict_get_next_value_idx (d); -} - -/* Returns true if a case for dictionary D would change after - compacting, false otherwise. Compacting a case eliminates - "holes" between values and after the last value. Holes are - created by deleting variables (or by scratch variables). - - The return value may differ from whether compacting a case - from dictionary D would *shrink* the case: compacting could - rearrange values without reducing space requirements. */ -bool -dict_compacting_would_change (const struct dictionary *d) -{ - size_t case_idx; - size_t i; - - case_idx = 0; - for (i = 0; i < dict_get_var_cnt (d); i++) - { - struct variable *v = dict_get_var (d, i); - if (var_get_case_index (v) != case_idx) - return true; - case_idx += var_get_value_cnt (v); + enum dict_class class = var_get_dict_class (d->var[i].var); + if (!(exclude_classes & (1u << class))) + cnt++; } - return false; + return cnt; } - -/* How to copy a contiguous range of values between cases. */ -struct copy_map - { - size_t src_idx; /* Starting value index in source case. */ - size_t dst_idx; /* Starting value index in target case. */ - size_t cnt; /* Number of values. */ - }; -/* How to compact a case. */ -struct dict_compactor - { - struct copy_map *maps; /* Array of mappings. */ - size_t map_cnt; /* Number of mappings. */ - }; +/* Returns the case prototype that would result after deleting + all variables from D that are not in one of the + EXCLUDE_CLASSES and compacting the dictionary with + dict_compact(). -/* Creates and returns a dict_compactor that can be used to - compact cases for dictionary D. - - Compacting a case eliminates "holes" between values and after - the last value. Holes are created by deleting variables (or - by scratch variables). */ -struct dict_compactor * -dict_make_compactor (const struct dictionary *d) + The caller must unref the returned caseproto when it is no + longer needed. */ +struct caseproto * +dict_get_compacted_proto (const struct dictionary *d, + unsigned int exclude_classes) { - struct dict_compactor *compactor; - struct copy_map *map; - size_t map_allocated; - size_t value_idx; + struct caseproto *proto; size_t i; - compactor = xmalloc (sizeof *compactor); - compactor->maps = NULL; - compactor->map_cnt = 0; - map_allocated = 0; + assert ((exclude_classes & ~((1u << DC_ORDINARY) + | (1u << DC_SYSTEM) + | (1u << DC_SCRATCH))) == 0); - value_idx = 0; - map = NULL; + proto = caseproto_create (); for (i = 0; i < d->var_cnt; i++) { - struct variable *v = d->var[i]; - - if (dict_class_from_id (var_get_name (v)) == DC_SCRATCH) - continue; - if (map != NULL && map->src_idx + map->cnt == var_get_case_index (v)) - map->cnt += var_get_value_cnt (v); - else - { - if (compactor->map_cnt == map_allocated) - compactor->maps = x2nrealloc (compactor->maps, &map_allocated, - sizeof *compactor->maps); - map = &compactor->maps[compactor->map_cnt++]; - map->src_idx = var_get_case_index (v); - map->dst_idx = value_idx; - map->cnt = var_get_value_cnt (v); - } - value_idx += var_get_value_cnt (v); - } - - return compactor; -} - -/* Compacts SRC by copying it to DST according to the scheme in - COMPACTOR. - - Compacting a case eliminates "holes" between values and after - the last value. Holes are created by deleting variables (or - by scratch variables). */ -void -dict_compactor_compact (const struct dict_compactor *compactor, - struct ccase *dst, const struct ccase *src) -{ - size_t i; - - for (i = 0; i < compactor->map_cnt; i++) - { - const struct copy_map *map = &compactor->maps[i]; - case_copy (dst, map->dst_idx, src, map->src_idx, map->cnt); + struct variable *v = d->var[i].var; + if (!(exclude_classes & (1u << var_get_dict_class (v)))) + proto = caseproto_add_width (proto, var_get_width (v)); } + return proto; } - -/* Destroys COMPACTOR. */ -void -dict_compactor_destroy (struct dict_compactor *compactor) -{ - if (compactor != NULL) - { - free (compactor->maps); - free (compactor); - } -} - + /* Returns the SPLIT FILE vars (see cmd_split_file()). Call dict_get_split_cnt() to determine how many SPLIT FILE vars there are. Returns a null pointer if and only if there are no @@ -1053,8 +1141,6 @@ dict_compactor_destroy (struct dict_compactor *compactor) const struct variable *const * dict_get_split_vars (const struct dictionary *d) { - assert (d != NULL); - return d->split; } @@ -1062,25 +1148,29 @@ dict_get_split_vars (const struct dictionary *d) size_t dict_get_split_cnt (const struct dictionary *d) { - assert (d != NULL); - return d->split_cnt; } -/* Removes variable V from the set of split variables in dictionary D */ +/* Removes variable V, which must be in D, from D's set of split + variables. */ void -dict_unset_split_var (struct dictionary *d, - struct variable *v) +dict_unset_split_var (struct dictionary *d, struct variable *v) { - const int count = d->split_cnt; - d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split, - &v, compare_var_ptrs, NULL); + int orig_count; - if ( count == d->split_cnt) - return; + assert (dict_contains_var (d, v)); - if ( d->callbacks && d->callbacks->split_changed ) - d->callbacks->split_changed (d, d->cb_data); + orig_count = d->split_cnt; + d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split, + &v, compare_var_ptrs, NULL); + if (orig_count != d->split_cnt) + { + if (d->changed) d->changed (d, d->changed_data); + /* We changed the set of split variables so invoke the + callback. */ + if (d->callbacks && d->callbacks->split_changed) + d->callbacks->split_changed (d, d->cb_data); + } } /* Sets CNT split vars SPLIT in dictionary D. */ @@ -1088,13 +1178,21 @@ void dict_set_split_vars (struct dictionary *d, struct variable *const *split, size_t cnt) { - assert (d != NULL); assert (cnt == 0 || split != NULL); d->split_cnt = cnt; - d->split = cnt > 0 ? xnrealloc (d->split, cnt, sizeof *d->split) : NULL; - memcpy (d->split, split, cnt * sizeof *d->split); + if ( cnt > 0 ) + { + d->split = xnrealloc (d->split, cnt, sizeof *d->split) ; + memcpy (d->split, split, cnt * sizeof *d->split); + } + else + { + free (d->split); + d->split = NULL; + } + if (d->changed) d->changed (d, d->changed_data); if ( d->callbacks && d->callbacks->split_changed ) d->callbacks->split_changed (d, d->cb_data); } @@ -1104,8 +1202,6 @@ dict_set_split_vars (struct dictionary *d, const char * dict_get_label (const struct dictionary *d) { - assert (d != NULL); - return d->label; } @@ -1114,19 +1210,8 @@ dict_get_label (const struct dictionary *d) void dict_set_label (struct dictionary *d, const char *label) { - assert (d != NULL); - free (d->label); - if (label == NULL) - d->label = NULL; - else if (strlen (label) < 60) - d->label = xstrdup (label); - else - { - d->label = xmalloc (61); - memcpy (d->label, label, 60); - d->label[60] = '\0'; - } + d->label = label != NULL ? xstrndup (label, 60) : NULL; } /* Returns the documents for D, or a null pointer if D has no @@ -1177,7 +1262,7 @@ dict_add_document_line (struct dictionary *d, const char *line) msg (SW, _("Truncating document line to %d bytes."), DOC_LINE_LENGTH); } buf_copy_str_rpad (ds_put_uninit (&d->documents, DOC_LINE_LENGTH), - DOC_LINE_LENGTH, line); + DOC_LINE_LENGTH, line, ' '); } /* Returns the number of document lines in dictionary D. */ @@ -1209,7 +1294,6 @@ dict_create_vector (struct dictionary *d, { size_t i; - assert (var != NULL); assert (cnt > 0); for (i = 0; i < cnt; i++) assert (dict_contains_var (d, var[i])); @@ -1241,7 +1325,6 @@ dict_create_vector_assert (struct dictionary *d, const struct vector * dict_get_vector (const struct dictionary *d, size_t idx) { - assert (d != NULL); assert (idx < d->vector_cnt); return d->vector[idx]; @@ -1251,8 +1334,6 @@ dict_get_vector (const struct dictionary *d, size_t idx) size_t dict_get_vector_cnt (const struct dictionary *d) { - assert (d != NULL); - return d->vector_cnt; } @@ -1282,166 +1363,142 @@ dict_clear_vectors (struct dictionary *d) d->vector_cnt = 0; } -/* Compares two strings. */ -static int -compare_strings (const void *a, const void *b, const void *aux UNUSED) +/* Returns D's attribute set. The caller may examine or modify + the attribute set, but must not destroy it. Destroying D or + calling dict_set_attributes for D will also destroy D's + attribute set. */ +struct attrset * +dict_get_attributes (const struct dictionary *d) { - return strcmp (a, b); + return CONST_CAST (struct attrset *, &d->attributes); } -/* Hashes a string. */ -static unsigned -hash_string (const void *s, const void *aux UNUSED) +/* Replaces D's attributes set by a copy of ATTRS. */ +void +dict_set_attributes (struct dictionary *d, const struct attrset *attrs) { - return hsh_hash_string (s); + attrset_destroy (&d->attributes); + attrset_clone (&d->attributes, attrs); } - -/* Sets V's short name to BASE, followed by a suffix of the form - _A, _B, _C, ..., _AA, _AB, etc. according to the value of - SUFFIX_NUMBER. Truncates BASE as necessary to fit. */ -static void -set_var_short_name_suffix (struct variable *v, const char *base, - int suffix_number) +/* Returns true if D has at least one attribute in its attribute + set, false if D's attribute set is empty. */ +bool +dict_has_attributes (const struct dictionary *d) { - char suffix[SHORT_NAME_LEN + 1]; - char short_name[SHORT_NAME_LEN + 1]; - char *start, *end; - int len, ofs; - - assert (v != NULL); - assert (suffix_number >= 0); - - /* Set base name. */ - var_set_short_name (v, base); - - /* Compose suffix. */ - start = end = suffix + sizeof suffix - 1; - *end = '\0'; - do - { - *--start = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[suffix_number % 26]; - if (start <= suffix + 1) - msg (SE, _("Variable suffix too large.")); - suffix_number /= 26; - } - while (suffix_number > 0); - *--start = '_'; - - /* Append suffix to V's short name. */ - str_copy_trunc (short_name, sizeof short_name, base); - len = end - start; - if (len + strlen (short_name) > SHORT_NAME_LEN) - ofs = SHORT_NAME_LEN - len; - else - ofs = strlen (short_name); - strcpy (short_name + ofs, start); - - /* Set name. */ - var_set_short_name (v, short_name); + return attrset_count (&d->attributes) > 0; } -/* Assigns a valid, unique short_name[] to each variable in D. - Each variable whose actual name is short has highest priority - for that short name. Otherwise, variables with an existing - short_name[] have the next highest priority for a given short - name; if it is already taken, then the variable is treated as - if short_name[] had been empty. Otherwise, long names are - truncated to form short names. If that causes conflicts, - variables are renamed as PREFIX_A, PREFIX_B, and so on. */ +/* Called from variable.c to notify the dictionary that some property of + the variable has changed */ void -dict_assign_short_names (struct dictionary *d) +dict_var_changed (const struct variable *v) { - struct hsh_table *short_names; - size_t i; - - /* Give variables whose names are short the corresponding short - names, and clear short_names[] that conflict with a variable - name. */ - for (i = 0; i < d->var_cnt; i++) - { - struct variable *v = d->var[i]; - const char *short_name = var_get_short_name (v); - if (strlen (var_get_name (v)) <= SHORT_NAME_LEN) - var_set_short_name (v, var_get_name (v)); - else if (short_name != NULL && dict_lookup_var (d, short_name) != NULL) - var_clear_short_name (v); - } - - /* Each variable with an assigned short_name[] now gets it - unless there is a conflict. */ - short_names = hsh_create (d->var_cnt, compare_strings, hash_string, - NULL, NULL); - for (i = 0; i < d->var_cnt; i++) + if ( var_has_vardict (v)) { - struct variable *v = d->var[i]; - const char *name = var_get_short_name (v); - if (name != NULL && hsh_insert (short_names, (char *) name) != NULL) - var_clear_short_name (v); - } + const struct vardict_info *vardict = var_get_vardict (v); + struct dictionary *d = vardict->dict; - /* Now assign short names to remaining variables. */ - for (i = 0; i < d->var_cnt; i++) - { - struct variable *v = d->var[i]; - const char *name = var_get_short_name (v); - if (name == NULL) - { - /* Form initial short_name from the variable name, then - try _A, _B, ... _AA, _AB, etc., if needed.*/ - int trial = 0; - do - { - if (trial == 0) - var_set_short_name (v, var_get_name (v)); - else - set_var_short_name_suffix (v, var_get_name (v), trial - 1); + if ( NULL == d) + return; - trial++; - } - while (hsh_insert (short_names, (char *) var_get_short_name (v)) - != NULL); - } + if (d->changed ) d->changed (d, d->changed_data); + if ( d->callbacks && d->callbacks->var_changed ) + d->callbacks->var_changed (d, var_get_dict_index (v), d->cb_data); } - - /* Get rid of hash table. */ - hsh_destroy (short_names); } -/* Called from variable.c to notify the dictionary that some property of - the variable has changed */ +/* Called from variable.c to notify the dictionary that the variable's width + has changed */ void -dict_var_changed (const struct variable *v) +dict_var_resized (const struct variable *v, int old_width) { if ( var_has_vardict (v)) { - const struct vardict_info *vdi = var_get_vardict (v); + const struct vardict_info *vardict = var_get_vardict (v); struct dictionary *d; - d = vdi->dict; + d = vardict->dict; - if ( d->callbacks && d->callbacks->var_changed ) - d->callbacks->var_changed (d, var_get_dict_index (v), d->cb_data); + if (d->changed) d->changed (d, d->changed_data); + + invalidate_proto (d); + if ( d->callbacks && d->callbacks->var_resized ) + d->callbacks->var_resized (d, var_get_dict_index (v), old_width, + d->cb_data); } } - -/* Called from variable.c to notify the dictionary that the variable's width +/* Called from variable.c to notify the dictionary that the variable's display width has changed */ void -dict_var_resized (const struct variable *v, int delta) +dict_var_display_width_changed (const struct variable *v) { if ( var_has_vardict (v)) { - const struct vardict_info *vdi = var_get_vardict (v); + const struct vardict_info *vardict = var_get_vardict (v); struct dictionary *d; - d = vdi->dict; + d = vardict->dict; - dict_pad_values (d, var_get_case_index(v) + 1, delta); + if (d->changed) d->changed (d, d->changed_data); + if ( d->callbacks && d->callbacks->var_display_width_changed ) + d->callbacks->var_display_width_changed (d, var_get_dict_index (v), d->cb_data); + } +} + +/* Dictionary used to contain "internal variables". */ +static struct dictionary *internal_dict; - if ( d->callbacks && d->callbacks->var_resized ) - d->callbacks->var_resized (d, var_get_dict_index (v), delta, d->cb_data); +/* Create a variable of the specified WIDTH to be used for internal + calculations only. The variable is assigned case index CASE_IDX. */ +struct variable * +dict_create_internal_var (int case_idx, int width) +{ + if (internal_dict == NULL) + internal_dict = dict_create (); + + for (;;) + { + static int counter = INT_MAX / 2; + struct variable *var; + char name[64]; + + if (++counter == INT_MAX) + counter = INT_MAX / 2; + + sprintf (name, "$internal%d", counter); + var = dict_create_var (internal_dict, name, width); + if (var != NULL) + { + set_var_case_index (var, case_idx); + return var; + } + } +} + +/* Destroys VAR, which must have been created with + dict_create_internal_var(). */ +void +dict_destroy_internal_var (struct variable *var) +{ + if (var != NULL) + { + dict_delete_var (internal_dict, var); + + /* Destroy internal_dict if it has no variables left, just so that + valgrind --leak-check --show-reachable won't show internal_dict. */ + if (dict_get_var_cnt (internal_dict) == 0) + { + dict_destroy (internal_dict); + internal_dict = NULL; + } } } + +int +vardict_get_dict_index (const struct vardict_info *vardict) +{ + return vardict - vardict->dict->var; +}