X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fdictionary.c;h=b5b6cca58f19bbf1732eae911379f0d4606caf3f;hb=537fdeb3702c011e05d7826a8d556a7beeba2605;hp=155d4bf4328501f07c7f7bebcfabb89883d3146a;hpb=51b0b4e017ccaa3a72000265080122a8db616992;p=pspp-builds.git diff --git a/src/data/dictionary.c b/src/data/dictionary.c index 155d4bf4..b5b6cca5 100644 --- a/src/data/dictionary.c +++ b/src/data/dictionary.c @@ -21,15 +21,17 @@ #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 +#include #include +#include #include #include #include @@ -37,7 +39,9 @@ #include #include +#include "intprops.h" #include "minmax.h" +#include "xalloc.h" #include "gettext.h" #define _(msgid) gettext (msgid) @@ -53,16 +57,48 @@ struct dictionary 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) + d->encoding = strdup (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; +} + + /* Print a representation of dictionary D to stdout, for debugging purposes. */ void @@ -112,11 +148,18 @@ dict_create (void) d->name_tab = hsh_create (8, compare_vars_by_name, hash_var_by_name, NULL, NULL); + 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) { @@ -129,12 +172,19 @@ dict_clone (const struct dictionary *s) for (i = 0; i < s->var_cnt; i++) { + const struct vardict_info *svdi; + struct vardict_info dvdi; struct variable *sv = s->var[i]; struct variable *dv = dict_clone_var_assert (d, sv, var_get_name (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)); + + svdi = var_get_vardict (sv); + dvdi = *svdi; + dvdi.dict = d; + var_set_vardict (dv, &dvdi); } d->next_value_idx = s->next_value_idx; @@ -162,6 +212,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 = strdup (s->encoding); + + dict_set_attributes (d, dict_get_attributes (s)); + return d; } @@ -176,20 +231,7 @@ dict_clear (struct dictionary *d) 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]); } free (d->var); @@ -205,6 +247,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 @@ -232,6 +275,7 @@ dict_destroy (struct dictionary *d) dict_clear (d); hsh_destroy (d->name_tab); + attrset_destroy (&d->attributes); free (d); } } @@ -257,21 +301,26 @@ dict_get_var (const struct dictionary *d, size_t idx) return d->var[idx]; } -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; @@ -279,15 +328,13 @@ dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars, 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]); + if (!(class & exclude)) count++; } @@ -295,8 +342,8 @@ 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))) + enum dict_class class = var_get_dict_class (d->var[i]); + if (!(class & exclude)) (*vars)[(*cnt)++] = d->var[i]; } assert (*cnt == count); @@ -321,6 +368,7 @@ add_var (struct dictionary *d, struct variable *v) d->var[d->var_cnt++] = v; hsh_force_insert (d->name_tab, v); + 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); @@ -393,6 +441,12 @@ dict_lookup_var (const struct dictionary *d, const char *name) result = hsh_find (d->name_tab, target); var_destroy (target); + if ( result && var_has_vardict (result)) + { + const struct vardict_info *vdi = var_get_vardict (result); + assert (vdi->dict == d); + } + return result; } @@ -442,6 +496,7 @@ set_var_dict_index (struct variable *v, int dict_index) vdi.dict_index = dict_index; var_set_vardict (v, &vdi); + 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); } @@ -474,7 +529,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, @@ -516,6 +571,7 @@ dict_delete_var (struct dictionary *d, struct variable *v) var_clear_vardict (v); var_destroy (v); + if ( d->changed ) d->changed (d, d->changed_data); if (d->callbacks && d->callbacks->var_deleted ) d->callbacks->var_deleted (d, dict_index, case_index, val_cnt, d->cb_data); } @@ -560,7 +616,7 @@ dict_delete_scratch_vars (struct dictionary *d) assert (d != NULL); for (i = 0; i < d->var_cnt; ) - if (dict_class_from_id (var_get_name (d->var[i])) == DC_SCRATCH) + if (var_get_dict_class (d->var[i]) == DC_SCRATCH) dict_delete_var (d, d->var[i]); else i++; @@ -643,9 +699,10 @@ dict_rename_var (struct dictionary *d, struct variable *v, rename_var (d, v, new_name); hsh_force_insert (d->name_tab, v); - if (get_algorithm () == ENHANCED) + 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); } @@ -708,7 +765,7 @@ dict_rename_vars (struct dictionary *d, } /* Clear short names. */ - if (get_algorithm () == ENHANCED) + if (settings_get_algorithm () == ENHANCED) for (i = 0; i < count; i++) var_clear_short_names (vars[i]); @@ -716,6 +773,123 @@ dict_rename_vars (struct dictionary *d, 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 * @@ -727,11 +901,12 @@ dict_get_weight (const struct dictionary *d) 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) @@ -767,6 +942,7 @@ dict_set_weight (struct dictionary *d, struct variable *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, @@ -791,9 +967,11 @@ 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, @@ -802,7 +980,7 @@ 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); @@ -813,7 +991,7 @@ dict_get_case_limit (const struct dictionary *d) /* 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); @@ -906,7 +1084,7 @@ dict_count_values (const struct dictionary *d, unsigned int exclude_classes) cnt = 0; for (i = 0; i < d->var_cnt; i++) { - enum dict_class class = dict_class_from_id (var_get_name (d->var[i])); + enum dict_class class = var_get_dict_class (d->var[i]); if (!(exclude_classes & (1u << class))) cnt += var_get_value_cnt (d->var[i]); } @@ -934,20 +1112,26 @@ dict_get_split_cnt (const struct dictionary *d) 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. */ @@ -959,9 +1143,18 @@ dict_set_split_vars (struct dictionary *d, 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); } @@ -984,16 +1177,7 @@ 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 @@ -1149,6 +1333,32 @@ dict_clear_vectors (struct dictionary *d) d->vector_cnt = 0; } +/* 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 (struct attrset *) &d->attributes; +} + +/* Replaces D's attributes set by a copy of ATTRS. */ +void +dict_set_attributes (struct dictionary *d, const struct attrset *attrs) +{ + attrset_destroy (&d->attributes); + attrset_clone (&d->attributes, attrs); +} + +/* 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) +{ + return attrset_count (&d->attributes) > 0; +} + /* Called from variable.c to notify the dictionary that some property of the variable has changed */ void @@ -1157,10 +1367,12 @@ dict_var_changed (const struct variable *v) if ( var_has_vardict (v)) { const struct vardict_info *vdi = var_get_vardict (v); - struct dictionary *d; + struct dictionary *d = vdi->dict; - d = vdi->dict; + if ( NULL == d) + return; + 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); } @@ -1181,7 +1393,27 @@ dict_var_resized (const struct variable *v, int delta) 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_resized ) d->callbacks->var_resized (d, var_get_dict_index (v), delta, d->cb_data); } } + +/* Called from variable.c to notify the dictionary that the variable's display width + has changed */ +void +dict_var_display_width_changed (const struct variable *v) +{ + if ( var_has_vardict (v)) + { + const struct vardict_info *vdi = var_get_vardict (v); + struct dictionary *d; + + d = vdi->dict; + + 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); + } +} +