X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fdictionary.c;h=caf8e2fc3490cc81968197e732b74f45a5aa14f3;hb=a1b98c15156a32b058294ba4f5c54fb745550222;hp=85b6a34909f0550a5ad9343d6abdf5608082e554;hpb=9b94efd7513afdb12a6023024e00e50801532fee;p=pspp diff --git a/src/data/dictionary.c b/src/data/dictionary.c index 85b6a34909..caf8e2fc34 100644 --- a/src/data/dictionary.c +++ b/src/data/dictionary.c @@ -21,14 +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 @@ -36,6 +39,7 @@ #include #include +#include "intprops.h" #include "minmax.h" #include "xalloc.h" @@ -58,6 +62,7 @@ struct dictionary 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. */ const struct dict_callbacks *callbacks; /* Callbacks on dictionary modification */ void *cb_data ; /* Data passed to callbacks */ @@ -112,6 +117,7 @@ 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; } @@ -175,6 +181,8 @@ dict_clone (const struct dictionary *s) for (i = 0; i < s->vector_cnt; i++) d->vector[i] = vector_clone (s->vector[i], s, d); + dict_set_attributes (d, dict_get_attributes (s)); + return d; } @@ -205,6 +213,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 +241,7 @@ dict_destroy (struct dictionary *d) dict_clear (d); hsh_destroy (d->name_tab); + attrset_destroy (&d->attributes); free (d); } } @@ -726,6 +736,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 * @@ -1165,6 +1292,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