X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fdictionary.c;h=2c4633f7f9804b93b87570598481d813fad77488;hb=1dcdba517fbb5c99c37e0a03275325f256975c7c;hp=ab4642a4da493c536b499a60e71479cbb14f7670;hpb=8f7af0acaf8a9253242d89fcdb26e285841f7833;p=pspp diff --git a/src/data/dictionary.c b/src/data/dictionary.c index ab4642a4da..2c4633f7f9 100644 --- a/src/data/dictionary.c +++ b/src/data/dictionary.c @@ -32,6 +32,7 @@ #include "data/value-labels.h" #include "data/vardict.h" #include "data/variable.h" +#include "data/varset.h" #include "data/vector.h" #include "libpspp/array.h" #include "libpspp/assertion.h" @@ -58,24 +59,27 @@ struct dictionary { int ref_cnt; - struct vardict_info *var; /* Variables. */ - size_t var_cnt, var_cap; /* Number of variables, capacity. */ + struct vardict_info *vars; /* Variables. */ + size_t n_vars; /* Number of variables. */ + size_t allocated_vars; /* Allocated space in 'vars'. */ 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. */ + size_t n_splits; /* SPLIT FILE count. */ + enum split_type split_type; struct variable *weight; /* WEIGHT variable. */ struct variable *filter; /* FILTER variable. */ casenumber case_limit; /* Current case limit (N command). */ char *label; /* File label. */ struct string_array documents; /* Documents. */ struct vector **vector; /* Vectors of variables. */ - size_t vector_cnt; /* Number of vectors. */ + size_t n_vectors; /* Number of vectors. */ struct attrset attributes; /* Custom attributes. */ struct mrset **mrsets; /* Multiple response sets. */ size_t n_mrsets; /* Number of multiple response sets. */ + struct varset **varsets; /* Variable sets. */ + size_t n_varsets; /* Number of variable sets. */ /* Whether variable names must be valid identifiers. Normally, this is true, but sometimes a dictionary is prepared for external use @@ -94,6 +98,7 @@ struct dictionary static void dict_unset_split_var (struct dictionary *, struct variable *, bool); static void dict_unset_mrset_var (struct dictionary *, struct variable *); +static void dict_unset_varset_var (struct dictionary *, struct variable *); /* Compares two double pointers to variables, which should point to elements of a struct dictionary's `var' member array. */ @@ -153,7 +158,7 @@ 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]); + unindex_var (d, &d->vars[i]); } /* Re-sets the dict_index in the dictionary variables with @@ -164,7 +169,7 @@ reindex_vars (struct dictionary *d, size_t from, size_t to, bool skip_callbacks) size_t i; for (i = from; i < to; i++) - reindex_var (d, &d->var[i], skip_callbacks); + reindex_var (d, &d->vars[i], skip_callbacks); } @@ -177,15 +182,35 @@ dict_get_encoding (const struct dictionary *d) return d->encoding ; } +/* Checks whether UTF-8 string ID is an acceptable identifier in DICT's + encoding. Returns true if it is, otherwise an error message that the caller + must free(). */ +char * WARN_UNUSED_RESULT +dict_id_is_valid__ (const struct dictionary *dict, const char *id) +{ + if (!dict->names_must_be_ids) + return NULL; + return id_is_valid__ (id, dict->encoding); +} + +static bool +error_to_bool (char *error) +{ + if (error) + { + free (error); + return false; + } + else + return true; +} + /* Returns true if UTF-8 string ID is an acceptable identifier in DICT's - encoding, false otherwise. If ISSUE_ERROR is true, issues an explanatory - error message on failure. */ + encoding, false otherwise. */ bool -dict_id_is_valid (const struct dictionary *dict, const char *id, - bool issue_error) +dict_id_is_valid (const struct dictionary *dict, const char *id) { - return (!dict->names_must_be_ids - || id_is_valid (id, dict->encoding, issue_error)); + return error_to_bool (dict_id_is_valid__ (dict, id)); } void @@ -212,9 +237,9 @@ void dict_dump (const struct dictionary *d) { int i; - for (i = 0 ; i < d->var_cnt ; ++i) + for (i = 0 ; i < d->n_vars ; ++i) { - const struct variable *v = d->var[i].var; + const struct variable *v = d->vars[i].var; printf ("Name: %s;\tdict_idx: %zu; case_idx: %zu\n", var_get_name (v), var_get_dict_index (v), @@ -250,13 +275,16 @@ dict_copy_callbacks (struct dictionary *dest, struct dictionary * dict_create (const char *encoding) { - struct dictionary *d = XZALLOC (struct dictionary); + struct dictionary *d = xmalloc (sizeof *d); - d->encoding = xstrdup (encoding); - d->names_must_be_ids = true; - hmap_init (&d->name_map); - attrset_init (&d->attributes); - d->ref_cnt = 1; + *d = (struct dictionary) { + .encoding = xstrdup (encoding), + .names_must_be_ids = true, + .name_map = HMAP_INITIALIZER (d->name_map), + .attributes = ATTRSET_INITIALIZER (d->attributes), + .split_type = SPLIT_NONE, + .ref_cnt = 1, + }; return d; } @@ -264,43 +292,32 @@ dict_create (const char *encoding) /* Creates and returns a (deep) copy of an existing 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. - Callbacks are not cloned. */ struct dictionary * dict_clone (const struct dictionary *s) { - struct dictionary *d; - size_t i; - - d = dict_create (s->encoding); + struct dictionary *d = dict_create (s->encoding); dict_set_names_must_be_ids (d, dict_get_names_must_be_ids (s)); - for (i = 0; i < s->var_cnt; i++) + for (size_t i = 0; i < s->n_vars; i++) { - struct variable *sv = s->var[i].var; + struct variable *sv = s->vars[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)); + for (size_t j = 0; j < var_get_n_short_names (sv); j++) + var_set_short_name (dv, j, var_get_short_name (sv, j)); var_get_vardict (dv)->case_index = var_get_vardict (sv)->case_index; } - d->next_value_idx = s->next_value_idx; - - d->split_cnt = s->split_cnt; - if (d->split_cnt > 0) + d->n_splits = s->n_splits; + if (d->n_splits > 0) { - d->split = xnmalloc (d->split_cnt, sizeof *d->split); - for (i = 0; i < d->split_cnt; i++) - d->split[i] = dict_lookup_var_assert (d, var_get_name (s->split[i])); + d->split = xnmalloc (d->n_splits, sizeof *d->split); + for (size_t i = 0; i < d->n_splits; i++) + d->split[i] = dict_lookup_var_assert (d, var_get_name (s->split[i])); } + d->split_type = s->split_type; if (s->weight != NULL) dict_set_weight (d, dict_lookup_var_assert (d, var_get_name (s->weight))); @@ -312,14 +329,14 @@ dict_clone (const struct dictionary *s) dict_set_label (d, dict_get_label (s)); dict_set_documents (d, dict_get_documents (s)); - d->vector_cnt = s->vector_cnt; - d->vector = xnmalloc (d->vector_cnt, sizeof *d->vector); - for (i = 0; i < s->vector_cnt; i++) + d->n_vectors = s->n_vectors; + d->vector = xnmalloc (d->n_vectors, sizeof *d->vector); + for (size_t i = 0; i < s->n_vectors; i++) d->vector[i] = vector_clone (s->vector[i], s, d); dict_set_attributes (d, dict_get_attributes (s)); - for (i = 0; i < s->n_mrsets; i++) + for (size_t i = 0; i < s->n_mrsets; i++) { const struct mrset *old = s->mrsets[i]; struct mrset *new; @@ -333,13 +350,23 @@ dict_clone (const struct dictionary *s) dict_add_mrset (d, new); } - return d; -} + for (size_t i = 0; i < s->n_varsets; i++) + { + const struct varset *old = s->varsets[i]; + /* Clone old varset, then replace vars from D by vars from S. */ + struct varset *new = varset_clone (old); + for (size_t j = 0; j < new->n_vars; j++) + new->vars[j] = dict_lookup_var_assert (d, var_get_name (new->vars[j])); + + dict_add_varset (d, new); + } + return d; +} /* Returns the SPLIT FILE vars (see cmd_split_file()). Call - dict_get_split_cnt() to determine how many SPLIT FILE vars + dict_get_n_splits() to determine how many SPLIT FILE vars there are. Returns a null pointer if and only if there are no SPLIT FILE vars. */ const struct variable *const * @@ -350,9 +377,9 @@ dict_get_split_vars (const struct dictionary *d) /* Returns the number of SPLIT FILE vars. */ size_t -dict_get_split_cnt (const struct dictionary *d) +dict_get_n_splits (const struct dictionary *d) { - return d->split_cnt; + return d->n_splits; } /* Removes variable V, which must be in D, from D's set of split @@ -364,10 +391,10 @@ dict_unset_split_var (struct dictionary *d, struct variable *v, bool skip_callba assert (dict_contains_var (d, v)); - orig_count = d->split_cnt; - d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split, + orig_count = d->n_splits; + d->n_splits = remove_equal (d->split, d->n_splits, sizeof *d->split, &v, compare_var_ptrs, NULL); - if (orig_count != d->split_cnt && !skip_callbacks) + if (orig_count != d->n_splits && !skip_callbacks) { if (d->changed) d->changed (d, d->changed_data); /* We changed the set of split variables so invoke the @@ -378,26 +405,33 @@ dict_unset_split_var (struct dictionary *d, struct variable *v, bool skip_callba } -/* Sets CNT split vars SPLIT in dictionary D. */ +/* Sets N split vars SPLIT in dictionary D. N is silently capped to a maximum + of MAX_SPLITS. */ static void dict_set_split_vars__ (struct dictionary *d, - struct variable *const *split, size_t cnt, bool skip_callbacks) -{ - assert (cnt == 0 || split != NULL); - - d->split_cnt = cnt; - if (cnt > 0) - { - d->split = xnrealloc (d->split, cnt, sizeof *d->split) ; - memcpy (d->split, split, cnt * sizeof *d->split); - } + struct variable *const *split, size_t n, + enum split_type type, bool skip_callbacks) +{ + if (n > MAX_SPLITS) + n = MAX_SPLITS; + assert (n == 0 || split != NULL); + + d->n_splits = n; + d->split_type = (n == 0 ? SPLIT_NONE + : type == SPLIT_NONE ? SPLIT_LAYERED + : type); + if (n > 0) + { + d->split = xnrealloc (d->split, n, sizeof *d->split) ; + memcpy (d->split, split, n * sizeof *d->split); + } else - { - free (d->split); - d->split = NULL; - } + { + free (d->split); + d->split = NULL; + } - if (!skip_callbacks) + if (!skip_callbacks) { if (d->changed) d->changed (d, d->changed_data); if (d->callbacks && d->callbacks->split_changed) @@ -405,14 +439,26 @@ dict_set_split_vars__ (struct dictionary *d, } } -/* Sets CNT split vars SPLIT in dictionary D. */ +enum split_type +dict_get_split_type (const struct dictionary *d) +{ + return d->split_type; +} + +/* Sets N split vars SPLIT in dictionary D. */ void dict_set_split_vars (struct dictionary *d, - struct variable *const *split, size_t cnt) + struct variable *const *split, size_t n, + enum split_type type) { - dict_set_split_vars__ (d, split, cnt, false); + dict_set_split_vars__ (d, split, n, type, false); } +void +dict_clear_split_vars (struct dictionary *d) +{ + dict_set_split_vars (d, NULL, 0, SPLIT_NONE); +} /* Deletes variable V from dictionary D and frees V. @@ -432,12 +478,12 @@ static void dict_delete_var__ (struct dictionary *d, struct variable *v, bool skip_callbacks) { int dict_index = var_get_dict_index (v); - const int case_index = var_get_case_index (v); assert (dict_contains_var (d, v)); dict_unset_split_var (d, v, skip_callbacks); dict_unset_mrset_var (d, v); + dict_unset_varset_var (d, v); if (d->weight == v) dict_set_weight (d, NULL); @@ -448,12 +494,12 @@ dict_delete_var__ (struct dictionary *d, struct variable *v, bool skip_callbacks 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--; + unindex_vars (d, dict_index, d->n_vars); + remove_element (d->vars, d->n_vars, sizeof *d->vars, dict_index); + d->n_vars--; /* Update dict_index for each affected variable. */ - reindex_vars (d, dict_index, d->var_cnt, skip_callbacks); + reindex_vars (d, dict_index, d->n_vars, skip_callbacks); /* Free memory. */ var_clear_vardict (v); @@ -461,8 +507,8 @@ dict_delete_var__ (struct dictionary *d, struct variable *v, bool skip_callbacks if (! skip_callbacks) { if (d->changed) d->changed (d, d->changed_data); - if (d->callbacks && d->callbacks->var_deleted) - d->callbacks->var_deleted (d, v, dict_index, case_index, d->cb_data); + if (d->callbacks && d->callbacks->vars_deleted) + d->callbacks->vars_deleted (d, dict_index, 1, d->cb_data); } invalidate_proto (d); @@ -486,6 +532,7 @@ void dict_delete_var (struct dictionary *d, struct variable *v) { dict_delete_var__ (d, v, false); + dict_compact_values (d); } @@ -501,6 +548,7 @@ dict_delete_vars (struct dictionary *d, while (count-- > 0) dict_delete_var (d, *vars++); + dict_compact_values (d); } /* Deletes the COUNT variables in D starting at index IDX. This @@ -508,21 +556,20 @@ dict_delete_vars (struct dictionary *d, details. Deleting consecutive vars will result in less callbacks compared to iterating over dict_delete_var. A simple while loop over dict_delete_var will - produce (d->var_cnt - IDX) * COUNT variable changed callbacks + produce (d->n_vars - IDX) * COUNT variable changed callbacks plus COUNT variable delete callbacks. - This here produces d->var_cnt - IDX variable changed callbacks + This here produces d->n_vars - IDX variable changed callbacks plus COUNT variable delete callbacks. */ void dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count) { - assert (idx + count <= d->var_cnt); + assert (idx + count <= d->n_vars); /* We need to store the variable and the corresponding case_index for the delete callbacks later. We store them in a linked list.*/ struct delvar { struct ll ll; struct variable *var; - int case_index; }; struct ll_list list = LL_INITIALIZER (list); @@ -530,10 +577,11 @@ dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count) { struct delvar *dv = xmalloc (sizeof (struct delvar)); assert (dv); - struct variable *v = d->var[i].var; + struct variable *v = d->vars[i].var; dict_unset_split_var (d, v, false); dict_unset_mrset_var (d, v); + dict_unset_varset_var (d, v); if (d->weight == v) dict_set_weight (d, NULL); @@ -542,19 +590,18 @@ dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count) dict_set_filter (d, NULL); dv->var = v; - dv->case_index = var_get_case_index (v); ll_push_tail (&list, (struct ll *)dv); } dict_clear_vectors (d); /* Remove variables from var array. */ - unindex_vars (d, idx, d->var_cnt); - remove_range (d->var, d->var_cnt, sizeof *d->var, idx, count); - d->var_cnt -= count; + unindex_vars (d, idx, d->n_vars); + remove_range (d->vars, d->n_vars, sizeof *d->vars, idx, count); + d->n_vars -= count; /* Reindexing will result variable-changed callback */ - reindex_vars (d, idx, d->var_cnt, false); + reindex_vars (d, idx, d->n_vars, false); invalidate_proto (d); if (d->changed) d->changed (d, d->changed_data); @@ -563,15 +610,17 @@ dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count) the variables. The vardict is not valid at this point anymore. That is the reason why we stored the caseindex before reindexing. */ + if (d->callbacks && d->callbacks->vars_deleted) + d->callbacks->vars_deleted (d, idx, count, d->cb_data); for (size_t vi = idx; vi < idx + count; vi++) { struct delvar *dv = (struct delvar *) ll_pop_head (&list); var_clear_vardict (dv->var); - if (d->callbacks && d->callbacks->var_deleted) - d->callbacks->var_deleted (d, dv->var, vi, dv->case_index, d->cb_data); var_unref (dv->var); free (dv); } + + dict_compact_values (d); } /* Deletes scratch variables from dictionary D. */ @@ -582,11 +631,13 @@ dict_delete_scratch_vars (struct dictionary *d) /* FIXME: this can be done in O(count) time, but this algorithm is O(count**2). */ - for (i = 0; i < d->var_cnt;) - if (var_get_dict_class (d->var[i].var) == DC_SCRATCH) - dict_delete_var (d, d->var[i].var); + for (i = 0; i < d->n_vars;) + if (var_get_dict_class (d->vars[i].var) == DC_SCRATCH) + dict_delete_var (d, d->vars[i].var); else i++; + + dict_compact_values (d); } @@ -598,18 +649,17 @@ dict_clear__ (struct dictionary *d, bool skip_callbacks) { /* FIXME? Should we really clear case_limit, label, documents? Others are necessarily cleared by deleting all the variables.*/ - while (d->var_cnt > 0) + while (d->n_vars > 0) { - dict_delete_var__ (d, d->var[d->var_cnt - 1].var, skip_callbacks); + dict_delete_var__ (d, d->vars[d->n_vars - 1].var, skip_callbacks); } - free (d->var); - d->var = NULL; - d->var_cnt = d->var_cap = 0; + free (d->vars); + d->vars = NULL; + d->n_vars = d->allocated_vars = 0; invalidate_proto (d); hmap_clear (&d->name_map); - d->next_value_idx = 0; - dict_set_split_vars__ (d, NULL, 0, skip_callbacks); + dict_set_split_vars__ (d, NULL, 0, SPLIT_NONE, skip_callbacks); if (skip_callbacks) { @@ -650,6 +700,7 @@ _dict_destroy (struct dictionary *d) hmap_destroy (&d->name_map); attrset_destroy (&d->attributes); dict_clear_mrsets (d); + dict_clear_varsets (d); free (d->encoding); free (d); } @@ -674,42 +725,42 @@ dict_unref (struct dictionary *d) /* Returns the number of variables in D. */ size_t -dict_get_var_cnt (const struct dictionary *d) +dict_get_n_vars (const struct dictionary *d) { - return d->var_cnt; + return d->n_vars; } /* Returns the variable in D with dictionary index IDX, which must be between 0 and the count returned by - dict_get_var_cnt(), exclusive. */ + dict_get_n_vars(), exclusive. */ struct variable * dict_get_var (const struct dictionary *d, size_t idx) { - assert (idx < d->var_cnt); + assert (idx < d->n_vars); - return d->var[idx].var; + return d->vars[idx].var; } -/* Sets *VARS to an array of pointers to variables in D and *CNT +/* Sets *VARS to an array of pointers to variables in D and *N 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, enum dict_class exclude) + size_t *n, enum dict_class exclude) { - dict_get_vars_mutable (d, (struct variable ***) vars, cnt, exclude); + dict_get_vars_mutable (d, (struct variable ***) vars, n, exclude); } -/* Sets *VARS to an array of pointers to variables in D and *CNT +/* Sets *VARS to an array of pointers to variables in D and *N 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_mutable (const struct dictionary *d, struct variable ***vars, - size_t *cnt, enum dict_class exclude) + size_t *n, enum dict_class exclude) { size_t count; size_t i; @@ -717,22 +768,22 @@ dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars, assert (exclude == (exclude & DC_ALL)); count = 0; - for (i = 0; i < d->var_cnt; i++) + for (i = 0; i < d->n_vars; i++) { - enum dict_class class = var_get_dict_class (d->var[i].var); + enum dict_class class = var_get_dict_class (d->vars[i].var); if (!(class & exclude)) count++; } *vars = xnmalloc (count, sizeof **vars); - *cnt = 0; - for (i = 0; i < d->var_cnt; i++) + *n = 0; + for (i = 0; i < d->n_vars; i++) { - enum dict_class class = var_get_dict_class (d->var[i].var); + enum dict_class class = var_get_dict_class (d->vars[i].var); if (!(class & exclude)) - (*vars)[(*cnt)++] = d->var[i].var; + (*vars)[(*n)++] = d->vars[i].var; } - assert (*cnt == count); + assert (*n == count); } static struct variable * @@ -741,24 +792,22 @@ add_var_with_case_index (struct dictionary *d, struct variable *v, { struct vardict_info *vardict; - assert (case_index >= d->next_value_idx); - /* Update dictionary. */ - if (d->var_cnt >= d->var_cap) + if (d->n_vars >= d->allocated_vars) { size_t i; - d->var = x2nrealloc (d->var, &d->var_cap, sizeof *d->var); + d->vars = x2nrealloc (d->vars, &d->allocated_vars, sizeof *d->vars); hmap_clear (&d->name_map); - for (i = 0; i < d->var_cnt; i++) + for (i = 0; i < d->n_vars; 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); + var_set_vardict (d->vars[i].var, &d->vars[i]); + hmap_insert_fast (&d->name_map, &d->vars[i].name_node, + d->vars[i].name_node.hash); } } - vardict = &d->var[d->var_cnt++]; + vardict = &d->vars[d->n_vars++]; vardict->dict = d; vardict->var = v; hmap_insert (&d->name_map, &vardict->name_node, @@ -771,7 +820,6 @@ add_var_with_case_index (struct dictionary *d, struct variable *v, d->callbacks->var_added (d, var_get_dict_index (v), d->cb_data); invalidate_proto (d); - d->next_value_idx = case_index + 1; return v; } @@ -779,7 +827,7 @@ add_var_with_case_index (struct dictionary *d, struct variable *v, static struct variable * add_var (struct dictionary *d, struct variable *v) { - return add_var_with_case_index (d, v, d->next_value_idx); + return add_var_with_case_index (d, v, dict_get_n_vars (d)); } /* Creates and returns a new variable in D with the given NAME @@ -904,10 +952,10 @@ 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); + assert (new_index < d->n_vars); 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); + move_element (d->vars, d->n_vars, sizeof *d->vars, old_index, new_index); reindex_vars (d, MIN (old_index, new_index), MAX (old_index, new_index) + 1, false); } @@ -923,9 +971,9 @@ dict_reorder_vars (struct dictionary *d, size_t i; assert (count == 0 || order != NULL); - assert (count <= d->var_cnt); + assert (count <= d->n_vars); - new_var = xnmalloc (d->var_cap, sizeof *new_var); + new_var = xnmalloc (d->allocated_vars, sizeof *new_var); /* Add variables in ORDER to new_var. */ for (i = 0; i < count; i++) @@ -940,17 +988,17 @@ dict_reorder_vars (struct dictionary *d, } /* Add remaining variables to new_var. */ - for (i = 0; i < d->var_cnt; i++) - if (d->var[i].dict != NULL) - new_var[count++] = d->var[i]; - assert (count == d->var_cnt); + for (i = 0; i < d->n_vars; i++) + if (d->vars[i].dict != NULL) + new_var[count++] = d->vars[i]; + assert (count == d->n_vars); /* Replace old vardicts by new ones. */ - free (d->var); - d->var = new_var; + free (d->vars); + d->vars = new_var; hmap_clear (&d->name_map); - reindex_vars (d, 0, d->var_cnt, false); + reindex_vars (d, 0, d->n_vars, false); } /* Changes the name of variable V that is currently in a dictionary to @@ -1239,7 +1287,7 @@ dict_get_weight (const struct dictionary *d) } /* Returns the value of D's weighting variable in case C, except - that a negative weight is returned as 0. Returns 1 if the + that a negative or missing 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 @@ -1260,11 +1308,20 @@ dict_get_case_weight (const struct dictionary *d, const struct ccase *c, } } +/* Like dict_get_case_weight(), but additionally rounds each weight to the + nearest integer. */ +double +dict_get_rounded_case_weight (const struct dictionary *d, + const struct ccase *c, bool *warn_on_invalid) +{ + return floor (dict_get_case_weight (d, c, warn_on_invalid) + 0.5); +} + /* Returns the format to use for weights. */ -const struct fmt_spec * +struct fmt_spec dict_get_weight_format (const struct dictionary *d) { - return d->weight ? var_get_print_format (d->weight) : &F_8_0; + return d->weight ? var_get_print_format (d->weight) : F_8_0; } /* Sets the weighting variable of D to V, or turning off @@ -1334,108 +1391,55 @@ dict_get_proto (const struct dictionary *d_) struct dictionary *d = CONST_CAST (struct dictionary *, d_); if (d->proto == NULL) { - size_t i; + short int *widths = xnmalloc (d->n_vars, sizeof *widths); + for (size_t i = 0; i < d->n_vars; i++) + widths[i] = -1; + for (size_t i = 0; i < d->n_vars; i++) + { + const struct variable *var = d->vars[i].var; + size_t case_idx = var_get_case_index (var); + assert (case_idx < d->n_vars); + assert (widths[case_idx] == -1); + widths[case_idx] = var_get_width (var); + } - 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)); + d->proto = caseproto_from_widths (widths, d->n_vars); } 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) -{ - return d->next_value_idx; -} - -/* Returns the number of bytes needed to store a case for - dictionary D. */ -size_t -dict_get_case_size (const struct dictionary *d) -{ - return sizeof (union value) * dict_get_next_value_idx (d); -} - /* 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; i++) + for (size_t i = 0; i < d->n_vars; i++) { - struct variable *v = d->var[i].var; - set_var_case_index (v, d->next_value_idx++); + struct variable *v = d->vars[i].var; + set_var_case_index (v, i); } 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. - - 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. */ + is 0, or it may contain one or more of DC_ORDINARY, DC_SYSTEM, + or DC_SCRATCH to exclude the corresponding type of variable. */ size_t dict_count_values (const struct dictionary *d, unsigned int exclude_classes) { - size_t i; - size_t cnt; - - assert ((exclude_classes & ~((1u << DC_ORDINARY) - | (1u << DC_SYSTEM) - | (1u << DC_SCRATCH))) == 0); + assert (!(exclude_classes & ~DC_ALL)); - cnt = 0; - for (i = 0; i < d->var_cnt; i++) + size_t n = 0; + for (size_t i = 0; i < d->n_vars; i++) { - enum dict_class class = var_get_dict_class (d->var[i].var); - if (!(exclude_classes & (1u << class))) - cnt++; + enum dict_class class = var_get_dict_class (d->vars[i].var); + if (!(exclude_classes & class)) + n++; } - return cnt; + return n; } -/* 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(). - - 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 caseproto *proto; - size_t i; - - assert ((exclude_classes & ~((1u << DC_ORDINARY) - | (1u << DC_SYSTEM) - | (1u << DC_SCRATCH))) == 0); - - proto = caseproto_create (); - for (i = 0; i < d->var_cnt; i++) - { - 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; -} /* Returns the file label for D, or a null pointer if D is unlabeled (see cmd_file_label()). */ const char * @@ -1471,12 +1475,15 @@ dict_get_documents (const struct dictionary *d) void dict_set_documents (struct dictionary *d, const struct string_array *new_docs) { - size_t i; + /* Swap out the old documents, instead of destroying them immediately, to + allow the new documents to include pointers into the old ones. */ + struct string_array old_docs = STRING_ARRAY_INITIALIZER; + string_array_swap (&d->documents, &old_docs); - dict_clear_documents (d); - - for (i = 0; i < new_docs->n; i++) + for (size_t i = 0; i < new_docs->n; i++) dict_add_document_line (d, new_docs->strings[i], false); + + string_array_destroy (&old_docs); } /* Replaces the documents for D by UTF-8 encoded string NEW_DOCS, dividing it @@ -1523,7 +1530,7 @@ dict_add_document_line (struct dictionary *d, const char *line, truncated = line[trunc_len] != '\0'; if (truncated && issue_warning) { - /* Note to translators: "bytes" is correct, not characters */ + /* TRANSLATORS: "bytes" is correct, not characters due to UTF encoding */ msg (SW, _("Truncating document line to %d bytes."), DOC_LINE_LENGTH); } @@ -1534,7 +1541,7 @@ dict_add_document_line (struct dictionary *d, const char *line, /* Returns the number of document lines in dictionary D. */ size_t -dict_get_document_line_cnt (const struct dictionary *d) +dict_get_document_n_lines (const struct dictionary *d) { return d->documents.n; } @@ -1548,57 +1555,55 @@ dict_get_document_line (const struct dictionary *d, size_t idx) return d->documents.strings[idx]; } -/* Creates in D a vector named NAME that contains the CNT +/* Creates in D a vector named NAME that contains the N variables in VAR. Returns true if successful, or false if a vector named NAME already exists in D. */ bool dict_create_vector (struct dictionary *d, const char *name, - struct variable **var, size_t cnt) + struct variable **var, size_t n) { - size_t i; - - assert (cnt > 0); - for (i = 0; i < cnt; i++) + assert (n > 0); + for (size_t i = 0; i < n; i++) assert (dict_contains_var (d, var[i])); if (dict_lookup_vector (d, name) == NULL) { - d->vector = xnrealloc (d->vector, d->vector_cnt + 1, sizeof *d->vector); - d->vector[d->vector_cnt++] = vector_create (name, var, cnt); + d->vector = xnrealloc (d->vector, d->n_vectors + 1, sizeof *d->vector); + d->vector[d->n_vectors++] = vector_create (name, var, n); return true; } else return false; } -/* Creates in D a vector named NAME that contains the CNT +/* Creates in D a vector named NAME that contains the N variables in VAR. A vector named NAME must not already exist in D. */ void dict_create_vector_assert (struct dictionary *d, const char *name, - struct variable **var, size_t cnt) + struct variable **var, size_t n) { assert (dict_lookup_vector (d, name) == NULL); - dict_create_vector (d, name, var, cnt); + dict_create_vector (d, name, var, n); } /* Returns the vector in D with index IDX, which must be less - than dict_get_vector_cnt (D). */ + than dict_get_n_vectors (D). */ const struct vector * dict_get_vector (const struct dictionary *d, size_t idx) { - assert (idx < d->vector_cnt); + assert (idx < d->n_vectors); return d->vector[idx]; } /* Returns the number of vectors in D. */ size_t -dict_get_vector_cnt (const struct dictionary *d) +dict_get_n_vectors (const struct dictionary *d) { - return d->vector_cnt; + return d->n_vectors; } /* Looks up and returns the vector within D with the given @@ -1607,7 +1612,7 @@ const struct vector * dict_lookup_vector (const struct dictionary *d, const char *name) { size_t i; - for (i = 0; i < d->vector_cnt; i++) + for (i = 0; i < d->n_vectors; i++) if (!utf8_strcasecmp (vector_get_name (d->vector[i]), name)) return d->vector[i]; return NULL; @@ -1619,12 +1624,12 @@ dict_clear_vectors (struct dictionary *d) { size_t i; - for (i = 0; i < d->vector_cnt; i++) + for (i = 0; i < d->n_vectors; i++) vector_destroy (d->vector[i]); free (d->vector); d->vector = NULL; - d->vector_cnt = 0; + d->n_vectors = 0; } /* Multiple response sets. */ @@ -1758,6 +1763,97 @@ dict_unset_mrset_var (struct dictionary *dict, struct variable *var) } } + +/* Returns the variable set in DICT with index IDX, which must be between 0 and + the count returned by dict_get_n_varsets(), exclusive. */ +const struct varset * +dict_get_varset (const struct dictionary *dict, size_t idx) +{ + assert (idx < dict->n_varsets); + return dict->varsets[idx]; +} + +/* Returns the number of variable sets in DICT. */ +size_t +dict_get_n_varsets (const struct dictionary *dict) +{ + return dict->n_varsets; +} + +/* Looks for a variable set named NAME in DICT. If it finds one, returns its + index; otherwise, returns SIZE_MAX. */ +static size_t +dict_lookup_varset_idx (const struct dictionary *dict, const char *name) +{ + for (size_t i = 0; i < dict->n_varsets; i++) + if (!utf8_strcasecmp (name, dict->varsets[i]->name)) + return i; + + return SIZE_MAX; +} + +/* Looks for a multiple response set named NAME in DICT. If it finds one, + returns it; otherwise, returns NULL. */ +const struct varset * +dict_lookup_varset (const struct dictionary *dict, const char *name) +{ + size_t idx = dict_lookup_varset_idx (dict, name); + return idx != SIZE_MAX ? dict->varsets[idx] : NULL; +} + +/* Adds VARSET to DICT, replacing any existing set with the same name. Returns + true if a set was replaced, false if none existed with the specified name. + + Ownership of VARSET is transferred to DICT. */ +bool +dict_add_varset (struct dictionary *dict, struct varset *varset) +{ + size_t idx = dict_lookup_varset_idx (dict, varset->name); + if (idx == SIZE_MAX) + { + dict->varsets = xrealloc (dict->varsets, + (dict->n_varsets + 1) * sizeof *dict->varsets); + dict->varsets[dict->n_varsets++] = varset; + return true; + } + else + { + varset_destroy (dict->varsets[idx]); + dict->varsets[idx] = varset; + return false; + } +} + +/* Deletes all variable sets from DICT. */ +void +dict_clear_varsets (struct dictionary *dict) +{ + for (size_t i = 0; i < dict->n_varsets; i++) + varset_destroy (dict->varsets[i]); + free (dict->varsets); + dict->varsets = NULL; + dict->n_varsets = 0; +} + +/* Removes VAR, which must be in DICT, from DICT's multiple response sets. */ +static void +dict_unset_varset_var (struct dictionary *dict, struct variable *var) +{ + assert (dict_contains_var (dict, var)); + + for (size_t i = 0; i < dict->n_varsets; i++) + { + struct varset *varset = dict->varsets[i]; + + for (size_t j = 0; j < varset->n_vars;) + if (varset->vars[j] == var) + remove_element (varset->vars, varset->n_vars--, + sizeof *varset->vars, j); + else + j++; + } +} + /* 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 @@ -1810,58 +1906,9 @@ dict_var_changed (const struct variable *v, unsigned int what, struct variable * } - -/* Dictionary used to contain "internal variables". */ -static struct dictionary *internal_dict; - -/* 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 ("UTF-8"); - - 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_unref (internal_dict); - internal_dict = NULL; - } - } -} int vardict_get_dict_index (const struct vardict_info *vardict) { - return vardict - vardict->dict->var; + return vardict - vardict->dict->vars; }